cdk-nextjs 0.6.2 → 0.7.1

package/lib/nextjs-build/nextjs-build.js

@@ -4,30 +4,91 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NextjsBuild = void 0;
+exports.deploymentArchitecture = deploymentArchitecture;
+exports.deploymentBuildId = deploymentBuildId;
+exports.pickStagedSharpPackage = pickStagedSharpPackage;
+exports.resolveNextSharp = resolveNextSharp;
+exports.isSharpBinaryPackage = isSharpBinaryPackage;
+exports.sharpBinaryDir = sharpBinaryDir;
+exports.listTree = listTree;
+exports.writePublicFileList = writePublicFileList;
+exports.storedSize = storedSize;
+exports.patchClientChunk = patchClientChunk;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const posix_1 = require("node:path/posix");
 const constructs_1 = require("constructs");
 // eslint-disable-next-line import/no-extraneous-dependencies
 const debug_1 = __importDefault(require("debug"));
+const function_groups_1 = require("../adapter/function-groups");
 const constants_1 = require("../constants");
+const manifest_1 = require("../runtime/manifest");
+const public_files_1 = require("../runtime/public-files");
 const base_path_1 = require("../utils/base-path");
-const experimental_flags_1 = require("../utils/experimental-flags");
 const get_architecture_1 = require("../utils/get-architecture");
+/**
+ * Lambda's hard limit on the unzipped size of a function's code, which
+ * CloudFormation only enforces at deploy time. Measured at synth instead, so the
+ * error names the group and arrives in seconds rather than minutes.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html
+ */
+const LAMBDA_UNZIPPED_LIMIT_BYTES = 250 * 1024 * 1024;
+/**
+ * Opens the patch `patchFetchInClientJs` prepends to a client chunk, followed by
+ * a hash of the patch itself, so a second synth over the same `.next` is a no-op
+ * while one by a cdk-nextjs with a different `patch-fetch.js` replaces it.
+ */
+const PATCH_FETCH_MARKER = "/* cdk-nextjs:patch-fetch";
+/** Closes the prepended patch; the chunk's own content starts after it. */
+const PATCH_FETCH_END_MARKER = "/* cdk-nextjs:patch-fetch:end */";
 const debug = (0, debug_1.default)("cdk-nextjs:nextjs-build");
+/**
+ * What every deployment root is staged for: the build's `architecture`, else
+ * the synth machine's. Containers ignore it: Docker builds their image
+ * natively, so it can only match the synth machine.
+ */
+function deploymentArchitecture(props) {
+    const isFunctions = props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS ||
+        props.nextjsType === constants_1.NextjsType.REGIONAL_FUNCTIONS;
+    return (isFunctions && props.architecture) || (0, get_architecture_1.getLambdaArchitecture)();
+}
+/** {@link NextjsBuild.buildId}: Next.js's build ID, suffixed with the app's `deploymentId`. */
+function deploymentBuildId(manifest) {
+    const { deploymentId } = manifest.config;
+    return deploymentId
+        ? `${manifest.buildId}-${deploymentId}`
+        : manifest.buildId;
+}
 /**
  * Builds Next.js assets.
  * @link https://nextjs.org/docs/pages/api-reference/next-config-js/output
  */
 class NextjsBuild extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsBuild", version: "0.6.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk-nextjs.NextjsBuild", version: "0.7.1" };
     /**
-     * Unique id for Next.js build. Used to partition cache storage and as
+     * Unique id for this deployment. Used to partition cache storage and as
      * metadata for static assets in S3 bucket.
+     *
+     * Next.js's build ID, suffixed with the app's `deploymentId` when it sets
+     * one. The build ID alone is not unique per deployment: setting
+     * `deploymentId` (or building with `NEXT_DEPLOYMENT_ID`) turns on skew
+     * protection, and next.js then *pins* the build ID to the constant
+     * `build-TfctsWXpff2fKS` — see `getBuildId` in `next/dist/build/index.js`,
+     * which does that deliberately so that tooling doing
+     * `.replace(escapedBuildId, …)` still has something to replace. Two
+     * successive deployments of such an app would share one cache prefix and one
+     * revalidation-table partition, and the new one would read the previous
+     * one's prerenders. Appending the deployment ID restores the "one
+     * deployment, one partition" invariant that ID exists to carry.
+     *
+     * Nothing routes on this value — the `/_next/data/<buildId>/…` URL space is
+     * routed on Next.js's own build ID, which is what the app's client bundles
+     * carry — so it is free to be longer than next.js's own.
      */
     buildId;
     /**
@@ -41,39 +102,71 @@ class NextjsBuild extends constructs_1.Construct {
      */
     publicDirEntries;
     /**
-     * The entrypoint JavaScript file used as an argument for Node.js to run the
-     * Next.js standalone server relative to the standalone directory.
-     * @example "./server.js"
-     * @example "./packages/ui/server.js" (monorepo)
+     * The JavaScript file Node.js runs to serve requests, relative to the
+     * deployment root. cdk-nextjs's own container shell, not `next build` output,
+     * so it is the same path for every app.
+     * @example "cdk-nextjs-runtime/server.mjs"
      */
     relativePathToEntrypoint;
-    /**
-     * Relative path from the standalone directory to the package containing the Next.js app.
-     * This is automatically detected from the standalone build output.
-     * @example "." for non-monorepo apps
-     * @example "./apps/web" for monorepo apps
-     */
-    relativePathToPackage;
     /**
      * Absolute path to the .next directory containing Next.js build artifacts
      */
     dotNextPath;
     /**
      * The Next.js app's own `basePath` — the URL prefix it generates its links and
-     * asset hrefs under — read out of the build's `required-server-files.json`.
-     * Normalized to a bare path segment, empty when the app sets none. Exposed so
+     * asset hrefs under — as the adapter manifest recorded it. Normalized to a bare path segment, empty when the app sets none. Exposed so
      * root constructs can reconcile it with the CDK `basePath` prop, which is a
      * distinct thing; see `resolveBasePath`.
      */
     nextConfigBasePath;
     /**
-     * Absolute path to the directory prepared for the image optimization Lambda
-     * asset: bundled handler, glibc `sharp` binaries, and `required-server-files.json`.
-     * Only set for {@link NextjsType.GLOBAL_FUNCTIONS} and
-     * {@link NextjsType.REGIONAL_FUNCTIONS}, and only when the dedicated image
-     * optimization Lambda is enabled.
+     * The Next.js app's own `assetPrefix`, as a path with a leading slash and no
+     * trailing one, empty when the app sets none or sets an absolute URL (which
+     * names an origin cdk-nextjs does not serve).
+     *
+     * Exposed because it is the shape of `assetPrefix` the regional
+     * `NextjsType`s cannot serve — see `warnUnservedAssetPrefix`. What the
+     * distribution has to answer on is {@link nextConfigAssetPrefixPath}, which
+     * also covers the path an absolute prefix carries.
+     */
+    nextConfigAssetPrefix;
+    /**
+     * The path portion of the app's `assetPrefix`, whichever form it takes: "/cdn"
+     * for both `assetPrefix: "/cdn"` and `assetPrefix:
+     * "https://cdn.example.com/cdn"`, empty when there is no path to answer on.
+     *
+     * Exposed because it is a URL prefix the distribution has to answer on: Next.js
+     * emits `<assetPrefix>/_next/static/...` for every bundle and compiles a rewrite
+     * that serves those URLs' paths itself, while the objects live in S3 under
+     * `<basePath>/_next/static/...`.
+     */
+    nextConfigAssetPrefixPath;
+    /**
+     * Every staged deployment root, one per function group, `default` first: the
+     * staged union of each group's shipped outputs and their traced assets,
+     * written by the adapter's `onBuildComplete`. Exactly one entry (named
+     * `default`, at `.next/cdk-nextjs-adapter/app`) unless `functionGroups`
+     * splits the app. The Lambda zip assets; Containers `COPY` the `default` one.
      */
-    imageOptimizationAssetPath;
+    deploymentRoots;
+    /**
+     * What routes each non-default function group's URLs to it, most specific
+     * first — the order CloudFront has to see them in, since it stops at the
+     * first match. Empty unless `functionGroups` splits the app.
+     */
+    functionGroupBehaviors;
+    /**
+     * From the deployment root to the Next.js project dir, POSIX, `""` when
+     * the app is at the repo root. The runtime `chdir`s here; Containers pass it to
+     * their Dockerfile so `.next/static` and `public` land in the same place.
+     * @see AdapterManifest.relativeProjectDir
+     */
+    relativeProjectDir;
+    /**
+     * The architecture every deployment root's native dependencies (`sharp`)
+     * were staged for. The Lambdas deploying them must use the same one.
+     */
+    architecture;
     props;
     buildCommand;
     constructor(scope, id, props) {
@@ -83,6 +176,14 @@ class NextjsBuild extends constructs_1.Construct {
         this.buildCommand = props.buildCommand || "npm run build";
         // Set init cache directory path
         this.initCacheDir = (0, node_path_1.join)(props.buildDirectory, ".next", "cdk-nextjs-init-cache");
+        // Before the build, not after it: the build is minutes long, and the env var
+        // it passes groups through is only set for a non-empty array — so an invalid
+        // `functionGroups` (an empty array, a reserved name, a group owning no
+        // routes) would otherwise be reported as "the build staged the wrong
+        // groups", after paying for the build, instead of as the prop error it is.
+        if (props.functionGroups) {
+            (0, function_groups_1.validateFunctionGroups)(props.functionGroups);
+        }
         // Execute local build process
         if (props.skipBuild !== true) {
             this.runNextBuild();
@@ -90,36 +191,247 @@ class NextjsBuild extends constructs_1.Construct {
         else {
             debug(`${constants_1.LOG_PREFIX} Skipping: ${this.buildCommand}`);
         }
-        // Validate build output and set validated paths
-        this.validateNextBuildOutput();
-        // Auto-detect relativePathToPackage from standalone build output
-        this.relativePathToPackage = this.findRelativePathToServerJs();
-        // Set entrypoint path using detected relativePathToPackage
-        this.relativePathToEntrypoint = (0, posix_1.join)(this.relativePathToPackage === "." ? "" : this.relativePathToPackage, "server.js");
-        this.buildId = this.getBuildId();
+        // First, before anything else reads `.next`: a missing manifest is the one
+        // error that names the cause (no build, or one without the adapter), where
+        // every later read fails with a bare ENOENT.
+        const manifest = this.readAdapterManifest();
+        // Deliberately outside the `skipBuild` gate. The patch is a property of
+        // *serving* through CloudFront, not of who ran `next build`: without it
+        // every POST with a body is rejected by the Lambda Function URL before it
+        // reaches the app (see `patchFetchInClientJs`). Running it only inside
+        // `runNextBuild` meant `skipBuild: true` silently shipped an app whose
+        // server actions and POST route handlers all returned 403.
+        if (props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS) {
+            this.patchFetchInClientJs();
+        }
+        this.buildId = deploymentBuildId(manifest);
         this.publicDirEntries = this.getLocalPublicDirEntries();
-        this.nextConfigBasePath = (0, base_path_1.readNextConfigBasePath)(this.dotNextPath);
-        const standalonePath = (0, node_path_1.join)(this.dotNextPath, "standalone");
+        // Next.js's resolved config, the same one it writes into
+        // `required-server-files.json`.
+        this.nextConfigBasePath = (0, base_path_1.normalizeBasePath)(manifest.config.basePath);
+        this.nextConfigAssetPrefix = (0, base_path_1.relativeAssetPrefix)(manifest.config.assetPrefix);
+        this.nextConfigAssetPrefixPath = (0, base_path_1.assetPrefixPath)(manifest.config.assetPrefix);
         const isFunctions = props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS ||
             props.nextjsType === constants_1.NextjsType.REGIONAL_FUNCTIONS;
-        const dedicatedImageFunction = isFunctions && (0, experimental_flags_1.useDedicatedImageFunction)();
-        // Strip whatever platform-specific Sharp binaries `next build`'s output
-        // file tracing bundled in either way, since they're the host's (e.g.
-        // macOS/glibc) rather than the deployment target's.
-        this.removeExistingSharpBinaries(standalonePath);
-        // The standalone server serves `_next/image` itself unless a dedicated
-        // image optimization Lambda takes over that route, and it runs on
-        // node:24-alpine (see functions.Dockerfile) / the same Alpine base for
-        // Containers, so it needs musl binaries. Skipping this install when Sharp
-        // *is* invoked from the server is silent: `imageOptimizer` catches the
-        // load failure internally and returns the unoptimized original with an
-        // HTTP 200.
-        if (!dedicatedImageFunction) {
-            this.downloadAndInstallSharpBinaries();
+        this.relativeProjectDir = manifest.relativeProjectDir;
+        this.relativePathToEntrypoint = (0, posix_1.join)(manifest_1.RUNTIME_DIR_NAME, "server.mjs");
+        this.architecture = deploymentArchitecture(props);
+        this.deploymentRoots = this.resolveDeploymentRoots(manifest);
+        this.functionGroupBehaviors = manifest.behaviors ?? [];
+        // Only the RegionalContainers image carries `public/`: nothing is in front
+        // of it to answer those paths from S3. Every other type lists it here and
+        // reads a file the edge didn't route to S3 (a rewrite onto it) from there.
+        const publicOnDisk = props.nextjsType === constants_1.NextjsType.REGIONAL_CONTAINERS;
+        if (publicOnDisk) {
+            // Its generated Dockerfile `COPY`s `public`, which fails the image build
+            // when the app has none. An empty directory is what `next start` sees
+            // for an app without one anyway, and git doesn't track it.
+            (0, node_fs_1.mkdirSync)((0, node_path_1.join)(props.buildDirectory, "public"), { recursive: true });
+        }
+        for (const root of this.deploymentRoots) {
+            this.stageRuntime(root.path, isFunctions, publicOnDisk);
+            // Functions run on the Lambda managed runtime (Amazon Linux 2023, glibc),
+            // for the architecture their Lambda deploys, whatever this machine is;
+            // Containers run on node:24-alpine (musl).
+            this.stageSharpForTarget(root, (0, node_path_1.join)(root.path, this.relativeProjectDir), `${isFunctions ? "linux" : "linuxmusl"}-${(0, get_architecture_1.toNodeArchitecture)(this.architecture)}`);
+            if (isFunctions) {
+                this.assertUnderLambdaLimit(root);
+            }
         }
-        if (dedicatedImageFunction) {
-            this.imageOptimizationAssetPath =
-                this.prepareImageOptimizationAssets(standalonePath);
+    }
+    /**
+     * Line up the groups the props asked for with the roots the build actually
+     * staged, and fail loudly when they disagree.
+     *
+     * They can disagree in both directions, and both mean the same thing — the
+     * `.next` on disk came from a build that did not see this `functionGroups` —
+     * but the causes differ: `skipBuild: true` with a build run by hand, or a
+     * stale `.next` from before the prop changed. Either way every later symptom
+     * (a Lambda missing an entrypoint, a CloudFront behavior pointing at a
+     * function that cannot serve it) is this, several steps downstream.
+     */
+    resolveDeploymentRoots(manifest) {
+        const staged = manifest.groups;
+        // Names *and* routes: moving `/reports/**` into an existing group keeps the
+        // names and still leaves that group's zip without the reports entrypoints.
+        // Order is not: assignment and CloudFront behaviors both go most specific
+        // first, and no two distinct patterns tie on a URL (`function-groups.ts`),
+        // so reordering groups or routes is the same split.
+        // Already validated in the constructor, so this is absent or non-empty.
+        const wanted = this.props.functionGroups?.length
+            ? toFunctionGroupSpecs(this.props.functionGroups)
+            : undefined;
+        const got = manifest.functionGroups;
+        if (JSON.stringify(sortedGroupSpecs(wanted)) !==
+            JSON.stringify(sortedGroupSpecs(got))) {
+            throw new Error(`${constants_1.LOG_PREFIX} \`functionGroups\` asks for ` +
+                `${wanted ? JSON.stringify(wanted) : "no splitting"} but the build ` +
+                `in ${this.dotNextPath} was split into ` +
+                `${got ? JSON.stringify(got) : "a single deployment root"}. ` +
+                `Groups are resolved during \`next build\` (cdk-nextjs passes them in ` +
+                `via ${function_groups_1.FUNCTION_GROUPS_ENV_VAR}), so this means the build output is ` +
+                `stale, or \`skipBuild: true\` and the build was run without that ` +
+                `variable set.`);
+        }
+        const names = staged ? Object.keys(staged) : [function_groups_1.DEFAULT_FUNCTION_GROUP];
+        const roots = names.map((name) => ({
+            name,
+            path: (0, node_path_1.join)(this.dotNextPath, manifest_1.ADAPTER_DIR_NAME, ...(0, manifest_1.groupStagingDirName)(staged ? name : undefined).split("/")),
+            routes: staged?.[name] ?? [],
+        }));
+        // `default` first, so any "the root" caller gets the group that owns
+        // everything unassigned.
+        roots.sort((a, b) => a.name === function_groups_1.DEFAULT_FUNCTION_GROUP
+            ? -1
+            : b.name === function_groups_1.DEFAULT_FUNCTION_GROUP
+                ? 1
+                : a.name.localeCompare(b.name));
+        for (const root of roots) {
+            if (!(0, node_fs_1.existsSync)(root.path)) {
+                throw new Error(`${constants_1.LOG_PREFIX} The deployment root for function group ` +
+                    `"${root.name}" is missing from ${root.path}, though the adapter ` +
+                    `manifest lists it. The \`.next\` directory has been modified since ` +
+                    `\`next build\` ran.`);
+            }
+        }
+        return roots;
+    }
+    /**
+     * Lambda enforces 250 MB unzipped at CloudFormation time, which is minutes
+     * into a deploy and reports only a size. Splitting exists to stay under that
+     * cap, so the error that tells you to split further has to name the group, its
+     * size, and what to do — and arrive at synth.
+     */
+    assertUnderLambdaLimit(root) {
+        const bytes = storedSize(root.path);
+        debug(`${constants_1.LOG_PREFIX} Deployment root "${root.name}" is ${(bytes / 1e6).toFixed(1)} MB unzipped`);
+        if (bytes <= LAMBDA_UNZIPPED_LIMIT_BYTES) {
+            return;
+        }
+        const mb = (value) => `${(value / 1024 / 1024).toFixed(0)} MB`;
+        const isSplit = this.deploymentRoots.length > 1;
+        throw new Error(`${constants_1.LOG_PREFIX} Function group "${root.name}" is ${mb(bytes)} unzipped, ` +
+            `over Lambda's ${mb(LAMBDA_UNZIPPED_LIMIT_BYTES)} limit. ` +
+            (isSplit
+                ? `Split its routes further, or move some of them into another group: ` +
+                    `the cap is per function, so the shared \`next\` closure every group ` +
+                    `duplicates costs nothing against any single budget.`
+                : `Use the \`functionGroups\` prop to package routes into separate ` +
+                    `functions. Note that splitting only removes route-local code — ` +
+                    `anything reachable from a shared layout or the \`next\` runtime is ` +
+                    `in every group.`));
+    }
+    /**
+     * Read the manifest the adapter's `onBuildComplete` wrote.
+     *
+     * Its absence means `next build` ran without cdk-nextjs's adapter registered
+     * (or with a stale `next.config`), which is worth saying plainly here: every
+     * later failure — a Lambda that cannot find `manifest.json`, an empty asset —
+     * is the same cause several steps downstream.
+     */
+    readAdapterManifest() {
+        const manifestPath = (0, node_path_1.join)(this.dotNextPath, manifest_1.ADAPTER_DIR_NAME, manifest_1.MANIFEST_FILE_NAME);
+        if (!(0, node_fs_1.existsSync)(manifestPath)) {
+            throw new Error(`cdk-nextjs adapter manifest not found at ${manifestPath}. ` +
+                `"${this.buildCommand}" must run a Next.js build with cdk-nextjs's ` +
+                `adapter registered. cdk-nextjs sets \`NEXT_ADAPTER_PATH\` on the ` +
+                `build it runs itself, so this usually means either the build command ` +
+                `does not reach \`next build\` (a wrapper that drops the environment, ` +
+                `or a cached build that did not re-run), or \`skipBuild: true\` and ` +
+                `the build happened outside CDK. For the latter, set ` +
+                `\`adapterPath: require.resolve("cdk-nextjs/adapter")\` in ` +
+                `next.config. A custom \`distDir\` is not supported either: ` +
+                `cdk-nextjs reads the build from \`.next\`.`);
+        }
+        const manifest = JSON.parse((0, node_fs_1.readFileSync)(manifestPath, "utf-8"));
+        if (manifest.version !== manifest_1.ADAPTER_MANIFEST_VERSION) {
+            throw new Error(`The cdk-nextjs adapter manifest at ${manifestPath} is version ` +
+                `${manifest.version}, but this version of cdk-nextjs reads version ` +
+                `${manifest_1.ADAPTER_MANIFEST_VERSION}. The adapter that wrote it and the ` +
+                `constructs reading it come from the same package, so this means two ` +
+                `cdk-nextjs versions are installed, or the build output is stale.`);
+        }
+        return manifest;
+    }
+    /**
+     * Copy cdk-nextjs's own bundled request-handling shell and the manifest into
+     * `<deploymentRoot>/cdk-nextjs-runtime/`, which is where
+     * `deploymentRootOf`/`deployedManifestPath` expect to find them.
+     *
+     * Only the shell the deployment type actually runs is copied — the Lambda
+     * handler for Functions, the `node:http` server for Containers — so nothing
+     * ships ~1.5 MB of dead code and the tree says which type produced it. Both
+     * are copied from this package's `lib/`, next to the compiled construct.
+     *
+     * Every group gets the same shell *and the same manifest*: a function only
+     * knows which routes it owns so it can say so when misrouted, and that comes
+     * from {@link FUNCTION_GROUP_ENV_VAR}, not from a per-group manifest.
+     */
+    stageRuntime(deploymentRoot, isFunctions, publicOnDisk) {
+        const shell = isFunctions ? "lambda.mjs" : "server.mjs";
+        const source = (0, node_path_1.join)(__dirname, "..", "runtime", shell);
+        const runtimeDir = (0, node_path_1.join)(deploymentRoot, manifest_1.RUNTIME_DIR_NAME);
+        // Removed rather than merged: a stale shell from the other deployment type
+        // would otherwise sit in the asset and change its hash for no reason.
+        (0, node_fs_1.rmSync)(runtimeDir, { recursive: true, force: true });
+        (0, node_fs_1.mkdirSync)(runtimeDir, { recursive: true });
+        (0, node_fs_1.cpSync)(source, (0, node_path_1.join)(runtimeDir, shell));
+        (0, node_fs_1.cpSync)((0, node_path_1.join)(this.dotNextPath, manifest_1.ADAPTER_DIR_NAME, manifest_1.MANIFEST_FILE_NAME), (0, node_path_1.join)(runtimeDir, manifest_1.MANIFEST_FILE_NAME));
+        if (!publicOnDisk) {
+            // The Lambda zips and the GlobalContainers image don't carry `public/`
+            // (its bytes are in S3), so the runtime can't list it at start the way
+            // the RegionalContainers image does.
+            // Listed here, after the build command, so `postbuild` output is in it:
+            // a rewrite onto a listed file is then served from S3 rather than 404ing.
+            writePublicFileList(runtimeDir, (0, node_path_1.join)(this.props.buildDirectory, "public"));
+        }
+        debug(`${constants_1.LOG_PREFIX} Staged ${shell} and ${manifest_1.MANIFEST_FILE_NAME} in ${runtimeDir}`);
+    }
+    /**
+     * `NEXT_ADAPTER_PATH` for the build, so `adapterPath` in `next.config` is
+     * optional.
+     *
+     * Next.js reads the variable as the *default* value of `adapterPath`
+     * (`next/dist/server/config-shared.js`, `defaultConfig`), so an app that does
+     * set `adapterPath` still wins and nothing existing changes.
+     *
+     * Resolved from the Next.js app, not from cdk-nextjs's own `__dirname` and not
+     * left as a bare specifier. Both alternatives were tried and both are wrong:
+     *
+     * - cdk-nextjs's own location loses because the adapter resolves its sibling
+     *   cache handler relative to wherever *it* was loaded from. An adapter loaded
+     *   from outside the app's tree hands Next.js a `cacheHandler` outside
+     *   `turbopack.root`, which Turbopack rejects outright ("leaves the filesystem
+     *   root").
+     * - A bare specifier loses because Next.js resolves `adapterPath` from inside
+     *   its own config loader, i.e. from `next`'s realpath. Under pnpm that is the
+     *   virtual store (`node_modules/.pnpm/next@…/node_modules/next/`), and the
+     *   walk up from there never reaches the app's own `node_modules`.
+     *
+     * Unset when `cdk-nextjs` is not resolvable from the app, which is legitimate:
+     * the Next.js app and the CDK app can be separate packages, and only the CDK one
+     * necessarily depends on cdk-nextjs. {@link readAdapterManifest} reports the
+     * resulting failure and names this case.
+     *
+     * One setup this cannot serve, and the reason this repo's own examples still set
+     * `adapterPath`: a `link:`/`file:` dependency on a cdk-nextjs checkout *outside*
+     * the app's project root. The symlink resolves out of the project, so the
+     * `cacheHandler` escape above applies. Set `adapterPath` in `next.config` there
+     * — it is resolved by the build, after whatever put the adapter in place.
+     */
+    adapterPathEnv() {
+        try {
+            return {
+                NEXT_ADAPTER_PATH: require.resolve("cdk-nextjs/adapter", {
+                    paths: [this.props.buildDirectory],
+                }),
+            };
+        }
+        catch {
+            debug(`${constants_1.LOG_PREFIX} Could not resolve "cdk-nextjs/adapter" from ` +
+                `${this.props.buildDirectory}; leaving NEXT_ADAPTER_PATH unset, so ` +
+                `next.config must set \`adapterPath\`.`);
+            return {};
         }
     }
     /**
@@ -139,33 +451,41 @@ class NextjsBuild extends constructs_1.Construct {
                 env: {
                     ...process.env,
                     CDK_NEXTJS_INIT_CACHE_DIR: this.initCacheDir,
+                    ...this.adapterPathEnv(),
+                    // `onBuildComplete` runs inside this process and cannot read CDK
+                    // props, so the resolved groups travel as JSON. Absent when not
+                    // splitting, which the adapter reads as "one deployment root".
+                    ...(this.props.functionGroups?.length
+                        ? {
+                            [function_groups_1.FUNCTION_GROUPS_ENV_VAR]: JSON.stringify(toFunctionGroupSpecs(this.props.functionGroups)),
+                        }
+                        : {}),
                 },
             });
-            // Copy patch-fetch.js into client JS bundle after build only for NextjsGlobalFunctions
-            if (this.props.nextjsType === constants_1.NextjsType.GLOBAL_FUNCTIONS) {
-                this.patchFetchInClientJs();
-            }
         }
         catch (error) {
             throw new Error(`Local build failed: ${error}`);
         }
     }
     /**
-     * Validate Next.js build output
-     * All builds must be standalone - no fallback to regular builds
-     */
-    validateNextBuildOutput() {
-        const standaloneDir = (0, node_path_1.join)(this.dotNextPath, "standalone");
-        // Standalone directory is mandatory
-        if (!(0, node_fs_1.existsSync)(standaloneDir)) {
-            throw new Error(`Standalone build directory not found: ${standaloneDir}. ` +
-                `All builds must be configured for standalone output. ` +
-                `Please ensure your next.config.js includes 'output: "standalone"'.`);
-        }
-        // Additional validation (server.js with .next sibling) happens in findRelativePathToServerJs()
-    }
-    /**
-     * Find entrypoint client side js files to patch `fetch` only for NextjsGlobalFunctions
+     * Prepend `patch-fetch.js` to the client entrypoint chunks, for
+     * `NextjsGlobalFunctions` only.
+     *
+     * This is what makes POST work at all on that type. CloudFront reaches the
+     * server through a Lambda Function URL with `AuthType: AWS_IAM`, signed by an
+     * origin access control, and AWS documents the consequence: "If you use PUT or
+     * POST methods with your Lambda function URL, your users must compute the
+     * SHA256 of the body and include the payload hash value of the request body in
+     * the `x-amz-content-sha256` header when sending the request to CloudFront.
+     * Lambda doesn't support unsigned payloads."
+     *
+     * CloudFront signs GETs itself (empty-body hash) but will not hash a body, and
+     * a browser has no way to add that header on its own, so an unpatched app
+     * answers every server action, form submission and POST route handler with
+     * `403 InvalidSignatureException` before the request reaches Next.js. The
+     * patch installs `fetch`/`XMLHttpRequest` wrappers that compute the hash.
+     *
+     * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-lambda.html
      */
     patchFetchInClientJs() {
         const staticChunksPath = (0, node_path_1.join)(this.dotNextPath, "static", "chunks");
@@ -178,69 +498,20 @@ class NextjsBuild extends constructs_1.Construct {
         }
         // Read the patch-fetch.js content
         const patchFetchPath = (0, node_path_1.join)(__dirname, "patch-fetch.js");
-        if (!(0, node_fs_1.existsSync)(patchFetchPath)) {
-            throw new Error("patch-fetch.js not found");
-        }
         const patchFetchContent = (0, node_fs_1.readFileSync)(patchFetchPath, "utf-8");
-        // Prepend patch-fetch logic to each entrypoint
+        // Prepend patch-fetch logic to each entrypoint, once. Now that this runs
+        // outside `runNextBuild`, the same `.next` can be synthesized more than
+        // once (`skipBuild: true`, `cdk synth` then `cdk deploy`, a retried
+        // deploy), and prepending twice would re-wrap the wrappers.
         for (const chunkFile of chunkFiles) {
             const chunkFilePath = (0, node_path_1.join)(staticChunksPath, chunkFile);
-            const originalContent = (0, node_fs_1.readFileSync)(chunkFilePath, "utf-8");
-            const patchedContent = patchFetchContent + "\n" + originalContent;
-            (0, node_fs_1.writeFileSync)(chunkFilePath, patchedContent);
-        }
-    }
-    /**
-     * Automatically finds the relative path from standalone directory to the
-     * package containing server.js by searching for server.js with a .next sibling.
-     * @returns "." for non-monorepo apps, or relative path like "app-playground" for monorepo apps
-     */
-    findRelativePathToServerJs() {
-        const standaloneDir = (0, node_path_1.join)(this.dotNextPath, "standalone");
-        if (!(0, node_fs_1.existsSync)(standaloneDir)) {
-            throw new Error(`Cannot detect relativePathToPackage: standalone directory not found at ${standaloneDir}`);
-        }
-        const findServerJs = (dir, relativePath = "") => {
-            const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = (0, node_path_1.join)(dir, entry.name);
-                if (entry.isDirectory() && entry.name !== "node_modules") {
-                    // Recursively search directories (skip node_modules at root level)
-                    const result = findServerJs(fullPath, (0, node_path_1.join)(relativePath, entry.name));
-                    if (result !== null)
-                        return result;
-                }
-                else if (entry.isFile() && entry.name === "server.js") {
-                    // Check if this server.js has a .next sibling directory
-                    const parentDir = dir;
-                    const dotNextPath = (0, node_path_1.join)(parentDir, ".next");
-                    if ((0, node_fs_1.existsSync)(dotNextPath)) {
-                        return relativePath || ".";
-                    }
-                }
+            const patchedContent = patchClientChunk((0, node_fs_1.readFileSync)(chunkFilePath, "utf-8"), patchFetchContent, chunkFilePath);
+            if (patchedContent === undefined) {
+                debug(`${constants_1.LOG_PREFIX} Already patched, skipping: ${chunkFilePath}`);
+                continue;
             }
-            return null;
-        };
-        const result = findServerJs(standaloneDir);
-        if (result === null) {
-            throw new Error(`Cannot detect relativePathToPackage: Could not find server.js with .next sibling in ${standaloneDir}. ` +
-                `Please ensure Next.js build completed successfully or provide relativePathToPackage manually.`);
-        }
-        debug(`${constants_1.LOG_PREFIX} Auto-detected relativePathToPackage: "${result}"`);
-        return result;
-    }
-    /**
-     * Get build ID from .next directory
-     */
-    getBuildId() {
-        const buildIdPath = (0, node_path_1.join)(this.dotNextPath, "BUILD_ID");
-        // Verify BUILD_ID exists (needed for cache partitioning)
-        if (!(0, node_fs_1.existsSync)(buildIdPath)) {
-            throw new Error(`BUILD_ID file not found at ${buildIdPath}. ` +
-                `Ensure Next.js build completed successfully.`);
+            (0, node_fs_1.writeFileSync)(chunkFilePath, patchedContent);
         }
-        // BUILD_ID existence is already validated in validateNextBuildOutput()
-        return (0, node_fs_1.readFileSync)(buildIdPath, "utf-8").trim();
     }
     /**
      * Get public directory entries from local filesystem
@@ -250,190 +521,108 @@ class NextjsBuild extends constructs_1.Construct {
         if (!(0, node_fs_1.existsSync)(publicDirPath)) {
             return [];
         }
-        try {
-            return (0, node_fs_1.readdirSync)(publicDirPath, { withFileTypes: true }).map((entry) => ({
-                name: entry.name,
-                isDirectory: entry.isDirectory(),
-            }));
-        }
-        catch (error) {
-            console.warn(`${constants_1.LOG_PREFIX} Failed to read public directory: ${error}`);
-            return [];
-        }
-    }
-    /**
-     * Recursively find and remove existing Sharp platform binaries
-     */
-    removeExistingSharpBinaries(standalonePath) {
-        const nodeModulesPath = (0, node_path_1.join)(standalonePath, "node_modules");
-        if (!(0, node_fs_1.existsSync)(nodeModulesPath)) {
-            return;
-        }
-        try {
-            // Use recursive readdirSync to find all Sharp binary directories and symlinks
-            const allEntries = (0, node_fs_1.readdirSync)(nodeModulesPath, {
-                recursive: true,
-                withFileTypes: true,
-            });
-            const sharpBinaryPaths = [];
-            for (const entry of allEntries) {
-                // Check for both directories and symlinks (pnpm creates symlinks)
-                if (entry.isDirectory() || entry.isSymbolicLink()) {
-                    // Match Sharp binary packages with more comprehensive patterns
-                    const isSharpBinary = entry.name.includes("sharp-") ||
-                        entry.name.includes("sharp-libvips");
-                    if (isSharpBinary) {
-                        // For recursive readdirSync, parentPath contains the full absolute path
-                        const fullPath = (0, node_path_1.join)(entry.parentPath, entry.name);
-                        sharpBinaryPaths.push(fullPath);
-                    }
-                }
-            }
-            debug(`${constants_1.LOG_PREFIX} Found ${sharpBinaryPaths.length} Sharp binary directories/symlinks to remove`);
-            // Remove all found Sharp binary directories and symlinks
-            for (const path of sharpBinaryPaths) {
-                try {
-                    (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
-                    debug(`${constants_1.LOG_PREFIX} Removed: ${path}`);
-                }
-                catch (error) {
-                    console.warn(`${constants_1.LOG_PREFIX} Warning: Could not remove ${path}: ${error}`);
-                }
-            }
-        }
-        catch (error) {
-            console.warn(`${constants_1.LOG_PREFIX} Warning: Could not read node_modules directory: ${error}`);
-        }
-    }
-    /**
-     * Download and install correct Sharp binaries for Linux MUSL
-     */
-    downloadAndInstallSharpBinaries() {
-        const nodeModulesPath = (0, node_path_1.join)(this.dotNextPath, "standalone", "node_modules");
-        const imgPath = (0, node_path_1.join)(nodeModulesPath, "@img");
-        const arch = (0, get_architecture_1.getNodeArchitecture)();
-        this.installSharpPackages(imgPath, this.getSharpBinaryPackages(this.findSharpPackage(nodeModulesPath), `linuxmusl-${arch}`));
+        return (0, node_fs_1.readdirSync)(publicDirPath, { withFileTypes: true }).map((entry) => ({
+            name: entry.name,
+            isDirectory: entry.isDirectory(),
+        }));
     }
     /**
-     * Assemble the deployment asset for the dedicated image optimization
-     * Lambda: the pre-bundled handler (from this package's own `lib/` output),
-     * `sharp`'s JS wrapper (already dereferenced from the pnpm store by Next's
-     * output file tracing into the standalone build), glibc `sharp` binaries
-     * (the standard Lambda managed runtime is Amazon Linux 2023/glibc, unlike
-     * the musl binaries the Docker/Lambda Web Adapter server function needs),
-     * and `required-server-files.json` (read by the handler at cold start to
-     * build `nextConfig`).
-     */
-    prepareImageOptimizationAssets(standalonePath) {
-        const assetPath = (0, node_path_1.join)(this.dotNextPath, "cdk-nextjs-image-optimization");
-        const nodeModulesPath = (0, node_path_1.join)(assetPath, "node_modules");
-        const imgPath = (0, node_path_1.join)(nodeModulesPath, "@img");
-        (0, node_fs_1.rmSync)(assetPath, { recursive: true, force: true });
-        (0, node_fs_1.mkdirSync)(imgPath, { recursive: true });
-        // Pre-bundled by esbuild into this package's own lib/ output.
-        (0, node_fs_1.cpSync)((0, node_path_1.join)(__dirname, "..", "image-optimization"), assetPath, {
-            recursive: true,
-        });
-        const sharpSource = this.findSharpPackage((0, node_path_1.join)(standalonePath, "node_modules"));
-        if (sharpSource) {
-            this.copySharpRuntime(sharpSource, nodeModulesPath);
-        }
-        else {
-            console.warn(`${constants_1.LOG_PREFIX} "sharp" not found in standalone build output. Add "sharp" as a dependency of your Next.js app to enable image optimization.`);
-        }
-        const requiredServerFiles = (0, node_path_1.join)(this.dotNextPath, "required-server-files.json");
-        if (!(0, node_fs_1.existsSync)(requiredServerFiles)) {
-            throw new Error(`${constants_1.LOG_PREFIX} "required-server-files.json" not found at ${requiredServerFiles}. The image optimization Lambda reads it at cold start to build its Next.js config.`);
-        }
-        (0, node_fs_1.cpSync)(requiredServerFiles, (0, node_path_1.join)(assetPath, "required-server-files.json"));
-        const arch = (0, get_architecture_1.getNodeArchitecture)();
-        this.installSharpPackages(imgPath, this.getSharpBinaryPackages(sharpSource, `linux-${arch}`));
-        return assetPath;
-    }
-    /**
-     * Locate `sharp`'s JS wrapper inside a standalone `node_modules`.
+     * Strip whatever platform-specific Sharp binaries `next build`'s output file
+     * tracing staged, since they're the host's (e.g. macOS/glibc) rather than the
+     * deployment target's, then install the target's. Skipping this is silent:
+     * `imageOptimizer` catches the load failure internally and returns the
+     * unoptimized original with an HTTP 200.
      *
-     * Next's output file tracing preserves the installer's on-disk layout, so
-     * npm/yarn produce a hoisted `node_modules/sharp` while pnpm only
-     * materializes `node_modules/.pnpm/sharp@<version>/node_modules/sharp`.
+     * Only a root with `sharp` staged gets the binaries: the image optimizer
+     * brings it into `default`, which serves every `/_next/image`, and another
+     * group has it only if its own routes use it. So only `default` warns when
+     * it's missing.
      */
-    findSharpPackage(nodeModulesPath) {
-        const hoisted = (0, node_path_1.join)(nodeModulesPath, "sharp");
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(hoisted, "package.json"))) {
-            return hoisted;
-        }
-        const pnpmPath = (0, node_path_1.join)(nodeModulesPath, ".pnpm");
-        if (!(0, node_fs_1.existsSync)(pnpmPath)) {
-            return undefined;
-        }
-        const candidates = (0, node_fs_1.readdirSync)(pnpmPath)
-            .filter((name) => name.startsWith("sharp@"))
-            .sort();
-        for (const candidate of candidates.reverse()) {
-            const nested = (0, node_path_1.join)(pnpmPath, candidate, "node_modules", "sharp");
-            if ((0, node_fs_1.existsSync)((0, node_path_1.join)(nested, "package.json"))) {
-                return nested;
+    stageSharpForTarget(root, projectDir, platform) {
+        const sharpSource = this.removeExistingSharpBinaries(root.path, projectDir);
+        if (!sharpSource) {
+            if (root.name === function_groups_1.DEFAULT_FUNCTION_GROUP) {
+                console.warn(`${constants_1.LOG_PREFIX} "sharp" not found in the staged build output. Add "sharp" as a dependency of your Next.js app to enable image optimization.`);
             }
+            return;
         }
-        return undefined;
+        this.installSharpPackages(sharpBinaryDir(root.path), this.getSharpBinaryPackages(sharpSource, platform));
     }
     /**
-     * Copy `sharp` plus the transitive `dependencies` closure `require("sharp")`
-     * pulls in (`@img/colour`, `detect-libc`, `semver`) into `targetPath`.
+     * Recursively find and remove existing Sharp platform binaries.
+     *
+     * `root` is walked whole rather than just its `node_modules`: the staged tree
+     * is keyed by repo-root-relative path, so in a monorepo the `node_modules`
+     * holding `sharp` is several directories down. {@link isSharpBinaryPackage} is
+     * what keeps that from reaching the app's own output — the staged root holds
+     * the compiled `.next` as well as the dependencies.
      *
-     * Copying only `sharp` itself leaves those requires unresolvable, and
-     * `imageOptimizer` swallows the resulting `MODULE_NOT_FOUND` by falling back
-     * to serving the unoptimized original, so the omission is otherwise silent.
+     * @param projectDir the app's directory inside `root`, which `next` is
+     * resolved from.
+     * @returns the staged `sharp` JS wrapper to install next to, found in the same
+     * walk: a root can be hundreds of megabytes, and each group has one.
      */
-    copySharpRuntime(sharpSource, targetPath) {
-        // Under pnpm a package's dependencies are symlinked into the sibling
-        // directory alongside it, which is also where a hoisted layout keeps
-        // them, so the same lookup covers both.
-        const lookupPath = (0, node_path_1.join)(sharpSource, "..");
-        const queue = ["sharp"];
-        const copied = new Set();
-        while (queue.length > 0) {
-            const name = queue.shift();
-            if (copied.has(name)) {
+    removeExistingSharpBinaries(root, projectDir) {
+        const sharpCandidates = [];
+        // Links are listed, not followed: every link in a staged root points
+        // inside it (`stageFiles` copies the ones that don't), so its target is
+        // walked at its own path anyway, and following them is what let a
+        // workspace cycle hang the synth.
+        const allEntries = listTree(root);
+        // Symlinks are unlinked, not `rmSync`ed, and they go first. pnpm points
+        // several links at one store directory, and `rmSync(…, { recursive: true,
+        // force: true })` *silently no-ops* on a symlink whose target is already
+        // gone — `force` swallows the ENOENT its `rmdir` gets. Removing a store
+        // directory before its links therefore left dangling
+        // `@img/sharp-darwin-arm64` entries in the asset, which is a latent ENOENT
+        // in whatever next follows them (`sharp` does, when it looks for binaries).
+        const symlinks = [];
+        const directories = [];
+        for (const entry of allEntries) {
+            if (entry.isDirectory() && entry.name === "sharp") {
+                const path = (0, node_path_1.join)(entry.parentPath, entry.name);
+                if ((0, node_fs_1.existsSync)((0, node_path_1.join)(path, "package.json"))) {
+                    sharpCandidates.push(path);
+                }
                 continue;
             }
-            const source = name === "sharp" ? sharpSource : (0, node_path_1.join)(lookupPath, name);
-            if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(source, "package.json"))) {
-                console.warn(`${constants_1.LOG_PREFIX} "sharp" dependency "${name}" not found in standalone build output; image optimization may fall back to serving unoptimized images.`);
+            if (!isSharpBinaryPackage(entry.parentPath, entry.name))
                 continue;
+            const fullPath = (0, node_path_1.join)(entry.parentPath, entry.name);
+            if (entry.isSymbolicLink()) {
+                symlinks.push(fullPath);
             }
-            // `dereference` resolves pnpm's symlinks into real files, since the
-            // Lambda asset is a standalone directory with no store to link into.
-            (0, node_fs_1.cpSync)(source, (0, node_path_1.join)(targetPath, name), {
-                recursive: true,
-                dereference: true,
-            });
-            copied.add(name);
-            const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(source, "package.json"), "utf-8"));
-            // Platform binaries are optionalDependencies, installed separately at
-            // the versions this same manifest pins, so only `dependencies` here.
-            queue.push(...Object.keys(manifest.dependencies ?? {}));
+            else if (entry.isDirectory()) {
+                directories.push(fullPath);
+            }
+        }
+        debug(`${constants_1.LOG_PREFIX} Removing ${symlinks.length} Sharp binary symlinks and ${directories.length} directories`);
+        for (const path of symlinks) {
+            (0, node_fs_1.unlinkSync)(path);
+            debug(`${constants_1.LOG_PREFIX} Unlinked: ${path}`);
+        }
+        for (const path of directories) {
+            (0, node_fs_1.rmSync)(path, { recursive: true, force: true });
+            debug(`${constants_1.LOG_PREFIX} Removed: ${path}`);
         }
-        debug(`${constants_1.LOG_PREFIX} Copied sharp runtime: ${[...copied].sort().join(", ")}`);
+        return pickStagedSharpPackage(sharpCandidates, resolveNextSharp(projectDir));
     }
     /**
      * Resolve the `@img/sharp-<platform>` and `@img/sharp-libvips-<platform>`
      * versions to install for a given platform.
      *
-     * These must match the `sharp` JS wrapper that output file tracing put in
-     * the standalone build: `sharp`'s `lib/libvips.js` compares the binary's
+     * These must match the `sharp` JS wrapper that output file tracing staged:
+     * `sharp`'s `lib/libvips.js` compares the binary's
      * reported libvips version against its own `minimumLibvipsVersion` and
      * throws at load when they disagree. `sharp` pins both in its
      * `optionalDependencies`, so that manifest is the authoritative source.
      */
     getSharpBinaryPackages(sharpSource, platform) {
+        // Only for a binary the staged `sharp` does not pin.
         const fallback = [
             { name: `sharp-libvips-${platform}`, version: "1.2.4" },
             { name: `sharp-${platform}`, version: "0.34.5" },
         ];
-        if (!sharpSource) {
-            return fallback;
-        }
         const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(sharpSource, "package.json"), "utf-8"));
         const optionalDependencies = manifest.optionalDependencies ?? {};
         return fallback.map((pkg) => {
@@ -451,56 +640,56 @@ class NextjsBuild extends constructs_1.Construct {
      */
     installSharpPackages(imgPath, packages) {
         const cacheDir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), "cdk-nextjs-sharp-cache");
-        if (!(0, node_fs_1.existsSync)(cacheDir)) {
-            (0, node_fs_1.mkdirSync)(cacheDir, { recursive: true });
-        }
+        (0, node_fs_1.mkdirSync)(cacheDir, { recursive: true });
         for (const pkg of packages) {
-            try {
-                const targetDir = (0, node_path_1.join)(imgPath, pkg.name);
-                const url = `https://registry.npmjs.org/@img/${pkg.name}/-/${pkg.name}-${pkg.version}.tgz`;
-                // Create a consistent filename based on package name and version
-                const cacheFileName = `${pkg.name}-${pkg.version}.tgz`;
-                const cachedFile = (0, node_path_1.join)(cacheDir, cacheFileName);
-                // Check if we already have a valid package cached; re-download if
-                // a previous run left behind a truncated/corrupt download
-                if ((0, node_fs_1.existsSync)(cachedFile) && this.isCachedFileValid(cachedFile)) {
-                    debug(`${constants_1.LOG_PREFIX} Using cached ${pkg.name}@${pkg.version} from ${cachedFile}`);
-                }
-                else {
-                    debug(`${constants_1.LOG_PREFIX} Downloading ${pkg.name}@${pkg.version}...`);
-                    // Download to a process-unique temp file in the same directory,
-                    // then atomically rename it onto the shared cache path. Concurrent
-                    // synth processes (e.g. Turborepo running multiple `cdk` commands)
-                    // share this cache dir, so writing directly to `cachedFile` risks
-                    // another process extracting a half-written file. Renaming within
-                    // the same filesystem is atomic, so readers only ever see a
-                    // complete file, whichever process wins the race.
-                    const tempFile = (0, node_path_1.join)(cacheDir, `${cacheFileName}.${process.pid}-${(0, node_crypto_1.randomBytes)(6).toString("hex")}.tmp`);
-                    try {
-                        // --fail makes curl exit non-zero on HTTP errors and --retry
-                        // handles transient connection drops so a partial transfer
-                        // isn't cached as valid.
-                        (0, node_child_process_1.execSync)(`curl -L --fail --retry 3 --retry-delay 1 -o "${tempFile}" "${url}"`, { stdio: "pipe" });
-                        if (!this.isCachedFileValid(tempFile)) {
-                            throw new Error(`Downloaded file for ${pkg.name}@${pkg.version} is empty or missing: ${tempFile}`);
-                        }
-                        (0, node_fs_1.renameSync)(tempFile, cachedFile);
-                    }
-                    finally {
-                        if ((0, node_fs_1.existsSync)(tempFile)) {
-                            (0, node_fs_1.rmSync)(tempFile, { force: true });
-                        }
+            const targetDir = (0, node_path_1.join)(imgPath, pkg.name);
+            const url = `https://registry.npmjs.org/@img/${pkg.name}/-/${pkg.name}-${pkg.version}.tgz`;
+            // Create a consistent filename based on package name and version
+            const cacheFileName = `${pkg.name}-${pkg.version}.tgz`;
+            const cachedFile = (0, node_path_1.join)(cacheDir, cacheFileName);
+            // Check if we already have a valid package cached; re-download if
+            // a previous run left behind a truncated/corrupt download
+            if ((0, node_fs_1.existsSync)(cachedFile) && this.isCachedFileValid(cachedFile)) {
+                debug(`${constants_1.LOG_PREFIX} Using cached ${pkg.name}@${pkg.version} from ${cachedFile}`);
+            }
+            else {
+                debug(`${constants_1.LOG_PREFIX} Downloading ${pkg.name}@${pkg.version}...`);
+                // Download to a process-unique temp file in the same directory,
+                // then atomically rename it onto the shared cache path. Concurrent
+                // synth processes (e.g. Turborepo running multiple `cdk` commands)
+                // share this cache dir, so writing directly to `cachedFile` risks
+                // another process extracting a half-written file. Renaming within
+                // the same filesystem is atomic, so readers only ever see a
+                // complete file, whichever process wins the race.
+                const tempFile = (0, node_path_1.join)(cacheDir, `${cacheFileName}.${process.pid}-${(0, node_crypto_1.randomBytes)(6).toString("hex")}.tmp`);
+                try {
+                    // --fail makes curl exit non-zero on HTTP errors and --retry
+                    // handles transient connection drops so a partial transfer
+                    // isn't cached as valid.
+                    (0, node_child_process_1.execFileSync)("curl", [
+                        "-L",
+                        "--fail",
+                        "--retry",
+                        "3",
+                        "--retry-delay",
+                        "1",
+                        "-o",
+                        tempFile,
+                        url,
+                    ], { stdio: "pipe" });
+                    if (!this.isCachedFileValid(tempFile)) {
+                        throw new Error(`Downloaded file for ${pkg.name}@${pkg.version} is empty or missing: ${tempFile}`);
                     }
-                    debug(`${constants_1.LOG_PREFIX} Cached ${pkg.name}@${pkg.version} to ${cachedFile}`);
+                    (0, node_fs_1.renameSync)(tempFile, cachedFile);
                 }
-                (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
-                (0, node_child_process_1.execSync)(`tar -xzf "${cachedFile}" -C "${targetDir}" --strip-components=1`, { stdio: "pipe" });
-                debug(`${constants_1.LOG_PREFIX} Installed ${pkg.name}@${pkg.version}`);
-            }
-            catch (error) {
-                console.error(`${constants_1.LOG_PREFIX} Failed to install ${pkg.name}: ${error}`);
-                throw error;
+                finally {
+                    (0, node_fs_1.rmSync)(tempFile, { force: true });
+                }
+                debug(`${constants_1.LOG_PREFIX} Cached ${pkg.name}@${pkg.version} to ${cachedFile}`);
             }
+            (0, node_fs_1.mkdirSync)(targetDir, { recursive: true });
+            (0, node_child_process_1.execFileSync)("tar", ["-xzf", cachedFile, "-C", targetDir, "--strip-components=1"], { stdio: "pipe" });
+            debug(`${constants_1.LOG_PREFIX} Installed ${pkg.name}@${pkg.version}`);
         }
     }
     /**
@@ -518,4 +707,172 @@ class NextjsBuild extends constructs_1.Construct {
     }
 }
 exports.NextjsBuild = NextjsBuild;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-build.js","sourceRoot":"","sources":["../../src/nextjs-build/nextjs-build.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync } from \"node:child_process\";\nimport { randomBytes } from \"node:crypto\";\nimport {\n  existsSync,\n  readFileSync,\n  readdirSync,\n  writeFileSync,\n  rmSync,\n  mkdirSync,\n  cpSync,\n  renameSync,\n  statSync,\n} from \"node:fs\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { Construct } from \"constructs\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { NextjsBaseProps } from \"../root-constructs/nextjs-base-construct\";\nimport { readNextConfigBasePath } from \"../utils/base-path\";\nimport { useDedicatedImageFunction } from \"../utils/experimental-flags\";\nimport { getNodeArchitecture } from \"../utils/get-architecture\";\n\nconst debug = getDebug(\"cdk-nextjs:nextjs-build\");\n\nexport interface NextjsBuildProps {\n  /**\n   * @see {@link NextjsBaseProps[\"buildCommand\"]}\n   */\n  readonly buildCommand: NextjsBaseProps[\"buildCommand\"];\n  /**\n   * Directory where the Next.js application is located for local builds.\n   * This should contain the package.json and Next.js application files.\n   */\n  readonly buildDirectory: string;\n  readonly nextjsType: NextjsType;\n  /**\n   * @see {@link NextjsBaseProps.skipBuild}\n   */\n  readonly skipBuild?: boolean;\n}\n\nexport interface PublicDirEntry {\n  readonly name: string;\n  readonly isDirectory: boolean;\n}\n\n/**\n * Builds Next.js assets.\n * @link https://nextjs.org/docs/pages/api-reference/next-config-js/output\n */\nexport class NextjsBuild extends Construct {\n  /**\n   * Unique id for Next.js build. Used to partition cache storage and as\n   * metadata for static assets in S3 bucket.\n   */\n  buildId: string;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  initCacheDir: string;\n  /**\n   * Absolute path to public. Use by CloudFront/ALB to create behaviors/rules\n   * @example \"/Users/john/myapp/public\"\n   */\n  publicDirEntries: PublicDirEntry[];\n  /**\n   * The entrypoint JavaScript file used as an argument for Node.js to run the\n   * Next.js standalone server relative to the standalone directory.\n   * @example \"./server.js\"\n   * @example \"./packages/ui/server.js\" (monorepo)\n   */\n  relativePathToEntrypoint: string;\n  /**\n   * Relative path from the standalone directory to the package containing the Next.js app.\n   * This is automatically detected from the standalone build output.\n   * @example \".\" for non-monorepo apps\n   * @example \"./apps/web\" for monorepo apps\n   */\n  relativePathToPackage: string;\n  /**\n   * Absolute path to the .next directory containing Next.js build artifacts\n   */\n  dotNextPath: string;\n  /**\n   * The Next.js app's own `basePath` — the URL prefix it generates its links and\n   * asset hrefs under — read out of the build's `required-server-files.json`.\n   * Normalized to a bare path segment, empty when the app sets none. Exposed so\n   * root constructs can reconcile it with the CDK `basePath` prop, which is a\n   * distinct thing; see `resolveBasePath`.\n   */\n  nextConfigBasePath: string;\n  /**\n   * Absolute path to the directory prepared for the image optimization Lambda\n   * asset: bundled handler, glibc `sharp` binaries, and `required-server-files.json`.\n   * Only set for {@link NextjsType.GLOBAL_FUNCTIONS} and\n   * {@link NextjsType.REGIONAL_FUNCTIONS}, and only when the dedicated image\n   * optimization Lambda is enabled.\n   */\n  imageOptimizationAssetPath?: string;\n\n  private props: NextjsBuildProps;\n  private buildCommand: string;\n\n  constructor(scope: Construct, id: string, props: NextjsBuildProps) {\n    super(scope, id);\n    this.props = props;\n    this.dotNextPath = join(props.buildDirectory, \".next\");\n\n    this.buildCommand = props.buildCommand || \"npm run build\";\n\n    // Set init cache directory path\n    this.initCacheDir = join(\n      props.buildDirectory,\n      \".next\",\n      \"cdk-nextjs-init-cache\",\n    );\n\n    // Execute local build process\n    if (props.skipBuild !== true) {\n      this.runNextBuild();\n    } else {\n      debug(`${LOG_PREFIX} Skipping: ${this.buildCommand}`);\n    }\n\n    // Validate build output and set validated paths\n    this.validateNextBuildOutput();\n\n    // Auto-detect relativePathToPackage from standalone build output\n    this.relativePathToPackage = this.findRelativePathToServerJs();\n\n    // Set entrypoint path using detected relativePathToPackage\n    this.relativePathToEntrypoint = joinPosix(\n      this.relativePathToPackage === \".\" ? \"\" : this.relativePathToPackage,\n      \"server.js\",\n    );\n\n    this.buildId = this.getBuildId();\n    this.publicDirEntries = this.getLocalPublicDirEntries();\n    this.nextConfigBasePath = readNextConfigBasePath(this.dotNextPath);\n\n    const standalonePath = join(this.dotNextPath, \"standalone\");\n    const isFunctions =\n      props.nextjsType === NextjsType.GLOBAL_FUNCTIONS ||\n      props.nextjsType === NextjsType.REGIONAL_FUNCTIONS;\n\n    const dedicatedImageFunction = isFunctions && useDedicatedImageFunction();\n\n    // Strip whatever platform-specific Sharp binaries `next build`'s output\n    // file tracing bundled in either way, since they're the host's (e.g.\n    // macOS/glibc) rather than the deployment target's.\n    this.removeExistingSharpBinaries(standalonePath);\n    // The standalone server serves `_next/image` itself unless a dedicated\n    // image optimization Lambda takes over that route, and it runs on\n    // node:24-alpine (see functions.Dockerfile) / the same Alpine base for\n    // Containers, so it needs musl binaries. Skipping this install when Sharp\n    // *is* invoked from the server is silent: `imageOptimizer` catches the\n    // load failure internally and returns the unoptimized original with an\n    // HTTP 200.\n    if (!dedicatedImageFunction) {\n      this.downloadAndInstallSharpBinaries();\n    }\n\n    if (dedicatedImageFunction) {\n      this.imageOptimizationAssetPath =\n        this.prepareImageOptimizationAssets(standalonePath);\n    }\n  }\n\n  /**\n   * Execute local build command in the specified directory\n   */\n  private runNextBuild() {\n    console.log(\n      `${LOG_PREFIX} Running: \"${this.buildCommand}\" in directory: ${this.props.buildDirectory}`,\n    );\n\n    // Clean existing cache directory to avoid stale data from previous builds\n    if (existsSync(this.initCacheDir)) {\n      rmSync(this.initCacheDir, { recursive: true, force: true });\n      debug(`Cleaned existing cache directory: ${this.initCacheDir}`);\n    }\n\n    try {\n      execSync(this.buildCommand, {\n        stdio: \"inherit\",\n        cwd: this.props.buildDirectory,\n        env: {\n          ...process.env,\n          CDK_NEXTJS_INIT_CACHE_DIR: this.initCacheDir,\n        },\n      });\n\n      // Copy patch-fetch.js into client JS bundle after build only for NextjsGlobalFunctions\n      if (this.props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n        this.patchFetchInClientJs();\n      }\n    } catch (error) {\n      throw new Error(`Local build failed: ${error}`);\n    }\n  }\n\n  /**\n   * Validate Next.js build output\n   * All builds must be standalone - no fallback to regular builds\n   */\n  private validateNextBuildOutput(): void {\n    const standaloneDir = join(this.dotNextPath, \"standalone\");\n    // Standalone directory is mandatory\n    if (!existsSync(standaloneDir)) {\n      throw new Error(\n        `Standalone build directory not found: ${standaloneDir}. ` +\n          `All builds must be configured for standalone output. ` +\n          `Please ensure your next.config.js includes 'output: \"standalone\"'.`,\n      );\n    }\n    // Additional validation (server.js with .next sibling) happens in findRelativePathToServerJs()\n  }\n\n  /**\n   * Find entrypoint client side js files to patch `fetch` only for NextjsGlobalFunctions\n   */\n  private patchFetchInClientJs() {\n    const staticChunksPath = join(this.dotNextPath, \"static\", \"chunks\");\n    const chunkFiles = readdirSync(staticChunksPath).filter(\n      (file: string) =>\n        // main-app- for webpack, turbopack- for turbo\n        file.startsWith(\"main-app-\") ||\n        (file.startsWith(\"turbopack-\") && file.endsWith(\".js\")),\n    );\n\n    if (chunkFiles.length === 0) {\n      throw new Error(\"No client side js entrypoint files found\");\n    }\n\n    // Read the patch-fetch.js content\n    const patchFetchPath = join(__dirname, \"patch-fetch.js\");\n    if (!existsSync(patchFetchPath)) {\n      throw new Error(\"patch-fetch.js not found\");\n    }\n\n    const patchFetchContent = readFileSync(patchFetchPath, \"utf-8\");\n\n    // Prepend patch-fetch logic to each entrypoint\n    for (const chunkFile of chunkFiles) {\n      const chunkFilePath = join(staticChunksPath, chunkFile);\n      const originalContent = readFileSync(chunkFilePath, \"utf-8\");\n      const patchedContent = patchFetchContent + \"\\n\" + originalContent;\n      writeFileSync(chunkFilePath, patchedContent);\n    }\n  }\n\n  /**\n   * Automatically finds the relative path from standalone directory to the\n   * package containing server.js by searching for server.js with a .next sibling.\n   * @returns \".\" for non-monorepo apps, or relative path like \"app-playground\" for monorepo apps\n   */\n  private findRelativePathToServerJs(): string {\n    const standaloneDir = join(this.dotNextPath, \"standalone\");\n\n    if (!existsSync(standaloneDir)) {\n      throw new Error(\n        `Cannot detect relativePathToPackage: standalone directory not found at ${standaloneDir}`,\n      );\n    }\n\n    const findServerJs = (\n      dir: string,\n      relativePath: string = \"\",\n    ): string | null => {\n      const entries = readdirSync(dir, { withFileTypes: true });\n\n      for (const entry of entries) {\n        const fullPath = join(dir, entry.name);\n\n        if (entry.isDirectory() && entry.name !== \"node_modules\") {\n          // Recursively search directories (skip node_modules at root level)\n          const result = findServerJs(fullPath, join(relativePath, entry.name));\n          if (result !== null) return result;\n        } else if (entry.isFile() && entry.name === \"server.js\") {\n          // Check if this server.js has a .next sibling directory\n          const parentDir = dir;\n          const dotNextPath = join(parentDir, \".next\");\n          if (existsSync(dotNextPath)) {\n            return relativePath || \".\";\n          }\n        }\n      }\n      return null;\n    };\n\n    const result = findServerJs(standaloneDir);\n    if (result === null) {\n      throw new Error(\n        `Cannot detect relativePathToPackage: Could not find server.js with .next sibling in ${standaloneDir}. ` +\n          `Please ensure Next.js build completed successfully or provide relativePathToPackage manually.`,\n      );\n    }\n\n    debug(`${LOG_PREFIX} Auto-detected relativePathToPackage: \"${result}\"`);\n    return result;\n  }\n\n  /**\n   * Get build ID from .next directory\n   */\n  private getBuildId(): string {\n    const buildIdPath = join(this.dotNextPath, \"BUILD_ID\");\n    // Verify BUILD_ID exists (needed for cache partitioning)\n    if (!existsSync(buildIdPath)) {\n      throw new Error(\n        `BUILD_ID file not found at ${buildIdPath}. ` +\n          `Ensure Next.js build completed successfully.`,\n      );\n    }\n    // BUILD_ID existence is already validated in validateNextBuildOutput()\n    return readFileSync(buildIdPath, \"utf-8\").trim();\n  }\n\n  /**\n   * Get public directory entries from local filesystem\n   */\n  private getLocalPublicDirEntries(): PublicDirEntry[] {\n    const publicDirPath = join(this.props.buildDirectory, \"public\");\n    if (!existsSync(publicDirPath)) {\n      return [];\n    }\n\n    try {\n      return readdirSync(publicDirPath, { withFileTypes: true }).map(\n        (entry: any) => ({\n          name: entry.name,\n          isDirectory: entry.isDirectory(),\n        }),\n      );\n    } catch (error) {\n      console.warn(`${LOG_PREFIX} Failed to read public directory: ${error}`);\n      return [];\n    }\n  }\n\n  /**\n   * Recursively find and remove existing Sharp platform binaries\n   */\n  private removeExistingSharpBinaries(standalonePath: string): void {\n    const nodeModulesPath = join(standalonePath, \"node_modules\");\n    if (!existsSync(nodeModulesPath)) {\n      return;\n    }\n\n    try {\n      // Use recursive readdirSync to find all Sharp binary directories and symlinks\n      const allEntries = readdirSync(nodeModulesPath, {\n        recursive: true,\n        withFileTypes: true,\n      });\n\n      const sharpBinaryPaths: string[] = [];\n\n      for (const entry of allEntries) {\n        // Check for both directories and symlinks (pnpm creates symlinks)\n        if (entry.isDirectory() || entry.isSymbolicLink()) {\n          // Match Sharp binary packages with more comprehensive patterns\n          const isSharpBinary =\n            entry.name.includes(\"sharp-\") ||\n            entry.name.includes(\"sharp-libvips\");\n\n          if (isSharpBinary) {\n            // For recursive readdirSync, parentPath contains the full absolute path\n            const fullPath = join(entry.parentPath, entry.name);\n            sharpBinaryPaths.push(fullPath);\n          }\n        }\n      }\n\n      debug(\n        `${LOG_PREFIX} Found ${sharpBinaryPaths.length} Sharp binary directories/symlinks to remove`,\n      );\n\n      // Remove all found Sharp binary directories and symlinks\n      for (const path of sharpBinaryPaths) {\n        try {\n          rmSync(path, { recursive: true, force: true });\n          debug(`${LOG_PREFIX} Removed: ${path}`);\n        } catch (error) {\n          console.warn(\n            `${LOG_PREFIX} Warning: Could not remove ${path}: ${error}`,\n          );\n        }\n      }\n    } catch (error) {\n      console.warn(\n        `${LOG_PREFIX} Warning: Could not read node_modules directory: ${error}`,\n      );\n    }\n  }\n\n  /**\n   * Download and install correct Sharp binaries for Linux MUSL\n   */\n  private downloadAndInstallSharpBinaries(): void {\n    const nodeModulesPath = join(\n      this.dotNextPath,\n      \"standalone\",\n      \"node_modules\",\n    );\n    const imgPath = join(nodeModulesPath, \"@img\");\n    const arch = getNodeArchitecture();\n\n    this.installSharpPackages(\n      imgPath,\n      this.getSharpBinaryPackages(\n        this.findSharpPackage(nodeModulesPath),\n        `linuxmusl-${arch}`,\n      ),\n    );\n  }\n\n  /**\n   * Assemble the deployment asset for the dedicated image optimization\n   * Lambda: the pre-bundled handler (from this package's own `lib/` output),\n   * `sharp`'s JS wrapper (already dereferenced from the pnpm store by Next's\n   * output file tracing into the standalone build), glibc `sharp` binaries\n   * (the standard Lambda managed runtime is Amazon Linux 2023/glibc, unlike\n   * the musl binaries the Docker/Lambda Web Adapter server function needs),\n   * and `required-server-files.json` (read by the handler at cold start to\n   * build `nextConfig`).\n   */\n  private prepareImageOptimizationAssets(standalonePath: string): string {\n    const assetPath = join(this.dotNextPath, \"cdk-nextjs-image-optimization\");\n    const nodeModulesPath = join(assetPath, \"node_modules\");\n    const imgPath = join(nodeModulesPath, \"@img\");\n\n    rmSync(assetPath, { recursive: true, force: true });\n    mkdirSync(imgPath, { recursive: true });\n\n    // Pre-bundled by esbuild into this package's own lib/ output.\n    cpSync(join(__dirname, \"..\", \"image-optimization\"), assetPath, {\n      recursive: true,\n    });\n\n    const sharpSource = this.findSharpPackage(\n      join(standalonePath, \"node_modules\"),\n    );\n    if (sharpSource) {\n      this.copySharpRuntime(sharpSource, nodeModulesPath);\n    } else {\n      console.warn(\n        `${LOG_PREFIX} \"sharp\" not found in standalone build output. Add \"sharp\" as a dependency of your Next.js app to enable image optimization.`,\n      );\n    }\n\n    const requiredServerFiles = join(\n      this.dotNextPath,\n      \"required-server-files.json\",\n    );\n    if (!existsSync(requiredServerFiles)) {\n      throw new Error(\n        `${LOG_PREFIX} \"required-server-files.json\" not found at ${requiredServerFiles}. The image optimization Lambda reads it at cold start to build its Next.js config.`,\n      );\n    }\n    cpSync(requiredServerFiles, join(assetPath, \"required-server-files.json\"));\n\n    const arch = getNodeArchitecture();\n    this.installSharpPackages(\n      imgPath,\n      this.getSharpBinaryPackages(sharpSource, `linux-${arch}`),\n    );\n\n    return assetPath;\n  }\n\n  /**\n   * Locate `sharp`'s JS wrapper inside a standalone `node_modules`.\n   *\n   * Next's output file tracing preserves the installer's on-disk layout, so\n   * npm/yarn produce a hoisted `node_modules/sharp` while pnpm only\n   * materializes `node_modules/.pnpm/sharp@<version>/node_modules/sharp`.\n   */\n  private findSharpPackage(nodeModulesPath: string): string | undefined {\n    const hoisted = join(nodeModulesPath, \"sharp\");\n    if (existsSync(join(hoisted, \"package.json\"))) {\n      return hoisted;\n    }\n\n    const pnpmPath = join(nodeModulesPath, \".pnpm\");\n    if (!existsSync(pnpmPath)) {\n      return undefined;\n    }\n\n    const candidates = readdirSync(pnpmPath)\n      .filter((name) => name.startsWith(\"sharp@\"))\n      .sort();\n    for (const candidate of candidates.reverse()) {\n      const nested = join(pnpmPath, candidate, \"node_modules\", \"sharp\");\n      if (existsSync(join(nested, \"package.json\"))) {\n        return nested;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Copy `sharp` plus the transitive `dependencies` closure `require(\"sharp\")`\n   * pulls in (`@img/colour`, `detect-libc`, `semver`) into `targetPath`.\n   *\n   * Copying only `sharp` itself leaves those requires unresolvable, and\n   * `imageOptimizer` swallows the resulting `MODULE_NOT_FOUND` by falling back\n   * to serving the unoptimized original, so the omission is otherwise silent.\n   */\n  private copySharpRuntime(sharpSource: string, targetPath: string): void {\n    // Under pnpm a package's dependencies are symlinked into the sibling\n    // directory alongside it, which is also where a hoisted layout keeps\n    // them, so the same lookup covers both.\n    const lookupPath = join(sharpSource, \"..\");\n    const queue = [\"sharp\"];\n    const copied = new Set<string>();\n\n    while (queue.length > 0) {\n      const name = queue.shift()!;\n      if (copied.has(name)) {\n        continue;\n      }\n\n      const source = name === \"sharp\" ? sharpSource : join(lookupPath, name);\n      if (!existsSync(join(source, \"package.json\"))) {\n        console.warn(\n          `${LOG_PREFIX} \"sharp\" dependency \"${name}\" not found in standalone build output; image optimization may fall back to serving unoptimized images.`,\n        );\n        continue;\n      }\n\n      // `dereference` resolves pnpm's symlinks into real files, since the\n      // Lambda asset is a standalone directory with no store to link into.\n      cpSync(source, join(targetPath, name), {\n        recursive: true,\n        dereference: true,\n      });\n      copied.add(name);\n\n      const manifest = JSON.parse(\n        readFileSync(join(source, \"package.json\"), \"utf-8\"),\n      );\n      // Platform binaries are optionalDependencies, installed separately at\n      // the versions this same manifest pins, so only `dependencies` here.\n      queue.push(...Object.keys(manifest.dependencies ?? {}));\n    }\n\n    debug(\n      `${LOG_PREFIX} Copied sharp runtime: ${[...copied].sort().join(\", \")}`,\n    );\n  }\n\n  /**\n   * Resolve the `@img/sharp-<platform>` and `@img/sharp-libvips-<platform>`\n   * versions to install for a given platform.\n   *\n   * These must match the `sharp` JS wrapper that output file tracing put in\n   * the standalone build: `sharp`'s `lib/libvips.js` compares the binary's\n   * reported libvips version against its own `minimumLibvipsVersion` and\n   * throws at load when they disagree. `sharp` pins both in its\n   * `optionalDependencies`, so that manifest is the authoritative source.\n   */\n  private getSharpBinaryPackages(\n    sharpSource: string | undefined,\n    platform: string,\n  ): { name: string; version: string }[] {\n    const fallback = [\n      { name: `sharp-libvips-${platform}`, version: \"1.2.4\" },\n      { name: `sharp-${platform}`, version: \"0.34.5\" },\n    ];\n\n    if (!sharpSource) {\n      return fallback;\n    }\n\n    const manifest = JSON.parse(\n      readFileSync(join(sharpSource, \"package.json\"), \"utf-8\"),\n    );\n    const optionalDependencies: Record<string, string> =\n      manifest.optionalDependencies ?? {};\n\n    return fallback.map((pkg) => {\n      const version = optionalDependencies[`@img/${pkg.name}`];\n      if (!version) {\n        console.warn(\n          `${LOG_PREFIX} sharp@${manifest.version} does not pin \"@img/${pkg.name}\"; falling back to ${pkg.version}.`,\n        );\n        return pkg;\n      }\n      return { name: pkg.name, version };\n    });\n  }\n\n  /**\n   * Download (with caching) and extract Sharp's platform-specific binary\n   * packages into `imgPath`.\n   */\n  private installSharpPackages(\n    imgPath: string,\n    packages: { name: string; version: string }[],\n  ): void {\n    const cacheDir = join(tmpdir(), \"cdk-nextjs-sharp-cache\");\n    if (!existsSync(cacheDir)) {\n      mkdirSync(cacheDir, { recursive: true });\n    }\n\n    for (const pkg of packages) {\n      try {\n        const targetDir = join(imgPath, pkg.name);\n        const url = `https://registry.npmjs.org/@img/${pkg.name}/-/${pkg.name}-${pkg.version}.tgz`;\n\n        // Create a consistent filename based on package name and version\n        const cacheFileName = `${pkg.name}-${pkg.version}.tgz`;\n        const cachedFile = join(cacheDir, cacheFileName);\n\n        // Check if we already have a valid package cached; re-download if\n        // a previous run left behind a truncated/corrupt download\n        if (existsSync(cachedFile) && this.isCachedFileValid(cachedFile)) {\n          debug(\n            `${LOG_PREFIX} Using cached ${pkg.name}@${pkg.version} from ${cachedFile}`,\n          );\n        } else {\n          debug(`${LOG_PREFIX} Downloading ${pkg.name}@${pkg.version}...`);\n\n          // Download to a process-unique temp file in the same directory,\n          // then atomically rename it onto the shared cache path. Concurrent\n          // synth processes (e.g. Turborepo running multiple `cdk` commands)\n          // share this cache dir, so writing directly to `cachedFile` risks\n          // another process extracting a half-written file. Renaming within\n          // the same filesystem is atomic, so readers only ever see a\n          // complete file, whichever process wins the race.\n          const tempFile = join(\n            cacheDir,\n            `${cacheFileName}.${process.pid}-${randomBytes(6).toString(\"hex\")}.tmp`,\n          );\n          try {\n            // --fail makes curl exit non-zero on HTTP errors and --retry\n            // handles transient connection drops so a partial transfer\n            // isn't cached as valid.\n            execSync(\n              `curl -L --fail --retry 3 --retry-delay 1 -o \"${tempFile}\" \"${url}\"`,\n              { stdio: \"pipe\" },\n            );\n\n            if (!this.isCachedFileValid(tempFile)) {\n              throw new Error(\n                `Downloaded file for ${pkg.name}@${pkg.version} is empty or missing: ${tempFile}`,\n              );\n            }\n\n            renameSync(tempFile, cachedFile);\n          } finally {\n            if (existsSync(tempFile)) {\n              rmSync(tempFile, { force: true });\n            }\n          }\n\n          debug(\n            `${LOG_PREFIX} Cached ${pkg.name}@${pkg.version} to ${cachedFile}`,\n          );\n        }\n\n        mkdirSync(targetDir, { recursive: true });\n        execSync(\n          `tar -xzf \"${cachedFile}\" -C \"${targetDir}\" --strip-components=1`,\n          { stdio: \"pipe\" },\n        );\n\n        debug(`${LOG_PREFIX} Installed ${pkg.name}@${pkg.version}`);\n      } catch (error) {\n        console.error(`${LOG_PREFIX} Failed to install ${pkg.name}: ${error}`);\n        throw error;\n      }\n    }\n  }\n\n  /**\n   * Checks that a cached Sharp binary archive is non-empty. Guards against\n   * a truncated/corrupt download (e.g. from a dropped connection) being\n   * reused across synth operations.\n   */\n  private isCachedFileValid(filePath: string): boolean {\n    try {\n      return statSync(filePath).size > 0;\n    } catch {\n      return false;\n    }\n  }\n}\n"]}
+/**
+ * What travels to the adapter in {@link FUNCTION_GROUPS_ENV_VAR}, and what it
+ * records back as `AdapterManifest.functionGroups`.
+ */
+function toFunctionGroupSpecs(groups) {
+    return groups.map(({ name, routes }) => ({ name, routes }));
+}
+/** `groups` in a canonical order, for comparing two of them. */
+function sortedGroupSpecs(groups) {
+    return groups
+        ?.map(({ name, routes }) => ({ name, routes: [...routes].sort() }))
+        .sort((a, b) => (a.name < b.name ? -1 : 1));
+}
+/**
+ * Pick the staged `sharp` JS wrapper out of every copy found in the tree.
+ *
+ * Unlike a standalone build there is no single `node_modules` to look in: the
+ * tree mirrors repo-root-relative paths, so the search is by directory name.
+ *
+ * An app can have two `sharp` copies at different versions (its own, hoisted,
+ * and next's, nested under `next/node_modules`), and every binary goes into the
+ * one root `@img`, so the copy pinning them has to be the one `next`'s image
+ * optimizer loads: `nextSharp`, when {@link resolveNextSharp} found it. Otherwise
+ * shortest path wins as the closest to a hoisted install, sorted for
+ * determinism.
+ */
+function pickStagedSharpPackage(candidates, nextSharp) {
+    const used = nextSharp &&
+        candidates.find((candidate) => nextSharp.startsWith((0, node_fs_1.realpathSync)(candidate) + node_path_1.sep));
+    if (used) {
+        return used;
+    }
+    candidates.sort((a, b) => a.length - b.length || a.localeCompare(b));
+    if (candidates.length > 1) {
+        debug(`${constants_1.LOG_PREFIX} Multiple staged "sharp" copies; using ${candidates[0]}`);
+    }
+    return candidates[0];
+}
+/**
+ * The real path of the `sharp` entry point the staged `next` resolves from
+ * `projectDir`, `undefined` when either does not resolve.
+ */
+function resolveNextSharp(projectDir) {
+    try {
+        // The anchor file needn't exist; `createRequire` only reads its directory.
+        const nextPackage = (0, node_module_1.createRequire)((0, node_path_1.join)(projectDir, "cdk-nextjs-next-resolver.cjs")).resolve("next/package.json");
+        return (0, node_module_1.createRequire)(nextPackage).resolve("sharp");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Whether the entry `name` in `parentPath` is an `@img/sharp-*` platform binary
+ * package, or pnpm's store entry for one.
+ *
+ * The name alone is not enough to delete a directory by. A route segment called
+ * `sharp-edges` stages `.next/server/app/sharp-edges/`, and removing it left the
+ * manifest listing an entrypoint that is no longer on disk — every request to
+ * that route 500ing with "Could not load the entrypoint". Nor is "a `sharp-`
+ * package": `sharp-ico` and `sharp-phash` are unrelated dependencies, and
+ * removing them failed the app at runtime with MODULE_NOT_FOUND. So both the
+ * scope and the place have to match:
+ *
+ * - `node_modules/@img/sharp-…`, where every platform binary actually lives
+ * - `node_modules/.pnpm/@img+sharp-…@0.35.4`, pnpm's store, whose entries are
+ *   also what the `@img` links point at (`sharp-libvips-…` matches the same way)
+ *
+ * The `node_modules` segment is required as well, so an app directory that
+ * happens to be called `@img` or `.pnpm` is still left alone.
+ */
+function isSharpBinaryPackage(parentPath, name) {
+    const segments = parentPath.split(node_path_1.sep);
+    const parent = segments[segments.length - 1];
+    const scoped = (parent === "@img" && name.startsWith("sharp-")) ||
+        (parent === ".pnpm" && name.startsWith("@img+sharp-"));
+    return scoped && segments.includes("node_modules");
+}
+/**
+ * Where the target's `@img/sharp-*` binaries go: `<root>/node_modules/@img`.
+ *
+ * Not next to the staged `sharp` package. Under pnpm that is
+ * `node_modules/.pnpm/sharp@x/node_modules/@img`, which only the store copy of
+ * `sharp` resolves from: a dereferenced link to `sharp` (a copy at
+ * `app/node_modules/sharp`, say) looks for `@img` from its own path and walks
+ * up, never into the store. Both the Functions zip (`zipDirectory`) and the
+ * Containers `COPY` keep the links, so it is the store copy that loads, and its
+ * walk up reaches the root `node_modules` too, so it serves either layout. It
+ * is also where main installed them.
+ */
+function sharpBinaryDir(root) {
+    return (0, node_path_1.join)(root, "node_modules", "@img");
+}
+/**
+ * Every entry under `root`, links listed but not followed.
+ *
+ * An explicit walk rather than `readdirSync({ recursive: true })`, which on
+ * Node 24 descends into symlinked directories itself and so never returns on a
+ * cycle — two workspace packages that link each other, which is how pnpm wires a
+ * monorepo.
+ */
+function listTree(root) {
+    const entries = [];
+    const pending = [root];
+    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
+        for (const entry of (0, node_fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            entries.push(entry);
+            if (entry.isDirectory()) {
+                pending.push((0, node_path_1.join)(dir, entry.name));
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Write {@link PUBLIC_FILES_FILE_NAME} into a deployment root's runtime
+ * directory: every file under `publicDir`, listed the way the runtime would
+ * list it off disk (`readPublicFiles`: symlinks followed, `/`-separated,
+ * sorted). An app without `public/` gets `[]`.
+ */
+function writePublicFileList(runtimeDir, publicDir) {
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(runtimeDir, manifest_1.PUBLIC_FILES_FILE_NAME), JSON.stringify((0, public_files_1.readPublicFiles)(publicDir)));
+}
+/**
+ * Total bytes of a tree as its deployment zip stores it. `zipDirectory` keeps
+ * links as links, so each counts as its target path, not as the target, which
+ * is walked at its own path anyway (every link in a staged root points inside
+ * it).
+ */
+function storedSize(root) {
+    let bytes = 0;
+    for (const entry of listTree(root)) {
+        if (!entry.isDirectory()) {
+            bytes += (0, node_fs_1.lstatSync)((0, node_path_1.join)(entry.parentPath, entry.name)).size;
+        }
+    }
+    return bytes;
+}
+/**
+ * `chunk` with `patch` prepended between `PATCH_FETCH_MARKER` and
+ * `PATCH_FETCH_END_MARKER`, or `undefined` when it already carries this exact
+ * patch.
+ *
+ * The opening marker carries a hash of the patch, so a chunk patched by a
+ * cdk-nextjs whose `patch-fetch.js` differs (an upgrade, over a `.next` reused
+ * with `skipBuild: true`) is not mistaken for current: the old patch is cut off
+ * at its end marker and this one put in its place, rather than the old one
+ * shipping or both stacking up.
+ */
+function patchClientChunk(chunk, patch, chunkPath) {
+    const hash = (0, node_crypto_1.createHash)("sha256").update(patch).digest("hex").slice(0, 16);
+    const open = `${PATCH_FETCH_MARKER} ${hash} */`;
+    if (chunk.startsWith(`${open}\n`)) {
+        return undefined;
+    }
+    let original = chunk;
+    if (chunk.startsWith(PATCH_FETCH_MARKER)) {
+        const end = chunk.indexOf(`\n${PATCH_FETCH_END_MARKER}\n`);
+        if (end === -1) {
+            // Only a pre-release cdk-nextjs wrote the marker without an end, and
+            // where its patch stops cannot be told from the chunk's own code.
+            throw new Error(`${constants_1.LOG_PREFIX} ${chunkPath} carries a cdk-nextjs fetch patch this ` +
+                `version cannot replace. Re-run \`next build\` to regenerate it.`);
+        }
+        original = chunk.slice(end + PATCH_FETCH_END_MARKER.length + 2);
+    }
+    return `${open}\n${patch}\n${PATCH_FETCH_END_MARKER}\n${original}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nextjs-build.js","sourceRoot":"","sources":["../../src/nextjs-build/nextjs-build.ts"],"names":[],"mappings":";;;;;;AAyJA,wDAKC;AAGD,8CAQC;AAs0BD,wDAmBC;AAMD,4CAUC;AAqBD,oDAUC;AAcD,wCAEC;AAUD,4BAYC;AAQD,kDAKC;AAQD,gCAQC;AAaD,4CAwBC;;AAzpCD,2DAA4D;AAC5D,6CAAsD;AACtD,qCAciB;AACjB,6CAA4C;AAC5C,qCAAiC;AACjC,yCAAsC;AACtC,2CAAoD;AAEpD,2CAAuC;AACvC,6DAA6D;AAC7D,kDAA6B;AAC7B,gEAKoC;AACpC,4CAAsD;AAEtD,kDAQ6B;AAC7B,0DAA0D;AAC1D,kDAI4B;AAC5B,gEAGmC;AAEnC;;;;;GAKG;AACH,MAAM,2BAA2B,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;AAEtD;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,2BAA2B,CAAC;AACvD,2EAA2E;AAC3E,MAAM,sBAAsB,GAAG,kCAAkC,CAAC;AAElE,MAAM,KAAK,GAAG,IAAA,eAAQ,EAAC,yBAAyB,CAAC,CAAC;AA8ElD;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,KAAuB;IAC5D,MAAM,WAAW,GACf,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,gBAAgB;QAChD,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,kBAAkB,CAAC;IACrD,OAAO,CAAC,WAAW,IAAI,KAAK,CAAC,YAAY,CAAC,IAAI,IAAA,wCAAqB,GAAE,CAAC;AACxE,CAAC;AAED,+FAA+F;AAC/F,SAAgB,iBAAiB,CAAC,QAGjC;IACC,MAAM,EAAE,YAAY,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC;IACzC,OAAO,YAAY;QACjB,CAAC,CAAC,GAAG,QAAQ,CAAC,OAAO,IAAI,YAAY,EAAE;QACvC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;AACvB,CAAC;AAOD;;;GAGG;AACH,MAAa,WAAY,SAAQ,sBAAS;;IACxC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAS;IAChB;;;OAGG;IACH,YAAY,CAAS;IACrB;;;OAGG;IACH,gBAAgB,CAAmB;IACnC;;;;;OAKG;IACH,wBAAwB,CAAS;IACjC;;OAEG;IACH,WAAW,CAAS;IACpB;;;;;OAKG;IACH,kBAAkB,CAAS;IAC3B;;;;;;;;;OASG;IACH,qBAAqB,CAAS;IAC9B;;;;;;;;;OASG;IACH,yBAAyB,CAAS;IAClC;;;;;;OAMG;IACH,eAAe,CAAyB;IACxC;;;;OAIG;IACH,sBAAsB,CAAgC;IACtD;;;;;OAKG;IACH,kBAAkB,CAAS;IAC3B;;;OAGG;IACH,YAAY,CAAe;IAEnB,KAAK,CAAmB;IACxB,YAAY,CAAS;IAE7B,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,WAAW,GAAG,IAAA,gBAAI,EAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAEvD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,IAAI,eAAe,CAAC;QAE1D,gCAAgC;QAChC,IAAI,CAAC,YAAY,GAAG,IAAA,gBAAI,EACtB,KAAK,CAAC,cAAc,EACpB,OAAO,EACP,uBAAuB,CACxB,CAAC;QAEF,6EAA6E;QAC7E,6EAA6E;QAC7E,uEAAuE;QACvE,qEAAqE;QACrE,2EAA2E;QAC3E,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;YACzB,IAAA,wCAAsB,EAAC,KAAK,CAAC,cAAqC,CAAC,CAAC;QACtE,CAAC;QAED,8BAA8B;QAC9B,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,GAAG,sBAAU,cAAc,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;QACxD,CAAC;QAED,2EAA2E;QAC3E,2EAA2E;QAC3E,6CAA6C;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE5C,wEAAwE;QACxE,wEAAwE;QACxE,0EAA0E;QAC1E,uEAAuE;QACvE,uEAAuE;QACvE,2DAA2D;QAC3D,IAAI,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,gBAAgB,EAAE,CAAC;YACrD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAC3C,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QACxD,yDAAyD;QACzD,gCAAgC;QAChC,IAAI,CAAC,kBAAkB,GAAG,IAAA,6BAAiB,EAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,CAAC,qBAAqB,GAAG,IAAA,+BAAmB,EAC9C,QAAQ,CAAC,MAAM,CAAC,WAAW,CAC5B,CAAC;QACF,IAAI,CAAC,yBAAyB,GAAG,IAAA,2BAAe,EAC9C,QAAQ,CAAC,MAAM,CAAC,WAAW,CAC5B,CAAC;QAEF,MAAM,WAAW,GACf,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,gBAAgB;YAChD,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,kBAAkB,CAAC;QAErD,IAAI,CAAC,kBAAkB,GAAG,QAAQ,CAAC,kBAAkB,CAAC;QACtD,IAAI,CAAC,wBAAwB,GAAG,IAAA,YAAS,EAAC,2BAAgB,EAAE,YAAY,CAAC,CAAC;QAC1E,IAAI,CAAC,YAAY,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAI,CAAC,sBAAsB,GAAG,QAAQ,CAAC,SAAS,IAAI,EAAE,CAAC;QAEvD,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,KAAK,sBAAU,CAAC,mBAAmB,CAAC;QACzE,IAAI,YAAY,EAAE,CAAC;YACjB,yEAAyE;YACzE,sEAAsE;YACtE,2DAA2D;YAC3D,IAAA,mBAAS,EAAC,IAAA,gBAAI,EAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACvE,CAAC;QAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACxC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;YACxD,0EAA0E;YAC1E,uEAAuE;YACvE,2CAA2C;YAC3C,IAAI,CAAC,mBAAmB,CACtB,IAAI,EACJ,IAAA,gBAAI,EAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,EACxC,GAAG,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,IAAI,IAAA,qCAAkB,EAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAClF,CAAC;YAEF,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACK,sBAAsB,CAC5B,QAAyB;QAEzB,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;QAE/B,4EAA4E;QAC5E,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,oDAAoD;QACpD,wEAAwE;QACxE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM;YAC9C,CAAC,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;YACjD,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,GAAG,GAAG,QAAQ,CAAC,cAAc,CAAC;QAEpC,IACE,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACxC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,EACrC,CAAC;YACD,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,+BAA+B;gBAC1C,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,cAAc,iBAAiB;gBACpE,MAAM,IAAI,CAAC,WAAW,kBAAkB;gBACxC,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,0BAA0B,IAAI;gBAC7D,uEAAuE;gBACvE,OAAO,yCAAuB,uCAAuC;gBACrE,mEAAmE;gBACnE,eAAe,CAClB,CAAC;QACJ,CAAC;QAED,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,wCAAsB,CAAC,CAAC;QACtE,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACjC,IAAI;YACJ,IAAI,EAAE,IAAA,gBAAI,EACR,IAAI,CAAC,WAAW,EAChB,2BAAgB,EAChB,GAAG,IAAA,8BAAmB,EAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAC7D;YACD,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE;SAC7B,CAAC,CAAC,CAAC;QAEJ,qEAAqE;QACrE,yBAAyB;QACzB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAClB,CAAC,CAAC,IAAI,KAAK,wCAAsB;YAC/B,CAAC,CAAC,CAAC,CAAC;YACJ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,wCAAsB;gBACjC,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CACnC,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,IAAA,oBAAU,EAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,0CAA0C;oBACrD,IAAI,IAAI,CAAC,IAAI,qBAAqB,IAAI,CAAC,IAAI,uBAAuB;oBAClE,qEAAqE;oBACrE,qBAAqB,CACxB,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACK,sBAAsB,CAAC,IAA0B;QACvD,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,KAAK,CACH,GAAG,sBAAU,qBAAqB,IAAI,CAAC,IAAI,QAAQ,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,CAC1F,CAAC;QACF,IAAI,KAAK,IAAI,2BAA2B,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QACD,MAAM,EAAE,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;QACvE,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QAChD,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,oBAAoB,IAAI,CAAC,IAAI,QAAQ,EAAE,CAAC,KAAK,CAAC,aAAa;YACtE,iBAAiB,EAAE,CAAC,2BAA2B,CAAC,UAAU;YAC1D,CAAC,OAAO;gBACN,CAAC,CAAC,qEAAqE;oBACrE,sEAAsE;oBACtE,qDAAqD;gBACvD,CAAC,CAAC,kEAAkE;oBAClE,iEAAiE;oBACjE,qEAAqE;oBACrE,iBAAiB,CAAC,CACzB,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACK,mBAAmB;QACzB,MAAM,YAAY,GAAG,IAAA,gBAAI,EACvB,IAAI,CAAC,WAAW,EAChB,2BAAgB,EAChB,6BAAkB,CACnB,CAAC;QACF,IAAI,CAAC,IAAA,oBAAU,EAAC,YAAY,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CACb,4CAA4C,YAAY,IAAI;gBAC1D,IAAI,IAAI,CAAC,YAAY,+CAA+C;gBACpE,mEAAmE;gBACnE,uEAAuE;gBACvE,uEAAuE;gBACvE,qEAAqE;gBACrE,sDAAsD;gBACtD,4DAA4D;gBAC5D,6DAA6D;gBAC7D,4CAA4C,CAC/C,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAoB,IAAI,CAAC,KAAK,CAC1C,IAAA,sBAAY,EAAC,YAAY,EAAE,OAAO,CAAC,CACpC,CAAC;QACF,IAAI,QAAQ,CAAC,OAAO,KAAK,mCAAwB,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CACb,sCAAsC,YAAY,cAAc;gBAC9D,GAAG,QAAQ,CAAC,OAAO,iDAAiD;gBACpE,GAAG,mCAAwB,sCAAsC;gBACjE,sEAAsE;gBACtE,kEAAkE,CACrE,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACK,YAAY,CAClB,cAAsB,EACtB,WAAoB,EACpB,YAAqB;QAErB,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC;QACxD,MAAM,MAAM,GAAG,IAAA,gBAAI,EAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAEvD,MAAM,UAAU,GAAG,IAAA,gBAAI,EAAC,cAAc,EAAE,2BAAgB,CAAC,CAAC;QAC1D,2EAA2E;QAC3E,sEAAsE;QACtE,IAAA,gBAAM,EAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,IAAA,mBAAS,EAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3C,IAAA,gBAAM,EAAC,MAAM,EAAE,IAAA,gBAAI,EAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;QACxC,IAAA,gBAAM,EACJ,IAAA,gBAAI,EAAC,IAAI,CAAC,WAAW,EAAE,2BAAgB,EAAE,6BAAkB,CAAC,EAC5D,IAAA,gBAAI,EAAC,UAAU,EAAE,6BAAkB,CAAC,CACrC,CAAC;QACF,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,uEAAuE;YACvE,uEAAuE;YACvE,qCAAqC;YACrC,wEAAwE;YACxE,0EAA0E;YAC1E,mBAAmB,CACjB,UAAU,EACV,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,CAC1C,CAAC;QACJ,CAAC;QACD,KAAK,CACH,GAAG,sBAAU,WAAW,KAAK,QAAQ,6BAAkB,OAAO,UAAU,EAAE,CAC3E,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACK,cAAc;QACpB,IAAI,CAAC;YACH,OAAO;gBACL,iBAAiB,EAAE,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE;oBACvD,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;iBACnC,CAAC;aACH,CAAC;QACJ,CAAC;QAAC,MAAM,CAAC;YACP,KAAK,CACH,GAAG,sBAAU,+CAA+C;gBAC1D,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,wCAAwC;gBACpE,uCAAuC,CAC1C,CAAC;YACF,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACK,YAAY;QAClB,OAAO,CAAC,GAAG,CACT,GAAG,sBAAU,cAAc,IAAI,CAAC,YAAY,mBAAmB,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAC3F,CAAC;QAEF,0EAA0E;QAC1E,IAAI,IAAA,oBAAU,EAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YAClC,IAAA,gBAAM,EAAC,IAAI,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAC5D,KAAK,CAAC,qCAAqC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;QAClE,CAAC;QAED,IAAI,CAAC;YACH,IAAA,6BAAQ,EAAC,IAAI,CAAC,YAAY,EAAE;gBAC1B,KAAK,EAAE,SAAS;gBAChB,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,cAAc;gBAC9B,GAAG,EAAE;oBACH,GAAG,OAAO,CAAC,GAAG;oBACd,yBAAyB,EAAE,IAAI,CAAC,YAAY;oBAC5C,GAAG,IAAI,CAAC,cAAc,EAAE;oBACxB,iEAAiE;oBACjE,gEAAgE;oBAChE,+DAA+D;oBAC/D,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,MAAM;wBACnC,CAAC,CAAC;4BACE,CAAC,yCAAuB,CAAC,EAAE,IAAI,CAAC,SAAS,CACvC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAChD;yBACF;wBACH,CAAC,CAAC,EAAE,CAAC;iBACR;aACF,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,uBAAuB,KAAK,EAAE,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACK,oBAAoB;QAC1B,MAAM,gBAAgB,GAAG,IAAA,gBAAI,EAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACpE,MAAM,UAAU,GAAG,IAAA,qBAAW,EAAC,gBAAgB,CAAC,CAAC,MAAM,CACrD,CAAC,IAAY,EAAE,EAAE;QACf,8CAA8C;QAC9C,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;YAC5B,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAC1D,CAAC;QAEF,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;QAC9D,CAAC;QAED,kCAAkC;QAClC,MAAM,cAAc,GAAG,IAAA,gBAAI,EAAC,SAAS,EAAE,gBAAgB,CAAC,CAAC;QACzD,MAAM,iBAAiB,GAAG,IAAA,sBAAY,EAAC,cAAc,EAAE,OAAO,CAAC,CAAC;QAEhE,yEAAyE;QACzE,wEAAwE;QACxE,oEAAoE;QACpE,4DAA4D;QAC5D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,aAAa,GAAG,IAAA,gBAAI,EAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;YACxD,MAAM,cAAc,GAAG,gBAAgB,CACrC,IAAA,sBAAY,EAAC,aAAa,EAAE,OAAO,CAAC,EACpC,iBAAiB,EACjB,aAAa,CACd,CAAC;YACF,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;gBACjC,KAAK,CAAC,GAAG,sBAAU,+BAA+B,aAAa,EAAE,CAAC,CAAC;gBACnE,SAAS;YACX,CAAC;YACD,IAAA,uBAAa,EAAC,aAAa,EAAE,cAAc,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,MAAM,aAAa,GAAG,IAAA,gBAAI,EAAC,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;QAChE,IAAI,CAAC,IAAA,oBAAU,EAAC,aAAa,CAAC,EAAE,CAAC;YAC/B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,IAAA,qBAAW,EAAC,aAAa,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACzE,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE;SACjC,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;;;;;;;;;;OAWG;IACK,mBAAmB,CACzB,IAA0B,EAC1B,UAAkB,EAClB,QAAgB;QAEhB,MAAM,WAAW,GAAG,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC5E,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,IAAI,IAAI,CAAC,IAAI,KAAK,wCAAsB,EAAE,CAAC;gBACzC,OAAO,CAAC,IAAI,CACV,GAAG,sBAAU,8HAA8H,CAC5I,CAAC;YACJ,CAAC;YACD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,oBAAoB,CACvB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EACzB,IAAI,CAAC,sBAAsB,CAAC,WAAW,EAAE,QAAQ,CAAC,CACnD,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACK,2BAA2B,CACjC,IAAY,EACZ,UAAkB;QAElB,MAAM,eAAe,GAAa,EAAE,CAAC;QAErC,qEAAqE;QACrE,wEAAwE;QACxE,kEAAkE;QAClE,kCAAkC;QAClC,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAElC,wEAAwE;QACxE,0EAA0E;QAC1E,yEAAyE;QACzE,wEAAwE;QACxE,qDAAqD;QACrD,2EAA2E;QAC3E,4EAA4E;QAC5E,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,MAAM,WAAW,GAAa,EAAE,CAAC;QAEjC,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;YAC/B,IAAI,KAAK,CAAC,WAAW,EAAE,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;gBAClD,MAAM,IAAI,GAAG,IAAA,gBAAI,EAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;gBAChD,IAAI,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAI,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC;oBAC3C,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAC7B,CAAC;gBACD,SAAS;YACX,CAAC;YACD,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC;gBAAE,SAAS;YAClE,MAAM,QAAQ,GAAG,IAAA,gBAAI,EAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACpD,IAAI,KAAK,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC3B,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC1B,CAAC;iBAAM,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBAC/B,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QAED,KAAK,CACH,GAAG,sBAAU,aAAa,QAAQ,CAAC,MAAM,8BAA8B,WAAW,CAAC,MAAM,cAAc,CACxG,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,IAAA,oBAAU,EAAC,IAAI,CAAC,CAAC;YACjB,KAAK,CAAC,GAAG,sBAAU,cAAc,IAAI,EAAE,CAAC,CAAC;QAC3C,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;YAC/B,IAAA,gBAAM,EAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAC/C,KAAK,CAAC,GAAG,sBAAU,aAAa,IAAI,EAAE,CAAC,CAAC;QAC1C,CAAC;QACD,OAAO,sBAAsB,CAC3B,eAAe,EACf,gBAAgB,CAAC,UAAU,CAAC,CAC7B,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACK,sBAAsB,CAC5B,WAAmB,EACnB,QAAgB;QAEhB,qDAAqD;QACrD,MAAM,QAAQ,GAAG;YACf,EAAE,IAAI,EAAE,iBAAiB,QAAQ,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;YACvD,EAAE,IAAI,EAAE,SAAS,QAAQ,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;SACjD,CAAC;QAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,IAAA,sBAAY,EAAC,IAAA,gBAAI,EAAC,WAAW,EAAE,cAAc,CAAC,EAAE,OAAO,CAAC,CACzD,CAAC;QACF,MAAM,oBAAoB,GACxB,QAAQ,CAAC,oBAAoB,IAAI,EAAE,CAAC;QAEtC,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1B,MAAM,OAAO,GAAG,oBAAoB,CAAC,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CACV,GAAG,sBAAU,UAAU,QAAQ,CAAC,OAAO,uBAAuB,GAAG,CAAC,IAAI,sBAAsB,GAAG,CAAC,OAAO,GAAG,CAC3G,CAAC;gBACF,OAAO,GAAG,CAAC;YACb,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;QACrC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,oBAAoB,CAC1B,OAAe,EACf,QAA6C;QAE7C,MAAM,QAAQ,GAAG,IAAA,gBAAI,EAAC,IAAA,gBAAM,GAAE,EAAE,wBAAwB,CAAC,CAAC;QAC1D,IAAA,mBAAS,EAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAEzC,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,SAAS,GAAG,IAAA,gBAAI,EAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YAC1C,MAAM,GAAG,GAAG,mCAAmC,GAAG,CAAC,IAAI,MAAM,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,MAAM,CAAC;YAE3F,iEAAiE;YACjE,MAAM,aAAa,GAAG,GAAG,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,MAAM,CAAC;YACvD,MAAM,UAAU,GAAG,IAAA,gBAAI,EAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;YAEjD,kEAAkE;YAClE,0DAA0D;YAC1D,IAAI,IAAA,oBAAU,EAAC,UAAU,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjE,KAAK,CACH,GAAG,sBAAU,iBAAiB,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,SAAS,UAAU,EAAE,CAC3E,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,GAAG,sBAAU,gBAAgB,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC;gBAEjE,gEAAgE;gBAChE,mEAAmE;gBACnE,mEAAmE;gBACnE,kEAAkE;gBAClE,kEAAkE;gBAClE,4DAA4D;gBAC5D,kDAAkD;gBAClD,MAAM,QAAQ,GAAG,IAAA,gBAAI,EACnB,QAAQ,EACR,GAAG,aAAa,IAAI,OAAO,CAAC,GAAG,IAAI,IAAA,yBAAW,EAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CACxE,CAAC;gBACF,IAAI,CAAC;oBACH,6DAA6D;oBAC7D,2DAA2D;oBAC3D,yBAAyB;oBACzB,IAAA,iCAAY,EACV,MAAM,EACN;wBACE,IAAI;wBACJ,QAAQ;wBACR,SAAS;wBACT,GAAG;wBACH,eAAe;wBACf,GAAG;wBACH,IAAI;wBACJ,QAAQ;wBACR,GAAG;qBACJ,EACD,EAAE,KAAK,EAAE,MAAM,EAAE,CAClB,CAAC;oBAEF,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,CAAC;wBACtC,MAAM,IAAI,KAAK,CACb,uBAAuB,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,yBAAyB,QAAQ,EAAE,CAClF,CAAC;oBACJ,CAAC;oBAED,IAAA,oBAAU,EAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;gBACnC,CAAC;wBAAS,CAAC;oBACT,IAAA,gBAAM,EAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBACpC,CAAC;gBAED,KAAK,CACH,GAAG,sBAAU,WAAW,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,OAAO,UAAU,EAAE,CACnE,CAAC;YACJ,CAAC;YAED,IAAA,mBAAS,EAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC1C,IAAA,iCAAY,EACV,KAAK,EACL,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,sBAAsB,CAAC,EAC7D,EAAE,KAAK,EAAE,MAAM,EAAE,CAClB,CAAC;YAEF,KAAK,CAAC,GAAG,sBAAU,cAAc,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,iBAAiB,CAAC,QAAgB;QACxC,IAAI,CAAC;YACH,OAAO,IAAA,kBAAQ,EAAC,QAAQ,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;QACrC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;;AAxxBH,kCAyxBC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAC3B,MAAmC;IAEnC,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,gEAAgE;AAChE,SAAS,gBAAgB,CACvB,MAAgD;IAEhD,OAAO,MAAM;QACX,EAAE,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;SAClE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,sBAAsB,CACpC,UAAoB,EACpB,SAAkB;IAElB,MAAM,IAAI,GACR,SAAS;QACT,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAC5B,SAAS,CAAC,UAAU,CAAC,IAAA,sBAAY,EAAC,SAAS,CAAC,GAAG,eAAG,CAAC,CACpD,CAAC;IACJ,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IACD,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACrE,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,KAAK,CACH,GAAG,sBAAU,0CAA0C,UAAU,CAAC,CAAC,CAAC,EAAE,CACvE,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,UAAkB;IACjD,IAAI,CAAC;QACH,2EAA2E;QAC3E,MAAM,WAAW,GAAG,IAAA,2BAAa,EAC/B,IAAA,gBAAI,EAAC,UAAU,EAAE,8BAA8B,CAAC,CACjD,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;QAC/B,OAAO,IAAA,2BAAa,EAAC,WAAW,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,oBAAoB,CAClC,UAAkB,EAClB,IAAY;IAEZ,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC,eAAG,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7C,MAAM,MAAM,GACV,CAAC,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;QAChD,CAAC,MAAM,KAAK,OAAO,IAAI,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;IACzD,OAAO,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,cAAc,CAAC,IAAY;IACzC,OAAO,IAAA,gBAAI,EAAC,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,QAAQ,CAAC,IAAY;IACnC,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC;IACvB,KAAK,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,GAAG,KAAK,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC;QACrE,KAAK,MAAM,KAAK,IAAI,IAAA,qBAAW,EAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;YAC9D,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACpB,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBACxB,OAAO,CAAC,IAAI,CAAC,IAAA,gBAAI,EAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,UAAkB,EAAE,SAAiB;IACvE,IAAA,uBAAa,EACX,IAAA,gBAAI,EAAC,UAAU,EAAE,iCAAsB,CAAC,EACxC,IAAI,CAAC,SAAS,CAAC,IAAA,8BAAe,EAAC,SAAS,CAAC,CAAC,CAC3C,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAC,IAAY;IACrC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;YACzB,KAAK,IAAI,IAAA,mBAAS,EAAC,IAAA,gBAAI,EAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9D,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAC9B,KAAa,EACb,KAAa,EACb,SAAiB;IAEjB,MAAM,IAAI,GAAG,IAAA,wBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC3E,MAAM,IAAI,GAAG,GAAG,kBAAkB,IAAI,IAAI,KAAK,CAAC;IAChD,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,KAAK,CAAC,UAAU,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACzC,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,sBAAsB,IAAI,CAAC,CAAC;QAC3D,IAAI,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC;YACf,qEAAqE;YACrE,kEAAkE;YAClE,MAAM,IAAI,KAAK,CACb,GAAG,sBAAU,IAAI,SAAS,yCAAyC;gBACjE,iEAAiE,CACpE,CAAC;QACJ,CAAC;QACD,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,GAAG,sBAAsB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,GAAG,IAAI,KAAK,KAAK,KAAK,sBAAsB,KAAK,QAAQ,EAAE,CAAC;AACrE,CAAC","sourcesContent":["import { execFileSync, execSync } from \"node:child_process\";\nimport { createHash, randomBytes } from \"node:crypto\";\nimport {\n  Dirent,\n  existsSync,\n  lstatSync,\n  readFileSync,\n  readdirSync,\n  writeFileSync,\n  rmSync,\n  mkdirSync,\n  cpSync,\n  renameSync,\n  realpathSync,\n  statSync,\n  unlinkSync,\n} from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { tmpdir } from \"node:os\";\nimport { join, sep } from \"node:path\";\nimport { join as joinPosix } from \"node:path/posix\";\nimport { Architecture } from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport getDebug from \"debug\";\nimport {\n  DEFAULT_FUNCTION_GROUP,\n  FUNCTION_GROUPS_ENV_VAR,\n  FunctionGroupSpec,\n  validateFunctionGroups,\n} from \"../adapter/function-groups\";\nimport { LOG_PREFIX, NextjsType } from \"../constants\";\nimport { NextjsBaseProps } from \"../root-constructs/nextjs-base-construct\";\nimport {\n  ADAPTER_DIR_NAME,\n  ADAPTER_MANIFEST_VERSION,\n  AdapterManifest,\n  MANIFEST_FILE_NAME,\n  PUBLIC_FILES_FILE_NAME,\n  RUNTIME_DIR_NAME,\n  groupStagingDirName,\n} from \"../runtime/manifest\";\nimport { readPublicFiles } from \"../runtime/public-files\";\nimport {\n  assetPrefixPath,\n  normalizeBasePath,\n  relativeAssetPrefix,\n} from \"../utils/base-path\";\nimport {\n  getLambdaArchitecture,\n  toNodeArchitecture,\n} from \"../utils/get-architecture\";\n\n/**\n * Lambda's hard limit on the unzipped size of a function's code, which\n * CloudFormation only enforces at deploy time. Measured at synth instead, so the\n * error names the group and arrives in seconds rather than minutes.\n * @see https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html\n */\nconst LAMBDA_UNZIPPED_LIMIT_BYTES = 250 * 1024 * 1024;\n\n/**\n * Opens the patch `patchFetchInClientJs` prepends to a client chunk, followed by\n * a hash of the patch itself, so a second synth over the same `.next` is a no-op\n * while one by a cdk-nextjs with a different `patch-fetch.js` replaces it.\n */\nconst PATCH_FETCH_MARKER = \"/* cdk-nextjs:patch-fetch\";\n/** Closes the prepended patch; the chunk's own content starts after it. */\nconst PATCH_FETCH_END_MARKER = \"/* cdk-nextjs:patch-fetch:end */\";\n\nconst debug = getDebug(\"cdk-nextjs:nextjs-build\");\n\nexport interface NextjsBuildProps {\n  /**\n   * @see {@link NextjsBaseProps[\"buildCommand\"]}\n   */\n  readonly buildCommand: NextjsBaseProps[\"buildCommand\"];\n  /**\n   * Directory where the Next.js application is located for local builds.\n   * This should contain the package.json and Next.js application files.\n   */\n  readonly buildDirectory: string;\n  readonly nextjsType: NextjsType;\n  /**\n   * @see {@link NextjsBaseProps.skipBuild}\n   */\n  readonly skipBuild?: boolean;\n  /**\n   * Route groups to package into separate Lambda functions. Only the two\n   * Functions `NextjsType`s pass this; see `NextjsFunctionGroup`.\n   */\n  readonly functionGroups?: NextjsFunctionGroupRoutes[];\n  /**\n   * Lambda architecture the Functions types deploy, which decides the `sharp`\n   * binaries staged into the deployment roots. Ignored by the Containers\n   * types, whose image is built for the synth machine.\n   * @default - the architecture of the machine running synth\n   */\n  readonly architecture?: Architecture;\n}\n\n/**\n * The part of a function group `NextjsBuild` needs: which routes it owns. The\n * per-group Lambda `overrides` are `NextjsFunctions`' business.\n */\nexport interface NextjsFunctionGroupRoutes {\n  readonly name: string;\n  readonly routes: string[];\n}\n\n/** One staged deployment root, and the function group it belongs to. */\nexport interface NextjsDeploymentRoot {\n  /**\n   * Group name, `default` for the implicit group that owns every unassigned\n   * route. The only entry is `default` when `functionGroups` is not used.\n   */\n  readonly name: string;\n  /** Absolute path to the deployment root: the Lambda zip asset's source. */\n  readonly path: string;\n  /**\n   * Route templates this root's package holds, as the adapter assigned them.\n   * Empty is legal: the default group still serves `/_next/image`, the static\n   * files the runtime reads off disk, and anything the catch-all routes to it.\n   */\n  readonly routes: string[];\n}\n\n/**\n * One behavior that routes a function group's URLs to it, as the adapter\n * checked them against what each group was packaged with.\n */\nexport interface NextjsFunctionGroupBehavior {\n  /** The function group the behavior routes to. */\n  readonly group: string;\n  /**\n   * The group pattern it came from (`/blog/**`), or the parent of an optional\n   * catch-all a subtree pattern moved into the group (`/blog` for\n   * `/blog/[[...slug]]`), which that subtree's behavior does not match.\n   */\n  readonly route: string;\n  /**\n   * The CloudFront path pattern, before basePath and without a leading slash:\n   * `blog/*`, `pricing`, `pricing/` for a `trailingSlash` app, and\n   * `_next/data/<buildId>/blog/*` for a group owning a Pages Router page.\n   */\n  readonly pattern: string;\n}\n\n/**\n * What every deployment root is staged for: the build's `architecture`, else\n * the synth machine's. Containers ignore it: Docker builds their image\n * natively, so it can only match the synth machine.\n */\nexport function deploymentArchitecture(props: NextjsBuildProps): Architecture {\n  const isFunctions =\n    props.nextjsType === NextjsType.GLOBAL_FUNCTIONS ||\n    props.nextjsType === NextjsType.REGIONAL_FUNCTIONS;\n  return (isFunctions && props.architecture) || getLambdaArchitecture();\n}\n\n/** {@link NextjsBuild.buildId}: Next.js's build ID, suffixed with the app's `deploymentId`. */\nexport function deploymentBuildId(manifest: {\n  readonly buildId: string;\n  readonly config: { readonly deploymentId: string };\n}): string {\n  const { deploymentId } = manifest.config;\n  return deploymentId\n    ? `${manifest.buildId}-${deploymentId}`\n    : manifest.buildId;\n}\n\nexport interface PublicDirEntry {\n  readonly name: string;\n  readonly isDirectory: boolean;\n}\n\n/**\n * Builds Next.js assets.\n * @link https://nextjs.org/docs/pages/api-reference/next-config-js/output\n */\nexport class NextjsBuild extends Construct {\n  /**\n   * Unique id for this deployment. Used to partition cache storage and as\n   * metadata for static assets in S3 bucket.\n   *\n   * Next.js's build ID, suffixed with the app's `deploymentId` when it sets\n   * one. The build ID alone is not unique per deployment: setting\n   * `deploymentId` (or building with `NEXT_DEPLOYMENT_ID`) turns on skew\n   * protection, and next.js then *pins* the build ID to the constant\n   * `build-TfctsWXpff2fKS` — see `getBuildId` in `next/dist/build/index.js`,\n   * which does that deliberately so that tooling doing\n   * `.replace(escapedBuildId, …)` still has something to replace. Two\n   * successive deployments of such an app would share one cache prefix and one\n   * revalidation-table partition, and the new one would read the previous\n   * one's prerenders. Appending the deployment ID restores the \"one\n   * deployment, one partition\" invariant that ID exists to carry.\n   *\n   * Nothing routes on this value — the `/_next/data/<buildId>/…` URL space is\n   * routed on Next.js's own build ID, which is what the app's client bundles\n   * carry — so it is free to be longer than next.js's own.\n   */\n  buildId: string;\n  /**\n   * Absolute path to the init cache directory\n   * @example \"/Users/john/myapp/.next/cdk-nextjs-init-cache\"\n   */\n  initCacheDir: string;\n  /**\n   * Absolute path to public. Use by CloudFront/ALB to create behaviors/rules\n   * @example \"/Users/john/myapp/public\"\n   */\n  publicDirEntries: PublicDirEntry[];\n  /**\n   * The JavaScript file Node.js runs to serve requests, relative to the\n   * deployment root. cdk-nextjs's own container shell, not `next build` output,\n   * so it is the same path for every app.\n   * @example \"cdk-nextjs-runtime/server.mjs\"\n   */\n  relativePathToEntrypoint: string;\n  /**\n   * Absolute path to the .next directory containing Next.js build artifacts\n   */\n  dotNextPath: string;\n  /**\n   * The Next.js app's own `basePath` — the URL prefix it generates its links and\n   * asset hrefs under — as the adapter manifest recorded it. Normalized to a bare path segment, empty when the app sets none. Exposed so\n   * root constructs can reconcile it with the CDK `basePath` prop, which is a\n   * distinct thing; see `resolveBasePath`.\n   */\n  nextConfigBasePath: string;\n  /**\n   * The Next.js app's own `assetPrefix`, as a path with a leading slash and no\n   * trailing one, empty when the app sets none or sets an absolute URL (which\n   * names an origin cdk-nextjs does not serve).\n   *\n   * Exposed because it is the shape of `assetPrefix` the regional\n   * `NextjsType`s cannot serve — see `warnUnservedAssetPrefix`. What the\n   * distribution has to answer on is {@link nextConfigAssetPrefixPath}, which\n   * also covers the path an absolute prefix carries.\n   */\n  nextConfigAssetPrefix: string;\n  /**\n   * The path portion of the app's `assetPrefix`, whichever form it takes: \"/cdn\"\n   * for both `assetPrefix: \"/cdn\"` and `assetPrefix:\n   * \"https://cdn.example.com/cdn\"`, empty when there is no path to answer on.\n   *\n   * Exposed because it is a URL prefix the distribution has to answer on: Next.js\n   * emits `<assetPrefix>/_next/static/...` for every bundle and compiles a rewrite\n   * that serves those URLs' paths itself, while the objects live in S3 under\n   * `<basePath>/_next/static/...`.\n   */\n  nextConfigAssetPrefixPath: string;\n  /**\n   * Every staged deployment root, one per function group, `default` first: the\n   * staged union of each group's shipped outputs and their traced assets,\n   * written by the adapter's `onBuildComplete`. Exactly one entry (named\n   * `default`, at `.next/cdk-nextjs-adapter/app`) unless `functionGroups`\n   * splits the app. The Lambda zip assets; Containers `COPY` the `default` one.\n   */\n  deploymentRoots: NextjsDeploymentRoot[];\n  /**\n   * What routes each non-default function group's URLs to it, most specific\n   * first — the order CloudFront has to see them in, since it stops at the\n   * first match. Empty unless `functionGroups` splits the app.\n   */\n  functionGroupBehaviors: NextjsFunctionGroupBehavior[];\n  /**\n   * From the deployment root to the Next.js project dir, POSIX, `\"\"` when\n   * the app is at the repo root. The runtime `chdir`s here; Containers pass it to\n   * their Dockerfile so `.next/static` and `public` land in the same place.\n   * @see AdapterManifest.relativeProjectDir\n   */\n  relativeProjectDir: string;\n  /**\n   * The architecture every deployment root's native dependencies (`sharp`)\n   * were staged for. The Lambdas deploying them must use the same one.\n   */\n  architecture: Architecture;\n\n  private props: NextjsBuildProps;\n  private buildCommand: string;\n\n  constructor(scope: Construct, id: string, props: NextjsBuildProps) {\n    super(scope, id);\n    this.props = props;\n    this.dotNextPath = join(props.buildDirectory, \".next\");\n\n    this.buildCommand = props.buildCommand || \"npm run build\";\n\n    // Set init cache directory path\n    this.initCacheDir = join(\n      props.buildDirectory,\n      \".next\",\n      \"cdk-nextjs-init-cache\",\n    );\n\n    // Before the build, not after it: the build is minutes long, and the env var\n    // it passes groups through is only set for a non-empty array — so an invalid\n    // `functionGroups` (an empty array, a reserved name, a group owning no\n    // routes) would otherwise be reported as \"the build staged the wrong\n    // groups\", after paying for the build, instead of as the prop error it is.\n    if (props.functionGroups) {\n      validateFunctionGroups(props.functionGroups as FunctionGroupSpec[]);\n    }\n\n    // Execute local build process\n    if (props.skipBuild !== true) {\n      this.runNextBuild();\n    } else {\n      debug(`${LOG_PREFIX} Skipping: ${this.buildCommand}`);\n    }\n\n    // First, before anything else reads `.next`: a missing manifest is the one\n    // error that names the cause (no build, or one without the adapter), where\n    // every later read fails with a bare ENOENT.\n    const manifest = this.readAdapterManifest();\n\n    // Deliberately outside the `skipBuild` gate. The patch is a property of\n    // *serving* through CloudFront, not of who ran `next build`: without it\n    // every POST with a body is rejected by the Lambda Function URL before it\n    // reaches the app (see `patchFetchInClientJs`). Running it only inside\n    // `runNextBuild` meant `skipBuild: true` silently shipped an app whose\n    // server actions and POST route handlers all returned 403.\n    if (props.nextjsType === NextjsType.GLOBAL_FUNCTIONS) {\n      this.patchFetchInClientJs();\n    }\n\n    this.buildId = deploymentBuildId(manifest);\n    this.publicDirEntries = this.getLocalPublicDirEntries();\n    // Next.js's resolved config, the same one it writes into\n    // `required-server-files.json`.\n    this.nextConfigBasePath = normalizeBasePath(manifest.config.basePath);\n    this.nextConfigAssetPrefix = relativeAssetPrefix(\n      manifest.config.assetPrefix,\n    );\n    this.nextConfigAssetPrefixPath = assetPrefixPath(\n      manifest.config.assetPrefix,\n    );\n\n    const isFunctions =\n      props.nextjsType === NextjsType.GLOBAL_FUNCTIONS ||\n      props.nextjsType === NextjsType.REGIONAL_FUNCTIONS;\n\n    this.relativeProjectDir = manifest.relativeProjectDir;\n    this.relativePathToEntrypoint = joinPosix(RUNTIME_DIR_NAME, \"server.mjs\");\n    this.architecture = deploymentArchitecture(props);\n    this.deploymentRoots = this.resolveDeploymentRoots(manifest);\n    this.functionGroupBehaviors = manifest.behaviors ?? [];\n\n    // Only the RegionalContainers image carries `public/`: nothing is in front\n    // of it to answer those paths from S3. Every other type lists it here and\n    // reads a file the edge didn't route to S3 (a rewrite onto it) from there.\n    const publicOnDisk = props.nextjsType === NextjsType.REGIONAL_CONTAINERS;\n    if (publicOnDisk) {\n      // Its generated Dockerfile `COPY`s `public`, which fails the image build\n      // when the app has none. An empty directory is what `next start` sees\n      // for an app without one anyway, and git doesn't track it.\n      mkdirSync(join(props.buildDirectory, \"public\"), { recursive: true });\n    }\n\n    for (const root of this.deploymentRoots) {\n      this.stageRuntime(root.path, isFunctions, publicOnDisk);\n      // Functions run on the Lambda managed runtime (Amazon Linux 2023, glibc),\n      // for the architecture their Lambda deploys, whatever this machine is;\n      // Containers run on node:24-alpine (musl).\n      this.stageSharpForTarget(\n        root,\n        join(root.path, this.relativeProjectDir),\n        `${isFunctions ? \"linux\" : \"linuxmusl\"}-${toNodeArchitecture(this.architecture)}`,\n      );\n\n      if (isFunctions) {\n        this.assertUnderLambdaLimit(root);\n      }\n    }\n  }\n\n  /**\n   * Line up the groups the props asked for with the roots the build actually\n   * staged, and fail loudly when they disagree.\n   *\n   * They can disagree in both directions, and both mean the same thing — the\n   * `.next` on disk came from a build that did not see this `functionGroups` —\n   * but the causes differ: `skipBuild: true` with a build run by hand, or a\n   * stale `.next` from before the prop changed. Either way every later symptom\n   * (a Lambda missing an entrypoint, a CloudFront behavior pointing at a\n   * function that cannot serve it) is this, several steps downstream.\n   */\n  private resolveDeploymentRoots(\n    manifest: AdapterManifest,\n  ): NextjsDeploymentRoot[] {\n    const staged = manifest.groups;\n\n    // Names *and* routes: moving `/reports/**` into an existing group keeps the\n    // names and still leaves that group's zip without the reports entrypoints.\n    // Order is not: assignment and CloudFront behaviors both go most specific\n    // first, and no two distinct patterns tie on a URL (`function-groups.ts`),\n    // so reordering groups or routes is the same split.\n    // Already validated in the constructor, so this is absent or non-empty.\n    const wanted = this.props.functionGroups?.length\n      ? toFunctionGroupSpecs(this.props.functionGroups)\n      : undefined;\n    const got = manifest.functionGroups;\n\n    if (\n      JSON.stringify(sortedGroupSpecs(wanted)) !==\n      JSON.stringify(sortedGroupSpecs(got))\n    ) {\n      throw new Error(\n        `${LOG_PREFIX} \\`functionGroups\\` asks for ` +\n          `${wanted ? JSON.stringify(wanted) : \"no splitting\"} but the build ` +\n          `in ${this.dotNextPath} was split into ` +\n          `${got ? JSON.stringify(got) : \"a single deployment root\"}. ` +\n          `Groups are resolved during \\`next build\\` (cdk-nextjs passes them in ` +\n          `via ${FUNCTION_GROUPS_ENV_VAR}), so this means the build output is ` +\n          `stale, or \\`skipBuild: true\\` and the build was run without that ` +\n          `variable set.`,\n      );\n    }\n\n    const names = staged ? Object.keys(staged) : [DEFAULT_FUNCTION_GROUP];\n    const roots = names.map((name) => ({\n      name,\n      path: join(\n        this.dotNextPath,\n        ADAPTER_DIR_NAME,\n        ...groupStagingDirName(staged ? name : undefined).split(\"/\"),\n      ),\n      routes: staged?.[name] ?? [],\n    }));\n\n    // `default` first, so any \"the root\" caller gets the group that owns\n    // everything unassigned.\n    roots.sort((a, b) =>\n      a.name === DEFAULT_FUNCTION_GROUP\n        ? -1\n        : b.name === DEFAULT_FUNCTION_GROUP\n          ? 1\n          : a.name.localeCompare(b.name),\n    );\n\n    for (const root of roots) {\n      if (!existsSync(root.path)) {\n        throw new Error(\n          `${LOG_PREFIX} The deployment root for function group ` +\n            `\"${root.name}\" is missing from ${root.path}, though the adapter ` +\n            `manifest lists it. The \\`.next\\` directory has been modified since ` +\n            `\\`next build\\` ran.`,\n        );\n      }\n    }\n    return roots;\n  }\n\n  /**\n   * Lambda enforces 250 MB unzipped at CloudFormation time, which is minutes\n   * into a deploy and reports only a size. Splitting exists to stay under that\n   * cap, so the error that tells you to split further has to name the group, its\n   * size, and what to do — and arrive at synth.\n   */\n  private assertUnderLambdaLimit(root: NextjsDeploymentRoot): void {\n    const bytes = storedSize(root.path);\n    debug(\n      `${LOG_PREFIX} Deployment root \"${root.name}\" is ${(bytes / 1e6).toFixed(1)} MB unzipped`,\n    );\n    if (bytes <= LAMBDA_UNZIPPED_LIMIT_BYTES) {\n      return;\n    }\n    const mb = (value: number) => `${(value / 1024 / 1024).toFixed(0)} MB`;\n    const isSplit = this.deploymentRoots.length > 1;\n    throw new Error(\n      `${LOG_PREFIX} Function group \"${root.name}\" is ${mb(bytes)} unzipped, ` +\n        `over Lambda's ${mb(LAMBDA_UNZIPPED_LIMIT_BYTES)} limit. ` +\n        (isSplit\n          ? `Split its routes further, or move some of them into another group: ` +\n            `the cap is per function, so the shared \\`next\\` closure every group ` +\n            `duplicates costs nothing against any single budget.`\n          : `Use the \\`functionGroups\\` prop to package routes into separate ` +\n            `functions. Note that splitting only removes route-local code — ` +\n            `anything reachable from a shared layout or the \\`next\\` runtime is ` +\n            `in every group.`),\n    );\n  }\n\n  /**\n   * Read the manifest the adapter's `onBuildComplete` wrote.\n   *\n   * Its absence means `next build` ran without cdk-nextjs's adapter registered\n   * (or with a stale `next.config`), which is worth saying plainly here: every\n   * later failure — a Lambda that cannot find `manifest.json`, an empty asset —\n   * is the same cause several steps downstream.\n   */\n  private readAdapterManifest(): AdapterManifest {\n    const manifestPath = join(\n      this.dotNextPath,\n      ADAPTER_DIR_NAME,\n      MANIFEST_FILE_NAME,\n    );\n    if (!existsSync(manifestPath)) {\n      throw new Error(\n        `cdk-nextjs adapter manifest not found at ${manifestPath}. ` +\n          `\"${this.buildCommand}\" must run a Next.js build with cdk-nextjs's ` +\n          `adapter registered. cdk-nextjs sets \\`NEXT_ADAPTER_PATH\\` on the ` +\n          `build it runs itself, so this usually means either the build command ` +\n          `does not reach \\`next build\\` (a wrapper that drops the environment, ` +\n          `or a cached build that did not re-run), or \\`skipBuild: true\\` and ` +\n          `the build happened outside CDK. For the latter, set ` +\n          `\\`adapterPath: require.resolve(\"cdk-nextjs/adapter\")\\` in ` +\n          `next.config. A custom \\`distDir\\` is not supported either: ` +\n          `cdk-nextjs reads the build from \\`.next\\`.`,\n      );\n    }\n    const manifest: AdapterManifest = JSON.parse(\n      readFileSync(manifestPath, \"utf-8\"),\n    );\n    if (manifest.version !== ADAPTER_MANIFEST_VERSION) {\n      throw new Error(\n        `The cdk-nextjs adapter manifest at ${manifestPath} is version ` +\n          `${manifest.version}, but this version of cdk-nextjs reads version ` +\n          `${ADAPTER_MANIFEST_VERSION}. The adapter that wrote it and the ` +\n          `constructs reading it come from the same package, so this means two ` +\n          `cdk-nextjs versions are installed, or the build output is stale.`,\n      );\n    }\n    return manifest;\n  }\n\n  /**\n   * Copy cdk-nextjs's own bundled request-handling shell and the manifest into\n   * `<deploymentRoot>/cdk-nextjs-runtime/`, which is where\n   * `deploymentRootOf`/`deployedManifestPath` expect to find them.\n   *\n   * Only the shell the deployment type actually runs is copied — the Lambda\n   * handler for Functions, the `node:http` server for Containers — so nothing\n   * ships ~1.5 MB of dead code and the tree says which type produced it. Both\n   * are copied from this package's `lib/`, next to the compiled construct.\n   *\n   * Every group gets the same shell *and the same manifest*: a function only\n   * knows which routes it owns so it can say so when misrouted, and that comes\n   * from {@link FUNCTION_GROUP_ENV_VAR}, not from a per-group manifest.\n   */\n  private stageRuntime(\n    deploymentRoot: string,\n    isFunctions: boolean,\n    publicOnDisk: boolean,\n  ): void {\n    const shell = isFunctions ? \"lambda.mjs\" : \"server.mjs\";\n    const source = join(__dirname, \"..\", \"runtime\", shell);\n\n    const runtimeDir = join(deploymentRoot, RUNTIME_DIR_NAME);\n    // Removed rather than merged: a stale shell from the other deployment type\n    // would otherwise sit in the asset and change its hash for no reason.\n    rmSync(runtimeDir, { recursive: true, force: true });\n    mkdirSync(runtimeDir, { recursive: true });\n    cpSync(source, join(runtimeDir, shell));\n    cpSync(\n      join(this.dotNextPath, ADAPTER_DIR_NAME, MANIFEST_FILE_NAME),\n      join(runtimeDir, MANIFEST_FILE_NAME),\n    );\n    if (!publicOnDisk) {\n      // The Lambda zips and the GlobalContainers image don't carry `public/`\n      // (its bytes are in S3), so the runtime can't list it at start the way\n      // the RegionalContainers image does.\n      // Listed here, after the build command, so `postbuild` output is in it:\n      // a rewrite onto a listed file is then served from S3 rather than 404ing.\n      writePublicFileList(\n        runtimeDir,\n        join(this.props.buildDirectory, \"public\"),\n      );\n    }\n    debug(\n      `${LOG_PREFIX} Staged ${shell} and ${MANIFEST_FILE_NAME} in ${runtimeDir}`,\n    );\n  }\n\n  /**\n   * `NEXT_ADAPTER_PATH` for the build, so `adapterPath` in `next.config` is\n   * optional.\n   *\n   * Next.js reads the variable as the *default* value of `adapterPath`\n   * (`next/dist/server/config-shared.js`, `defaultConfig`), so an app that does\n   * set `adapterPath` still wins and nothing existing changes.\n   *\n   * Resolved from the Next.js app, not from cdk-nextjs's own `__dirname` and not\n   * left as a bare specifier. Both alternatives were tried and both are wrong:\n   *\n   * - cdk-nextjs's own location loses because the adapter resolves its sibling\n   *   cache handler relative to wherever *it* was loaded from. An adapter loaded\n   *   from outside the app's tree hands Next.js a `cacheHandler` outside\n   *   `turbopack.root`, which Turbopack rejects outright (\"leaves the filesystem\n   *   root\").\n   * - A bare specifier loses because Next.js resolves `adapterPath` from inside\n   *   its own config loader, i.e. from `next`'s realpath. Under pnpm that is the\n   *   virtual store (`node_modules/.pnpm/next@…/node_modules/next/`), and the\n   *   walk up from there never reaches the app's own `node_modules`.\n   *\n   * Unset when `cdk-nextjs` is not resolvable from the app, which is legitimate:\n   * the Next.js app and the CDK app can be separate packages, and only the CDK one\n   * necessarily depends on cdk-nextjs. {@link readAdapterManifest} reports the\n   * resulting failure and names this case.\n   *\n   * One setup this cannot serve, and the reason this repo's own examples still set\n   * `adapterPath`: a `link:`/`file:` dependency on a cdk-nextjs checkout *outside*\n   * the app's project root. The symlink resolves out of the project, so the\n   * `cacheHandler` escape above applies. Set `adapterPath` in `next.config` there\n   * — it is resolved by the build, after whatever put the adapter in place.\n   */\n  private adapterPathEnv(): Record<string, string> {\n    try {\n      return {\n        NEXT_ADAPTER_PATH: require.resolve(\"cdk-nextjs/adapter\", {\n          paths: [this.props.buildDirectory],\n        }),\n      };\n    } catch {\n      debug(\n        `${LOG_PREFIX} Could not resolve \"cdk-nextjs/adapter\" from ` +\n          `${this.props.buildDirectory}; leaving NEXT_ADAPTER_PATH unset, so ` +\n          `next.config must set \\`adapterPath\\`.`,\n      );\n      return {};\n    }\n  }\n\n  /**\n   * Execute local build command in the specified directory\n   */\n  private runNextBuild() {\n    console.log(\n      `${LOG_PREFIX} Running: \"${this.buildCommand}\" in directory: ${this.props.buildDirectory}`,\n    );\n\n    // Clean existing cache directory to avoid stale data from previous builds\n    if (existsSync(this.initCacheDir)) {\n      rmSync(this.initCacheDir, { recursive: true, force: true });\n      debug(`Cleaned existing cache directory: ${this.initCacheDir}`);\n    }\n\n    try {\n      execSync(this.buildCommand, {\n        stdio: \"inherit\",\n        cwd: this.props.buildDirectory,\n        env: {\n          ...process.env,\n          CDK_NEXTJS_INIT_CACHE_DIR: this.initCacheDir,\n          ...this.adapterPathEnv(),\n          // `onBuildComplete` runs inside this process and cannot read CDK\n          // props, so the resolved groups travel as JSON. Absent when not\n          // splitting, which the adapter reads as \"one deployment root\".\n          ...(this.props.functionGroups?.length\n            ? {\n                [FUNCTION_GROUPS_ENV_VAR]: JSON.stringify(\n                  toFunctionGroupSpecs(this.props.functionGroups),\n                ),\n              }\n            : {}),\n        },\n      });\n    } catch (error) {\n      throw new Error(`Local build failed: ${error}`);\n    }\n  }\n\n  /**\n   * Prepend `patch-fetch.js` to the client entrypoint chunks, for\n   * `NextjsGlobalFunctions` only.\n   *\n   * This is what makes POST work at all on that type. CloudFront reaches the\n   * server through a Lambda Function URL with `AuthType: AWS_IAM`, signed by an\n   * origin access control, and AWS documents the consequence: \"If you use PUT or\n   * POST methods with your Lambda function URL, your users must compute the\n   * SHA256 of the body and include the payload hash value of the request body in\n   * the `x-amz-content-sha256` header when sending the request to CloudFront.\n   * Lambda doesn't support unsigned payloads.\"\n   *\n   * CloudFront signs GETs itself (empty-body hash) but will not hash a body, and\n   * a browser has no way to add that header on its own, so an unpatched app\n   * answers every server action, form submission and POST route handler with\n   * `403 InvalidSignatureException` before the request reaches Next.js. The\n   * patch installs `fetch`/`XMLHttpRequest` wrappers that compute the hash.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-lambda.html\n   */\n  private patchFetchInClientJs() {\n    const staticChunksPath = join(this.dotNextPath, \"static\", \"chunks\");\n    const chunkFiles = readdirSync(staticChunksPath).filter(\n      (file: string) =>\n        // main-app- for webpack, turbopack- for turbo\n        file.startsWith(\"main-app-\") ||\n        (file.startsWith(\"turbopack-\") && file.endsWith(\".js\")),\n    );\n\n    if (chunkFiles.length === 0) {\n      throw new Error(\"No client side js entrypoint files found\");\n    }\n\n    // Read the patch-fetch.js content\n    const patchFetchPath = join(__dirname, \"patch-fetch.js\");\n    const patchFetchContent = readFileSync(patchFetchPath, \"utf-8\");\n\n    // Prepend patch-fetch logic to each entrypoint, once. Now that this runs\n    // outside `runNextBuild`, the same `.next` can be synthesized more than\n    // once (`skipBuild: true`, `cdk synth` then `cdk deploy`, a retried\n    // deploy), and prepending twice would re-wrap the wrappers.\n    for (const chunkFile of chunkFiles) {\n      const chunkFilePath = join(staticChunksPath, chunkFile);\n      const patchedContent = patchClientChunk(\n        readFileSync(chunkFilePath, \"utf-8\"),\n        patchFetchContent,\n        chunkFilePath,\n      );\n      if (patchedContent === undefined) {\n        debug(`${LOG_PREFIX} Already patched, skipping: ${chunkFilePath}`);\n        continue;\n      }\n      writeFileSync(chunkFilePath, patchedContent);\n    }\n  }\n\n  /**\n   * Get public directory entries from local filesystem\n   */\n  private getLocalPublicDirEntries(): PublicDirEntry[] {\n    const publicDirPath = join(this.props.buildDirectory, \"public\");\n    if (!existsSync(publicDirPath)) {\n      return [];\n    }\n\n    return readdirSync(publicDirPath, { withFileTypes: true }).map((entry) => ({\n      name: entry.name,\n      isDirectory: entry.isDirectory(),\n    }));\n  }\n\n  /**\n   * Strip whatever platform-specific Sharp binaries `next build`'s output file\n   * tracing staged, since they're the host's (e.g. macOS/glibc) rather than the\n   * deployment target's, then install the target's. Skipping this is silent:\n   * `imageOptimizer` catches the load failure internally and returns the\n   * unoptimized original with an HTTP 200.\n   *\n   * Only a root with `sharp` staged gets the binaries: the image optimizer\n   * brings it into `default`, which serves every `/_next/image`, and another\n   * group has it only if its own routes use it. So only `default` warns when\n   * it's missing.\n   */\n  private stageSharpForTarget(\n    root: NextjsDeploymentRoot,\n    projectDir: string,\n    platform: string,\n  ) {\n    const sharpSource = this.removeExistingSharpBinaries(root.path, projectDir);\n    if (!sharpSource) {\n      if (root.name === DEFAULT_FUNCTION_GROUP) {\n        console.warn(\n          `${LOG_PREFIX} \"sharp\" not found in the staged build output. Add \"sharp\" as a dependency of your Next.js app to enable image optimization.`,\n        );\n      }\n      return;\n    }\n    this.installSharpPackages(\n      sharpBinaryDir(root.path),\n      this.getSharpBinaryPackages(sharpSource, platform),\n    );\n  }\n\n  /**\n   * Recursively find and remove existing Sharp platform binaries.\n   *\n   * `root` is walked whole rather than just its `node_modules`: the staged tree\n   * is keyed by repo-root-relative path, so in a monorepo the `node_modules`\n   * holding `sharp` is several directories down. {@link isSharpBinaryPackage} is\n   * what keeps that from reaching the app's own output — the staged root holds\n   * the compiled `.next` as well as the dependencies.\n   *\n   * @param projectDir the app's directory inside `root`, which `next` is\n   * resolved from.\n   * @returns the staged `sharp` JS wrapper to install next to, found in the same\n   * walk: a root can be hundreds of megabytes, and each group has one.\n   */\n  private removeExistingSharpBinaries(\n    root: string,\n    projectDir: string,\n  ): string | undefined {\n    const sharpCandidates: string[] = [];\n\n    // Links are listed, not followed: every link in a staged root points\n    // inside it (`stageFiles` copies the ones that don't), so its target is\n    // walked at its own path anyway, and following them is what let a\n    // workspace cycle hang the synth.\n    const allEntries = listTree(root);\n\n    // Symlinks are unlinked, not `rmSync`ed, and they go first. pnpm points\n    // several links at one store directory, and `rmSync(…, { recursive: true,\n    // force: true })` *silently no-ops* on a symlink whose target is already\n    // gone — `force` swallows the ENOENT its `rmdir` gets. Removing a store\n    // directory before its links therefore left dangling\n    // `@img/sharp-darwin-arm64` entries in the asset, which is a latent ENOENT\n    // in whatever next follows them (`sharp` does, when it looks for binaries).\n    const symlinks: string[] = [];\n    const directories: string[] = [];\n\n    for (const entry of allEntries) {\n      if (entry.isDirectory() && entry.name === \"sharp\") {\n        const path = join(entry.parentPath, entry.name);\n        if (existsSync(join(path, \"package.json\"))) {\n          sharpCandidates.push(path);\n        }\n        continue;\n      }\n      if (!isSharpBinaryPackage(entry.parentPath, entry.name)) continue;\n      const fullPath = join(entry.parentPath, entry.name);\n      if (entry.isSymbolicLink()) {\n        symlinks.push(fullPath);\n      } else if (entry.isDirectory()) {\n        directories.push(fullPath);\n      }\n    }\n\n    debug(\n      `${LOG_PREFIX} Removing ${symlinks.length} Sharp binary symlinks and ${directories.length} directories`,\n    );\n\n    for (const path of symlinks) {\n      unlinkSync(path);\n      debug(`${LOG_PREFIX} Unlinked: ${path}`);\n    }\n    for (const path of directories) {\n      rmSync(path, { recursive: true, force: true });\n      debug(`${LOG_PREFIX} Removed: ${path}`);\n    }\n    return pickStagedSharpPackage(\n      sharpCandidates,\n      resolveNextSharp(projectDir),\n    );\n  }\n\n  /**\n   * Resolve the `@img/sharp-<platform>` and `@img/sharp-libvips-<platform>`\n   * versions to install for a given platform.\n   *\n   * These must match the `sharp` JS wrapper that output file tracing staged:\n   * `sharp`'s `lib/libvips.js` compares the binary's\n   * reported libvips version against its own `minimumLibvipsVersion` and\n   * throws at load when they disagree. `sharp` pins both in its\n   * `optionalDependencies`, so that manifest is the authoritative source.\n   */\n  private getSharpBinaryPackages(\n    sharpSource: string,\n    platform: string,\n  ): { name: string; version: string }[] {\n    // Only for a binary the staged `sharp` does not pin.\n    const fallback = [\n      { name: `sharp-libvips-${platform}`, version: \"1.2.4\" },\n      { name: `sharp-${platform}`, version: \"0.34.5\" },\n    ];\n\n    const manifest = JSON.parse(\n      readFileSync(join(sharpSource, \"package.json\"), \"utf-8\"),\n    );\n    const optionalDependencies: Record<string, string> =\n      manifest.optionalDependencies ?? {};\n\n    return fallback.map((pkg) => {\n      const version = optionalDependencies[`@img/${pkg.name}`];\n      if (!version) {\n        console.warn(\n          `${LOG_PREFIX} sharp@${manifest.version} does not pin \"@img/${pkg.name}\"; falling back to ${pkg.version}.`,\n        );\n        return pkg;\n      }\n      return { name: pkg.name, version };\n    });\n  }\n\n  /**\n   * Download (with caching) and extract Sharp's platform-specific binary\n   * packages into `imgPath`.\n   */\n  private installSharpPackages(\n    imgPath: string,\n    packages: { name: string; version: string }[],\n  ): void {\n    const cacheDir = join(tmpdir(), \"cdk-nextjs-sharp-cache\");\n    mkdirSync(cacheDir, { recursive: true });\n\n    for (const pkg of packages) {\n      const targetDir = join(imgPath, pkg.name);\n      const url = `https://registry.npmjs.org/@img/${pkg.name}/-/${pkg.name}-${pkg.version}.tgz`;\n\n      // Create a consistent filename based on package name and version\n      const cacheFileName = `${pkg.name}-${pkg.version}.tgz`;\n      const cachedFile = join(cacheDir, cacheFileName);\n\n      // Check if we already have a valid package cached; re-download if\n      // a previous run left behind a truncated/corrupt download\n      if (existsSync(cachedFile) && this.isCachedFileValid(cachedFile)) {\n        debug(\n          `${LOG_PREFIX} Using cached ${pkg.name}@${pkg.version} from ${cachedFile}`,\n        );\n      } else {\n        debug(`${LOG_PREFIX} Downloading ${pkg.name}@${pkg.version}...`);\n\n        // Download to a process-unique temp file in the same directory,\n        // then atomically rename it onto the shared cache path. Concurrent\n        // synth processes (e.g. Turborepo running multiple `cdk` commands)\n        // share this cache dir, so writing directly to `cachedFile` risks\n        // another process extracting a half-written file. Renaming within\n        // the same filesystem is atomic, so readers only ever see a\n        // complete file, whichever process wins the race.\n        const tempFile = join(\n          cacheDir,\n          `${cacheFileName}.${process.pid}-${randomBytes(6).toString(\"hex\")}.tmp`,\n        );\n        try {\n          // --fail makes curl exit non-zero on HTTP errors and --retry\n          // handles transient connection drops so a partial transfer\n          // isn't cached as valid.\n          execFileSync(\n            \"curl\",\n            [\n              \"-L\",\n              \"--fail\",\n              \"--retry\",\n              \"3\",\n              \"--retry-delay\",\n              \"1\",\n              \"-o\",\n              tempFile,\n              url,\n            ],\n            { stdio: \"pipe\" },\n          );\n\n          if (!this.isCachedFileValid(tempFile)) {\n            throw new Error(\n              `Downloaded file for ${pkg.name}@${pkg.version} is empty or missing: ${tempFile}`,\n            );\n          }\n\n          renameSync(tempFile, cachedFile);\n        } finally {\n          rmSync(tempFile, { force: true });\n        }\n\n        debug(\n          `${LOG_PREFIX} Cached ${pkg.name}@${pkg.version} to ${cachedFile}`,\n        );\n      }\n\n      mkdirSync(targetDir, { recursive: true });\n      execFileSync(\n        \"tar\",\n        [\"-xzf\", cachedFile, \"-C\", targetDir, \"--strip-components=1\"],\n        { stdio: \"pipe\" },\n      );\n\n      debug(`${LOG_PREFIX} Installed ${pkg.name}@${pkg.version}`);\n    }\n  }\n\n  /**\n   * Checks that a cached Sharp binary archive is non-empty. Guards against\n   * a truncated/corrupt download (e.g. from a dropped connection) being\n   * reused across synth operations.\n   */\n  private isCachedFileValid(filePath: string): boolean {\n    try {\n      return statSync(filePath).size > 0;\n    } catch {\n      return false;\n    }\n  }\n}\n\n/**\n * What travels to the adapter in {@link FUNCTION_GROUPS_ENV_VAR}, and what it\n * records back as `AdapterManifest.functionGroups`.\n */\nfunction toFunctionGroupSpecs(\n  groups: NextjsFunctionGroupRoutes[],\n): FunctionGroupSpec[] {\n  return groups.map(({ name, routes }) => ({ name, routes }));\n}\n\n/** `groups` in a canonical order, for comparing two of them. */\nfunction sortedGroupSpecs(\n  groups: readonly FunctionGroupSpec[] | undefined,\n): FunctionGroupSpec[] | undefined {\n  return groups\n    ?.map(({ name, routes }) => ({ name, routes: [...routes].sort() }))\n    .sort((a, b) => (a.name < b.name ? -1 : 1));\n}\n\n/**\n * Pick the staged `sharp` JS wrapper out of every copy found in the tree.\n *\n * Unlike a standalone build there is no single `node_modules` to look in: the\n * tree mirrors repo-root-relative paths, so the search is by directory name.\n *\n * An app can have two `sharp` copies at different versions (its own, hoisted,\n * and next's, nested under `next/node_modules`), and every binary goes into the\n * one root `@img`, so the copy pinning them has to be the one `next`'s image\n * optimizer loads: `nextSharp`, when {@link resolveNextSharp} found it. Otherwise\n * shortest path wins as the closest to a hoisted install, sorted for\n * determinism.\n */\nexport function pickStagedSharpPackage(\n  candidates: string[],\n  nextSharp?: string,\n): string | undefined {\n  const used =\n    nextSharp &&\n    candidates.find((candidate) =>\n      nextSharp.startsWith(realpathSync(candidate) + sep),\n    );\n  if (used) {\n    return used;\n  }\n  candidates.sort((a, b) => a.length - b.length || a.localeCompare(b));\n  if (candidates.length > 1) {\n    debug(\n      `${LOG_PREFIX} Multiple staged \"sharp\" copies; using ${candidates[0]}`,\n    );\n  }\n  return candidates[0];\n}\n\n/**\n * The real path of the `sharp` entry point the staged `next` resolves from\n * `projectDir`, `undefined` when either does not resolve.\n */\nexport function resolveNextSharp(projectDir: string): string | undefined {\n  try {\n    // The anchor file needn't exist; `createRequire` only reads its directory.\n    const nextPackage = createRequire(\n      join(projectDir, \"cdk-nextjs-next-resolver.cjs\"),\n    ).resolve(\"next/package.json\");\n    return createRequire(nextPackage).resolve(\"sharp\");\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Whether the entry `name` in `parentPath` is an `@img/sharp-*` platform binary\n * package, or pnpm's store entry for one.\n *\n * The name alone is not enough to delete a directory by. A route segment called\n * `sharp-edges` stages `.next/server/app/sharp-edges/`, and removing it left the\n * manifest listing an entrypoint that is no longer on disk — every request to\n * that route 500ing with \"Could not load the entrypoint\". Nor is \"a `sharp-`\n * package\": `sharp-ico` and `sharp-phash` are unrelated dependencies, and\n * removing them failed the app at runtime with MODULE_NOT_FOUND. So both the\n * scope and the place have to match:\n *\n * - `node_modules/@img/sharp-…`, where every platform binary actually lives\n * - `node_modules/.pnpm/@img+sharp-…@0.35.4`, pnpm's store, whose entries are\n *   also what the `@img` links point at (`sharp-libvips-…` matches the same way)\n *\n * The `node_modules` segment is required as well, so an app directory that\n * happens to be called `@img` or `.pnpm` is still left alone.\n */\nexport function isSharpBinaryPackage(\n  parentPath: string,\n  name: string,\n): boolean {\n  const segments = parentPath.split(sep);\n  const parent = segments[segments.length - 1];\n  const scoped =\n    (parent === \"@img\" && name.startsWith(\"sharp-\")) ||\n    (parent === \".pnpm\" && name.startsWith(\"@img+sharp-\"));\n  return scoped && segments.includes(\"node_modules\");\n}\n\n/**\n * Where the target's `@img/sharp-*` binaries go: `<root>/node_modules/@img`.\n *\n * Not next to the staged `sharp` package. Under pnpm that is\n * `node_modules/.pnpm/sharp@x/node_modules/@img`, which only the store copy of\n * `sharp` resolves from: a dereferenced link to `sharp` (a copy at\n * `app/node_modules/sharp`, say) looks for `@img` from its own path and walks\n * up, never into the store. Both the Functions zip (`zipDirectory`) and the\n * Containers `COPY` keep the links, so it is the store copy that loads, and its\n * walk up reaches the root `node_modules` too, so it serves either layout. It\n * is also where main installed them.\n */\nexport function sharpBinaryDir(root: string): string {\n  return join(root, \"node_modules\", \"@img\");\n}\n\n/**\n * Every entry under `root`, links listed but not followed.\n *\n * An explicit walk rather than `readdirSync({ recursive: true })`, which on\n * Node 24 descends into symlinked directories itself and so never returns on a\n * cycle — two workspace packages that link each other, which is how pnpm wires a\n * monorepo.\n */\nexport function listTree(root: string): Dirent[] {\n  const entries: Dirent[] = [];\n  const pending = [root];\n  for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {\n    for (const entry of readdirSync(dir, { withFileTypes: true })) {\n      entries.push(entry);\n      if (entry.isDirectory()) {\n        pending.push(join(dir, entry.name));\n      }\n    }\n  }\n  return entries;\n}\n\n/**\n * Write {@link PUBLIC_FILES_FILE_NAME} into a deployment root's runtime\n * directory: every file under `publicDir`, listed the way the runtime would\n * list it off disk (`readPublicFiles`: symlinks followed, `/`-separated,\n * sorted). An app without `public/` gets `[]`.\n */\nexport function writePublicFileList(runtimeDir: string, publicDir: string) {\n  writeFileSync(\n    join(runtimeDir, PUBLIC_FILES_FILE_NAME),\n    JSON.stringify(readPublicFiles(publicDir)),\n  );\n}\n\n/**\n * Total bytes of a tree as its deployment zip stores it. `zipDirectory` keeps\n * links as links, so each counts as its target path, not as the target, which\n * is walked at its own path anyway (every link in a staged root points inside\n * it).\n */\nexport function storedSize(root: string): number {\n  let bytes = 0;\n  for (const entry of listTree(root)) {\n    if (!entry.isDirectory()) {\n      bytes += lstatSync(join(entry.parentPath, entry.name)).size;\n    }\n  }\n  return bytes;\n}\n\n/**\n * `chunk` with `patch` prepended between `PATCH_FETCH_MARKER` and\n * `PATCH_FETCH_END_MARKER`, or `undefined` when it already carries this exact\n * patch.\n *\n * The opening marker carries a hash of the patch, so a chunk patched by a\n * cdk-nextjs whose `patch-fetch.js` differs (an upgrade, over a `.next` reused\n * with `skipBuild: true`) is not mistaken for current: the old patch is cut off\n * at its end marker and this one put in its place, rather than the old one\n * shipping or both stacking up.\n */\nexport function patchClientChunk(\n  chunk: string,\n  patch: string,\n  chunkPath: string,\n): string | undefined {\n  const hash = createHash(\"sha256\").update(patch).digest(\"hex\").slice(0, 16);\n  const open = `${PATCH_FETCH_MARKER} ${hash} */`;\n  if (chunk.startsWith(`${open}\\n`)) {\n    return undefined;\n  }\n  let original = chunk;\n  if (chunk.startsWith(PATCH_FETCH_MARKER)) {\n    const end = chunk.indexOf(`\\n${PATCH_FETCH_END_MARKER}\\n`);\n    if (end === -1) {\n      // Only a pre-release cdk-nextjs wrote the marker without an end, and\n      // where its patch stops cannot be told from the chunk's own code.\n      throw new Error(\n        `${LOG_PREFIX} ${chunkPath} carries a cdk-nextjs fetch patch this ` +\n          `version cannot replace. Re-run \\`next build\\` to regenerate it.`,\n      );\n    }\n    original = chunk.slice(end + PATCH_FETCH_END_MARKER.length + 2);\n  }\n  return `${open}\\n${patch}\\n${PATCH_FETCH_END_MARKER}\\n${original}`;\n}\n"]}