@vercel/container 10.0.0 → 10.1.0

package/dist/index.js

@@ -62,8 +62,8 @@ async function generateProjectManifest({
 var diagnostics = (0, import_build_utils.createDiagnostics)("container");
 
 // src/index.ts
-var import_node_fs14 = require("fs");
-var import_node_path14 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path15 = __toESM(require("path"));
 
 // src/util.ts
 var import_build_utils2 = require("@vercel/build-utils");
@@ -106,7 +106,7 @@ function shortDigest(digest) {
   return digest.startsWith("sha256:") ? `${digest.slice(0, 19)}\u2026` : digest;
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function withSpan(parent, name, attrs, fn) {
   if (!parent) {
@@ -136,7 +136,7 @@ function devImageTag(serviceName) {
   return `vercel-dev/${safe || "service"}:dev`;
 }
 function run(cmd, args, opts = {}) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = (0, import_node_child_process.spawn)(cmd, args, {
       cwd: opts.cwd,
       env: opts.env,
@@ -171,7 +171,7 @@ function run(cmd, args, opts = {}) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve2({ stdout, stderr });
+        resolve4({ stdout, stderr });
       } else {
         const detail = stderr.trim().split("\n").slice(-5).join("\n");
         const error = new Error(
@@ -746,7 +746,7 @@ var buildahEngine = {
       });
       const imageCount = stdout2.trim() ? stdout2.trim().split("\n").length : 0;
       info(
-        imageCount > 0 ? `layer store: warm (${imageCount} image(s) present before build)` : "layer store: cold (no cached images; first build or cache miss)"
+        imageCount > 0 ? `layer store: warm (${imageCount} image(s) present before build)` : "layer store: cold (no images present before build)"
       );
     } catch (err) {
       debug(`could not read store warmth: ${err.message}`);
@@ -990,7 +990,7 @@ async function startDockerDaemon(span) {
         ].join("\n")
       );
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 500));
+    await new Promise((resolve4) => setTimeout(resolve4, 500));
   }
 }
 async function stopDockerDaemon(daemon, span) {
@@ -1000,12 +1000,12 @@ async function stopDockerDaemon(daemon, span) {
   }
   step("Stopping Docker daemon");
   const stopTimeoutMs = Number(process.env.VERCEL_VCR_DOCKERD_STOP_TIMEOUT_MS) || 1e4;
-  await new Promise((resolve2) => {
+  await new Promise((resolve4) => {
     let settled = false;
     const finish = () => {
       if (!settled) {
         settled = true;
-        resolve2();
+        resolve4();
       }
     };
     child.once("exit", finish);
@@ -1206,16 +1206,155 @@ function selectContainerEngine() {
 }
 
 // src/buildpacks/build.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_os7 = require("os");
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 
-// src/buildpacks/lifecycle/lifecycle.ts
-var import_build_utils3 = require("@vercel/build-utils");
+// src/buildpacks/cache.ts
 var import_node_crypto2 = require("crypto");
 var import_node_fs4 = require("fs");
-var import_node_os4 = require("os");
 var import_node_path4 = require("path");
+var BUILDPACK_CACHE_DIR = ".vercel/cache/buildpacks";
+var CNB_COMMITTED_DIR = "committed";
+var CNB_CACHE_METADATA_FILE = "io.buildpacks.lifecycle.cache.metadata";
+var IMAGE_ID_FILE = "image-id";
+function buildpackCacheEnabled() {
+  return readString(process.env.VERCEL_ENABLE_BUILDPACK_CACHE) === "1";
+}
+function buildpackCacheDir(options) {
+  const root = (0, import_node_path4.resolve)(options.repoRootPath || options.workPath);
+  const app = (0, import_node_path4.relative)(root, (0, import_node_path4.resolve)(options.workPath)).split(import_node_path4.sep).join("/") || ".";
+  const key = (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify([app, options.service?.name ?? null])).digest("hex").slice(0, 32);
+  return (0, import_node_path4.join)(root, BUILDPACK_CACHE_DIR, key);
+}
+function restoreBuildpackCache(dir, imageId, cacheDir) {
+  try {
+    if (readRegularFile((0, import_node_path4.join)(dir, IMAGE_ID_FILE)) !== imageId) {
+      return { status: "miss", reason: "base_image_changed" };
+    }
+    copyCommitted(dir, cacheDir);
+    return { status: "hit", bytes: sizeOf((0, import_node_path4.join)(cacheDir, CNB_COMMITTED_DIR)) };
+  } catch (error) {
+    (0, import_node_fs4.rmSync)((0, import_node_path4.join)(cacheDir, CNB_COMMITTED_DIR), { recursive: true, force: true });
+    const cold = error.code === "ENOENT";
+    return { status: "miss", reason: cold ? "no_cache" : firstLine(error) };
+  }
+}
+function saveBuildpackCache(dir, imageId, cacheDir) {
+  const committed = (0, import_node_path4.join)(cacheDir, CNB_COMMITTED_DIR);
+  let metadata;
+  try {
+    assertDirectory(committed);
+    metadata = readRegularFile((0, import_node_path4.join)(committed, CNB_CACHE_METADATA_FILE));
+  } catch (error) {
+    const missing = error.code === "ENOENT";
+    return {
+      status: "skipped",
+      reason: missing ? "no_cache_written" : firstLine(error)
+    };
+  }
+  try {
+    if (isSaved(dir, imageId, metadata))
+      return { status: "unchanged" };
+    const bytes = sizeOf(committed);
+    (0, import_node_fs4.rmSync)(dir, { recursive: true, force: true });
+    copyCommitted(cacheDir, dir);
+    (0, import_node_fs4.writeFileSync)((0, import_node_path4.join)(dir, IMAGE_ID_FILE), imageId);
+    return { status: "saved", bytes };
+  } catch (error) {
+    (0, import_node_fs4.rmSync)(dir, { recursive: true, force: true });
+    return { status: "skipped", reason: firstLine(error) };
+  }
+}
+function isSaved(dir, imageId, metadata) {
+  try {
+    const committed = (0, import_node_path4.join)(dir, CNB_COMMITTED_DIR);
+    assertDirectory(committed);
+    return readRegularFile((0, import_node_path4.join)(dir, IMAGE_ID_FILE)) === imageId && readRegularFile((0, import_node_path4.join)(committed, CNB_CACHE_METADATA_FILE)) === metadata;
+  } catch {
+    return false;
+  }
+}
+function copyCommitted(from, to) {
+  const source = (0, import_node_path4.join)(from, CNB_COMMITTED_DIR);
+  const target = (0, import_node_path4.join)(to, CNB_COMMITTED_DIR);
+  assertDirectory(source);
+  (0, import_node_fs4.mkdirSync)(target, { recursive: true });
+  for (const entry of (0, import_node_fs4.readdirSync)(source, { withFileTypes: true })) {
+    if (!entry.isFile())
+      throw notRegularFile(entry.name);
+    (0, import_node_fs4.copyFileSync)((0, import_node_path4.join)(source, entry.name), (0, import_node_path4.join)(target, entry.name));
+  }
+}
+function assertDirectory(path4) {
+  if (!(0, import_node_fs4.lstatSync)(path4).isDirectory()) {
+    throw new Error(`${(0, import_node_path4.basename)(path4)} is not a directory`);
+  }
+}
+function readRegularFile(path4) {
+  if (!(0, import_node_fs4.lstatSync)(path4).isFile())
+    throw notRegularFile((0, import_node_path4.basename)(path4));
+  return (0, import_node_fs4.readFileSync)(path4, "utf8");
+}
+function notRegularFile(name) {
+  return new Error(`${JSON.stringify(name)} is not a regular file`);
+}
+function sizeOf(dir) {
+  return (0, import_node_fs4.readdirSync)(dir).reduce(
+    (bytes, name) => bytes + (0, import_node_fs4.lstatSync)((0, import_node_path4.join)(dir, name)).size,
+    0
+  );
+}
+function firstLine(error) {
+  return error.message.split("\n")[0];
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  const units = ["KiB", "MiB", "GiB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unit]}`;
+}
+function describeRestore(outcome) {
+  return outcome.status === "hit" ? `restored buildpack cache (${formatBytes(outcome.bytes)})` : `no buildpack cache to restore (${outcome.reason})`;
+}
+function describeSave(outcome) {
+  switch (outcome.status) {
+    case "saved":
+      return `saved buildpack cache (${formatBytes(outcome.bytes)})`;
+    case "unchanged":
+      return "buildpack cache unchanged";
+    default:
+      return `buildpack cache not saved (${outcome.reason})`;
+  }
+}
+function recordRestore(span, outcome, durationMs) {
+  span?.setAttributes({
+    "buildpack.cache.restore": outcome.status,
+    "buildpack.cache.restore_ms": String(durationMs),
+    ...outcome.status === "hit" ? { "buildpack.cache.restore_bytes": String(outcome.bytes) } : { "buildpack.cache.miss_reason": outcome.reason }
+  });
+}
+function recordSave(span, outcome, durationMs) {
+  span?.setAttributes({
+    "buildpack.cache.save": outcome.status,
+    "buildpack.cache.save_ms": String(durationMs),
+    ...outcome.status === "saved" ? { "buildpack.cache.save_bytes": String(outcome.bytes) } : {},
+    ...outcome.status === "skipped" ? { "buildpack.cache.skip_reason": outcome.reason } : {}
+  });
+}
+
+// src/buildpacks/lifecycle/lifecycle.ts
+var import_build_utils3 = require("@vercel/build-utils");
+var import_node_crypto3 = require("crypto");
+var import_node_fs5 = require("fs");
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
 var import_smol_toml = require("smol-toml");
 var import_tar = require("tar");
 
@@ -1230,8 +1369,8 @@ var distribution_default = {
   buildpacks: {
     ruby: {
       id: "vercel/ruby",
-      version: "0.2.0",
-      sha256: "d46d7d825b8e57636957125859c2637545892dc0f3cf93117b16c748bb4f35c5"
+      version: "0.3.0",
+      sha256: "7ee871c18ac1616658793d3d25639d7a1f65ade618f84c6596ef9e3f515b7202"
     }
   }
 };
@@ -1314,7 +1453,7 @@ async function withPrereleaseBuildpack(buildpack, archiveUrl) {
   );
   if (!entry) {
     throw new Error(
-      `Pre-release archive ${archive.url} does not match a buildpack in the ${buildpack.runtime} runtime.`
+      `Pre-release archive ${archive.fileName} does not match a buildpack in the ${buildpack.runtime} runtime.`
     );
   }
   const checksumUrlObj = new URL(archive.url);
@@ -1323,17 +1462,17 @@ async function withPrereleaseBuildpack(buildpack, archiveUrl) {
   const response = await fetch(checksumUrl);
   if (!response.ok) {
     throw new Error(
-      `Failed to fetch pre-release checksum ${checksumUrl}: HTTP ${response.status} ${response.statusText}`
+      `Failed to fetch pre-release checksum for ${archive.fileName}: HTTP ${response.status} ${response.statusText}`
     );
   }
   const fields = (await response.text()).trim().split(/\s+/);
   const [sha256, fileName] = fields;
   if (fields.length !== 2 || !SHA256_RE.test(sha256) || fileName !== archive.fileName) {
     throw new Error(
-      `Invalid pre-release checksum ${checksumUrl}: expected a SHA-256 checksum for ${archive.fileName}.`
+      `Invalid pre-release checksum: expected a SHA-256 checksum for ${archive.fileName}.`
     );
   }
-  info(`Using pre-release ${entry.id}@${archive.version}: ${archive.url}`);
+  info(`Using pre-release ${entry.id}@${archive.version}`);
   return {
     ...buildpack,
     buildpacks: buildpack.buildpacks.map(
@@ -1346,17 +1485,18 @@ async function withPrereleaseBuildpack(buildpack, archiveUrl) {
 var BUILD_USER_ID = 1001;
 var BUILD_GROUP_ID = 1001;
 var BUILD_USER = `${BUILD_USER_ID}:${BUILD_GROUP_ID}`;
-var CNB_PLATFORM_API = "0.13";
+var CNB_PLATFORM_API = "0.15";
 var ORDER_MOUNT_DIR = "/platform/order";
 var ORDER_FILE = `${ORDER_MOUNT_DIR}/order.toml`;
+var CACHE_MOUNT_DIR = "/cache";
 var ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 async function stageWorkspace({ files, workPath }, destinationDir) {
   const staged = /* @__PURE__ */ Object.create(null);
   const symlinks = /* @__PURE__ */ new Set();
   for (const [name, file] of Object.entries(files)) {
     const portable = name.replace(/\\/g, "/");
-    const normalized = import_node_path4.posix.normalize(portable).replace(/\/$/, "");
-    if (!normalized || normalized === "." || import_node_path4.win32.isAbsolute(name) || import_node_path4.posix.isAbsolute(portable) || portable.split("/").includes("..") || normalized in staged) {
+    const normalized = import_node_path5.posix.normalize(portable).replace(/\/$/, "");
+    if (!normalized || normalized === "." || import_node_path5.win32.isAbsolute(name) || import_node_path5.posix.isAbsolute(portable) || portable.split("/").includes("..") || normalized in staged) {
       throw new Error(`Invalid buildpack source path ${JSON.stringify(name)}.`);
     }
     staged[normalized] = file;
@@ -1369,15 +1509,15 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
     if (!target) {
       throw new Error(`Cannot read buildpack source symlink ${name}.`);
     }
-    if ((0, import_node_path4.isAbsolute)(target)) {
-      target = (0, import_node_path4.relative)((0, import_node_path4.resolve)(workPath, import_node_path4.posix.dirname(normalized)), target) || ".";
-    } else if (import_node_path4.win32.isAbsolute(target)) {
+    if ((0, import_node_path5.isAbsolute)(target)) {
+      target = (0, import_node_path5.relative)((0, import_node_path5.resolve)(workPath, import_node_path5.posix.dirname(normalized)), target) || ".";
+    } else if (import_node_path5.win32.isAbsolute(target)) {
       throw new Error(
         `Buildpack source symlink ${name} has an absolute target.`
       );
     }
     target = target.replace(/\\/g, "/");
-    const resolved = import_node_path4.posix.join(import_node_path4.posix.dirname(normalized), target);
+    const resolved = import_node_path5.posix.join(import_node_path5.posix.dirname(normalized), target);
     if (resolved === ".." || resolved.startsWith("../")) {
       throw new Error(
         `Buildpack source symlink ${name} escapes the service root. Ruby buildpack services must be self-contained.`
@@ -1387,7 +1527,7 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
     symlinks.add(normalized);
   }
   for (const name of Object.keys(staged)) {
-    for (let parent = import_node_path4.posix.dirname(name); parent !== "."; parent = import_node_path4.posix.dirname(parent)) {
+    for (let parent = import_node_path5.posix.dirname(name); parent !== "."; parent = import_node_path5.posix.dirname(parent)) {
       if (symlinks.has(parent)) {
         throw new Error(
           `Buildpack source ${name} is inside symlink ${parent}.`
@@ -1396,16 +1536,16 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
     }
     const file = staged[name];
     if (file.type === "FileFsRef" && !(0, import_build_utils3.isSymbolicLink)(file.mode)) {
-      const sourcePath = (0, import_node_path4.resolve)(file.fsPath);
-      const sourceRelative = (0, import_node_path4.relative)((0, import_node_path4.resolve)(workPath), sourcePath);
-      if (sourceRelative.startsWith(`..${import_node_path4.sep}`) || sourceRelative === ".." || (0, import_node_path4.isAbsolute)(sourceRelative)) {
+      const sourcePath = (0, import_node_path5.resolve)(file.fsPath);
+      const sourceRelative = (0, import_node_path5.relative)((0, import_node_path5.resolve)(workPath), sourcePath);
+      if (sourceRelative.startsWith(`..${import_node_path5.sep}`) || sourceRelative === ".." || (0, import_node_path5.isAbsolute)(sourceRelative)) {
         continue;
       }
-      const sourceRoot = import_node_fs4.realpathSync.native(workPath);
-      const sourceTarget = import_node_fs4.realpathSync.native(sourcePath);
-      if (sourceTarget !== (0, import_node_path4.resolve)(sourceRoot, sourceRelative)) {
-        const target = (0, import_node_path4.relative)(sourceRoot, sourceTarget).split(import_node_path4.sep).join("/");
-        if (target === ".." || target.startsWith("../") || (0, import_node_path4.isAbsolute)(target) || !(target in staged)) {
+      const sourceRoot = import_node_fs5.realpathSync.native(workPath);
+      const sourceTarget = import_node_fs5.realpathSync.native(sourcePath);
+      if (sourceTarget !== (0, import_node_path5.resolve)(sourceRoot, sourceRelative)) {
+        const target = (0, import_node_path5.relative)(sourceRoot, sourceTarget).split(import_node_path5.sep).join("/");
+        if (target === ".." || target.startsWith("../") || (0, import_node_path5.isAbsolute)(target) || !(target in staged)) {
           throw new Error(
             `Buildpack source ${name} follows a symlink to an excluded or outside-root file. Ruby buildpack services must be self-contained.`
           );
@@ -1414,17 +1554,17 @@ async function stageWorkspace({ files, workPath }, destinationDir) {
     }
   }
   await (0, import_build_utils3.download)(staged, destinationDir);
-  const root = import_node_fs4.realpathSync.native(destinationDir);
+  const root = import_node_fs5.realpathSync.native(destinationDir);
   for (const name of symlinks) {
     let target;
     try {
-      target = (0, import_node_path4.relative)(root, import_node_fs4.realpathSync.native((0, import_node_path4.join)(destinationDir, name)));
+      target = (0, import_node_path5.relative)(root, import_node_fs5.realpathSync.native((0, import_node_path5.join)(destinationDir, name)));
     } catch {
       throw new Error(
         `Buildpack source symlink ${name} has no target in the staged service.`
       );
     }
-    if (target === ".." || target.startsWith(`..${import_node_path4.sep}`) || (0, import_node_path4.isAbsolute)(target)) {
+    if (target === ".." || target.startsWith(`..${import_node_path5.sep}`) || (0, import_node_path5.isAbsolute)(target)) {
       throw new Error(
         `Buildpack source symlink ${name} escapes the staged service.`
       );
@@ -1438,16 +1578,16 @@ function writePlatformEnvDir(buildEnv, config, parentDir = (0, import_node_os4.t
   if (config.nodeHome) {
     environment.VERCEL_NODE_HOME = config.nodeHome;
   }
-  const dir = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)(parentDir, "vercel-cnb-env-"));
-  (0, import_node_fs4.chmodSync)(dir, 493);
+  const dir = (0, import_node_fs5.mkdtempSync)((0, import_node_path5.join)(parentDir, "vercel-cnb-env-"));
+  (0, import_node_fs5.chmodSync)(dir, 493);
   for (const [key, value] of Object.entries(environment)) {
     if (!ENV_NAME_RE.test(key)) {
       debug(`skipping build env var with an unsupported name: ${key}`);
       continue;
     }
-    const file = (0, import_node_path4.join)(dir, key);
-    (0, import_node_fs4.writeFileSync)(file, value);
-    (0, import_node_fs4.chmodSync)(file, 420);
+    const file = (0, import_node_path5.join)(dir, key);
+    (0, import_node_fs5.writeFileSync)(file, value);
+    (0, import_node_fs5.chmodSync)(file, 420);
   }
   return dir;
 }
@@ -1499,11 +1639,11 @@ function writeOrderDir(buildpack, parentDir = (0, import_node_os4.tmpdir)()) {
       }
     ]
   };
-  const dir = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)(parentDir, "vercel-cnb-order-"));
-  (0, import_node_fs4.chmodSync)(dir, 493);
-  const file = (0, import_node_path4.join)(dir, "order.toml");
-  (0, import_node_fs4.writeFileSync)(file, (0, import_smol_toml.stringify)(order));
-  (0, import_node_fs4.chmodSync)(file, 420);
+  const dir = (0, import_node_fs5.mkdtempSync)((0, import_node_path5.join)(parentDir, "vercel-cnb-order-"));
+  (0, import_node_fs5.chmodSync)(dir, 493);
+  const file = (0, import_node_path5.join)(dir, "order.toml");
+  (0, import_node_fs5.writeFileSync)(file, (0, import_smol_toml.stringify)(order));
+  (0, import_node_fs5.chmodSync)(file, 420);
   return dir;
 }
 function cnbRegistryAuth(credentials) {
@@ -1519,74 +1659,78 @@ function distributionUrls(buildpack) {
     )
   };
 }
+function archiveName(archive) {
+  return new URL(archive.url).pathname.split("/").at(-1) || "archive";
+}
 async function downloadPinnedArchive(archive, destinationPath) {
   const response = await fetch(archive.url);
   if (!response.ok) {
     throw new Error(
-      `Failed to fetch ${archive.url}: HTTP ${response.status} ${response.statusText}`
+      `Failed to fetch ${archiveName(archive)}: HTTP ${response.status} ${response.statusText}`
     );
   }
   const contents = new Uint8Array(await response.arrayBuffer());
-  const checksum = (0, import_node_crypto2.createHash)("sha256").update(contents).digest("hex");
+  const checksum = (0, import_node_crypto3.createHash)("sha256").update(contents).digest("hex");
   if (checksum !== archive.sha256) {
     throw new Error(
-      `Checksum mismatch for ${archive.url}: expected ${archive.sha256}, received ${checksum}.`
+      `Checksum mismatch for ${archiveName(archive)}: expected ${archive.sha256}, received ${checksum}.`
     );
   }
-  (0, import_node_fs4.writeFileSync)(destinationPath, contents);
+  (0, import_node_fs5.writeFileSync)(destinationPath, contents);
 }
 async function fetchPinnedArchive(archive, destinationDir) {
-  const archivePath = (0, import_node_path4.join)(destinationDir, `${archive.sha256}.tgz`);
+  const archivePath = (0, import_node_path5.join)(destinationDir, `${archive.sha256}.tgz`);
   try {
     await downloadPinnedArchive(archive, archivePath);
     (0, import_tar.extract)({ file: archivePath, cwd: destinationDir, sync: true });
   } finally {
-    (0, import_node_fs4.rmSync)(archivePath, { force: true });
+    (0, import_node_fs5.rmSync)(archivePath, { force: true });
   }
 }
 var LAYER_MEDIA_TYPE_RE = /(\.tar\.gzip|\.tar\+gzip|\.tar)$/;
 function readOciJson(path4) {
-  return JSON.parse((0, import_node_fs4.readFileSync)(path4, "utf8"));
+  return JSON.parse((0, import_node_fs5.readFileSync)(path4, "utf8"));
 }
 function blobPath(layoutDir, digest) {
   const match = digest.match(/^sha256:([0-9a-f]{64})$/);
   if (!match) {
     throw new Error(`Unsupported OCI digest ${JSON.stringify(digest)}.`);
   }
-  return (0, import_node_path4.join)(layoutDir, "blobs", "sha256", match[1]);
+  return (0, import_node_path5.join)(layoutDir, "blobs", "sha256", match[1]);
 }
 async function fetchBuildpackage(archive, cnbDir) {
-  const layoutDir = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)((0, import_node_os4.tmpdir)(), "vercel-cnb-buildpackage-"));
-  const archivePath = (0, import_node_path4.join)(layoutDir, "buildpackage.cnb");
+  const layoutDir = (0, import_node_fs5.mkdtempSync)((0, import_node_path5.join)((0, import_node_os4.tmpdir)(), "vercel-cnb-buildpackage-"));
+  const archivePath = (0, import_node_path5.join)(layoutDir, "buildpackage.cnb");
   try {
     await downloadPinnedArchive(archive, archivePath);
     await (0, import_tar.extract)({ file: archivePath, cwd: layoutDir });
     const index = readOciJson(
-      (0, import_node_path4.join)(layoutDir, "index.json")
+      (0, import_node_path5.join)(layoutDir, "index.json")
     );
+    const name = archiveName(archive);
     const manifestDigest = index.manifests?.[0]?.digest;
     if (!manifestDigest) {
-      throw new Error(`${archive.url} has no image manifest in index.json.`);
+      throw new Error(`${name} has no image manifest in index.json.`);
     }
     const manifest = readOciJson(
       blobPath(layoutDir, manifestDigest)
     );
     if (!manifest.layers?.length) {
-      throw new Error(`${archive.url} has an image manifest with no layers.`);
+      throw new Error(`${name} has an image manifest with no layers.`);
     }
     for (const layer of manifest.layers) {
       if (!layer.digest || !LAYER_MEDIA_TYPE_RE.test(layer.mediaType ?? "")) {
         throw new Error(
-          `${archive.url} has an unsupported layer media type ${JSON.stringify(
+          `${name} has an unsupported layer media type ${JSON.stringify(
             layer.mediaType
           )}.`
         );
       }
       const layerPath = blobPath(layoutDir, layer.digest);
-      const actual = (0, import_node_crypto2.createHash)("sha256").update(new Uint8Array((0, import_node_fs4.readFileSync)(layerPath))).digest("hex");
+      const actual = (0, import_node_crypto3.createHash)("sha256").update(new Uint8Array((0, import_node_fs5.readFileSync)(layerPath))).digest("hex");
       if (`sha256:${actual}` !== layer.digest) {
         throw new Error(
-          `${archive.url} layer ${layer.digest} hashes to sha256:${actual}.`
+          `${name} layer ${layer.digest} hashes to sha256:${actual}.`
         );
       }
       await (0, import_tar.extract)({
@@ -1609,7 +1753,7 @@ async function fetchBuildpackage(archive, cnbDir) {
       });
     }
   } finally {
-    (0, import_node_fs4.rmSync)(layoutDir, { recursive: true, force: true });
+    (0, import_node_fs5.rmSync)(layoutDir, { recursive: true, force: true });
   }
 }
 async function fetchDistribution(buildpack, cnbDir) {
@@ -1620,14 +1764,14 @@ async function fetchDistribution(buildpack, cnbDir) {
     )
   ]);
   for (const entry of buildpack.buildpacks) {
-    const directory = (0, import_node_path4.join)(
+    const directory = (0, import_node_path5.join)(
       cnbDir,
       "buildpacks",
       entry.id.replace("/", "_"),
       entry.version
     );
     for (const file of ["buildpack.toml", "bin/detect", "bin/build"]) {
-      if (!(0, import_node_fs4.statSync)((0, import_node_path4.join)(directory, file), { throwIfNoEntry: false })?.isFile()) {
+      if (!(0, import_node_fs5.statSync)((0, import_node_path5.join)(directory, file), { throwIfNoEntry: false })?.isFile()) {
         throw new Error(
           `Buildpack ${entry.id}@${entry.version} is missing ${file}.`
         );
@@ -1635,11 +1779,11 @@ async function fetchDistribution(buildpack, cnbDir) {
     }
   }
 }
-function creatorArgs(image, imageRef) {
+function creatorArgs(image, imageRef, options = {}) {
   return [
     "-app=/workspace",
     `-order=${ORDER_FILE}`,
-    "-skip-restore",
+    ...options.cacheDir ? [`-cache-dir=${options.cacheDir}`] : ["-skip-restore"],
     `-run-image=${image.runImage}`,
     "-report=/platform-output/report.toml",
     imageRef
@@ -1647,13 +1791,13 @@ function creatorArgs(image, imageRef) {
 }
 
 // src/buildpacks/lifecycle/buildah.ts
-var import_node_fs5 = require("fs");
-var import_node_crypto3 = require("crypto");
+var import_node_fs6 = require("fs");
+var import_node_crypto4 = require("crypto");
 var import_node_os5 = require("os");
-var import_node_path5 = require("path");
-async function runBuildah2(args, env) {
+var import_node_path6 = require("path");
+async function runBuildah2(args, env, quiet) {
   const storageArgs = await buildahStorageArgs();
-  return run("buildah", [...storageArgs, ...args], { env });
+  return run("buildah", [...storageArgs, ...args], { env, quiet });
 }
 async function removeContainer(name) {
   try {
@@ -1664,6 +1808,47 @@ async function removeContainer(name) {
     );
   }
 }
+async function inspectBaseImageId(container) {
+  const { stdout } = await runBuildah2(
+    ["inspect", "--type", "container", container],
+    void 0,
+    true
+  );
+  const inspected = JSON.parse(stdout);
+  const id = inspected.FromImageID || inspected.FromImageDigest;
+  if (!id) {
+    throw new Error(
+      `buildah inspect did not report the base image of ${container}.`
+    );
+  }
+  return id;
+}
+function cacheScratchParent() {
+  if (isBuildContainer()) {
+    const dir = "/vercel/.cnb";
+    try {
+      (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+      return dir;
+    } catch (error) {
+      debug(
+        `cannot use ${dir} for the buildpack cache: ${error.message}`
+      );
+    }
+  }
+  return (0, import_node_os5.tmpdir)();
+}
+function chownTree(root, uid, gid) {
+  const stat = (0, import_node_fs6.lstatSync)(root);
+  if (stat.isDirectory()) {
+    (0, import_node_fs6.chmodSync)(root, 493);
+    for (const entry of (0, import_node_fs6.readdirSync)(root)) {
+      chownTree((0, import_node_path6.join)(root, entry), uid, gid);
+    }
+  } else if (stat.isFile()) {
+    (0, import_node_fs6.chmodSync)(root, 420);
+  }
+  (0, import_node_fs6.lchownSync)(root, uid, gid);
+}
 var buildAndPushWithLifecycle = async (buildpack, params, span) => {
   const urls = distributionUrls(buildpack);
   return withSpan(
@@ -1680,19 +1865,20 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
       "image.ref": params.imageRef
     },
     async (lifecycleSpan) => {
-      const suffix = `${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}`;
+      const suffix = `${process.pid}-${(0, import_node_crypto4.randomBytes)(4).toString("hex")}`;
       const buildContainer = `vercel-cnb-${buildpack.runtime}-${suffix}`;
       let cnbDir;
       let reportDir;
       let orderDir;
       let platformEnvDir;
+      let cacheScratch;
       try {
-        reportDir = (0, import_node_fs5.mkdtempSync)((0, import_node_path5.join)((0, import_node_os5.tmpdir)(), "vercel-cnb-report-"));
-        const reportPath = (0, import_node_path5.join)(reportDir, "report.toml");
-        (0, import_node_fs5.chownSync)(reportDir, BUILD_USER_ID, BUILD_GROUP_ID);
-        (0, import_node_fs5.chmodSync)(reportDir, 493);
-        cnbDir = (0, import_node_fs5.mkdtempSync)((0, import_node_path5.join)((0, import_node_os5.tmpdir)(), "vercel-cnb-"));
-        (0, import_node_fs5.chmodSync)(cnbDir, 493);
+        reportDir = (0, import_node_fs6.mkdtempSync)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "vercel-cnb-report-"));
+        const reportPath = (0, import_node_path6.join)(reportDir, "report.toml");
+        (0, import_node_fs6.chownSync)(reportDir, BUILD_USER_ID, BUILD_GROUP_ID);
+        (0, import_node_fs6.chmodSync)(reportDir, 493);
+        cnbDir = (0, import_node_fs6.mkdtempSync)((0, import_node_path6.join)((0, import_node_os5.tmpdir)(), "vercel-cnb-"));
+        (0, import_node_fs6.chmodSync)(cnbDir, 493);
         orderDir = writeOrderDir(buildpack);
         platformEnvDir = writePlatformEnvDir(params.buildEnv, {
           nodeHome: params.nodeToolchain?.home
@@ -1730,6 +1916,36 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
           params.workPath,
           "/workspace"
         ]);
+        let imageId;
+        let cacheDir;
+        if (params.cache) {
+          const restoreStart = Date.now();
+          step("Restoring the buildpack cache");
+          let restored;
+          try {
+            imageId = await inspectBaseImageId(buildContainer);
+            cacheScratch = (0, import_node_fs6.mkdtempSync)(
+              (0, import_node_path6.join)(cacheScratchParent(), "vercel-cnb-cache-")
+            );
+            (0, import_node_fs6.chmodSync)(cacheScratch, 493);
+            cacheDir = (0, import_node_path6.join)(cacheScratch, "cache");
+            (0, import_node_fs6.mkdirSync)(cacheDir, { mode: 493 });
+            restored = restoreBuildpackCache(
+              params.cache.dir,
+              imageId,
+              cacheDir
+            );
+            chownTree(cacheDir, BUILD_USER_ID, BUILD_GROUP_ID);
+          } catch (error) {
+            cacheDir = void 0;
+            restored = {
+              status: "miss",
+              reason: `setup_failed:${error.message.split("\n")[0]}`
+            };
+          }
+          done(describeRestore(restored));
+          recordRestore(lifecycleSpan, restored, Date.now() - restoreStart);
+        }
         const platformEnvMount = [
           "--volume",
           `${platformEnvDir}:/platform/env:ro`
@@ -1738,6 +1954,7 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
           "--volume",
           `${params.nodeToolchain.home}:${params.nodeToolchain.home}:ro`
         ] : [];
+        const cacheMount = cacheDir ? ["--volume", `${cacheDir}:${CACHE_MOUNT_DIR}`] : [];
         const lifecycleEnv = {
           ...process.env,
           CNB_REGISTRY_AUTH: cnbRegistryAuth(params.credentials)
@@ -1770,14 +1987,17 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
             `${orderDir}:${ORDER_MOUNT_DIR}:ro`,
             ...nodeToolchainMount,
             ...platformEnvMount,
+            ...cacheMount,
             buildContainer,
             "--",
             "/cnb/lifecycle/creator",
-            ...creatorArgs(params.image, params.imageRef)
+            ...creatorArgs(params.image, params.imageRef, {
+              cacheDir: cacheDir ? CACHE_MOUNT_DIR : void 0
+            })
           ],
           lifecycleEnv
         );
-        const digest = readReportDigest((0, import_node_fs5.readFileSync)(reportPath, "utf8"));
+        const digest = readReportDigest((0, import_node_fs6.readFileSync)(reportPath, "utf8"));
         if (!digest) {
           throw new Error(
             `${buildpack.runtime} buildpack lifecycle did not report a digest.`
@@ -1785,6 +2005,12 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
         }
         done(`built and published ${params.imageRef}@${digest}`);
         lifecycleSpan?.setAttributes({ "image.digest": digest });
+        if (params.cache && imageId && cacheDir) {
+          const saveStart = Date.now();
+          const save = saveBuildpackCache(params.cache.dir, imageId, cacheDir);
+          done(`${describeSave(save)} in ${elapsed(saveStart)}`);
+          recordSave(lifecycleSpan, save, Date.now() - saveStart);
+        }
         return {
           imageRef: params.imageRef,
           digest,
@@ -1802,8 +2028,6 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
         throw new Error(
           [
             `${buildpack.runtime} buildpack build failed via lifecycle/creator (${params.image.buildImage}).`,
-            `Lifecycle archive: ${urls.lifecycle}`,
-            ...urls.buildpacks.map((url) => `Buildpack archive: ${url}`),
             ...hint ? [`The lifecycle exited with code ${exitCode}: ${hint}.`] : [],
             "",
             `Underlying error: ${error.message}`,
@@ -1813,10 +2037,16 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
         );
       } finally {
         await removeContainer(buildContainer);
-        for (const dir of [cnbDir, reportDir, orderDir, platformEnvDir]) {
+        for (const dir of [
+          cnbDir,
+          reportDir,
+          orderDir,
+          platformEnvDir,
+          cacheScratch
+        ]) {
           if (dir) {
             try {
-              (0, import_node_fs5.rmSync)(dir, { recursive: true, force: true });
+              (0, import_node_fs6.rmSync)(dir, { recursive: true, force: true });
             } catch {
               debug(`Could not remove Buildah build scratch directory ${dir}.`);
             }
@@ -1828,10 +2058,10 @@ var buildAndPushWithLifecycle = async (buildpack, params, span) => {
 };
 
 // src/buildpacks/lifecycle/docker.ts
-var import_node_crypto4 = require("crypto");
-var import_node_fs6 = require("fs");
+var import_node_crypto5 = require("crypto");
+var import_node_fs7 = require("fs");
 var import_node_os6 = require("os");
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 function localBuildImageDockerfile(buildImage, nodeMajor) {
   const lines = [];
   if (nodeMajor !== void 0) {
@@ -1850,7 +2080,7 @@ function localBuildImageDockerfile(buildImage, nodeMajor) {
 `;
 }
 function localBuildImageTag(dockerfile) {
-  const hash = (0, import_node_crypto4.createHash)("sha256").update(dockerfile).digest("hex");
+  const hash = (0, import_node_crypto5.createHash)("sha256").update(dockerfile).digest("hex");
   return `vercel-cnb-build:${hash.slice(0, 16)}`;
 }
 async function runDocker2(args, opts = {}) {
@@ -1876,9 +2106,9 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
       let stageDir;
       const containers = [];
       try {
-        stageDir = (0, import_node_fs6.mkdtempSync)((0, import_node_path6.join)((0, import_node_os6.tmpdir)(), "vercel-cnb-"));
-        const cnbDir = (0, import_node_path6.join)(stageDir, "cnb");
-        (0, import_node_fs6.mkdirSync)(cnbDir, { mode: 493 });
+        stageDir = (0, import_node_fs7.mkdtempSync)((0, import_node_path7.join)((0, import_node_os6.tmpdir)(), "vercel-cnb-"));
+        const cnbDir = (0, import_node_path7.join)(stageDir, "cnb");
+        (0, import_node_fs7.mkdirSync)(cnbDir, { mode: 493 });
         const orderDir = writeOrderDir(buildpack, stageDir);
         const platformEnvDir = writePlatformEnvDir(
           params.buildEnv,
@@ -1893,7 +2123,7 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
           params.nodeToolchain?.major
         );
         const buildImageTag = localBuildImageTag(dockerfile);
-        const buildImageIdPath = (0, import_node_path6.join)(stageDir, "build-image.id");
+        const buildImageIdPath = (0, import_node_path7.join)(stageDir, "build-image.id");
         step(
           `Preparing ${buildpack.runtime} ${params.image.version} build image` + (params.nodeToolchain ? ` with Node.js ${params.nodeToolchain.major}` : "")
         );
@@ -1911,11 +2141,11 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
           ],
           { input: dockerfile }
         );
-        const buildImageId = (0, import_node_fs6.readFileSync)(buildImageIdPath, "utf8").trim();
+        const buildImageId = (0, import_node_fs7.readFileSync)(buildImageIdPath, "utf8").trim();
         if (!/^sha256:[a-f0-9]{64}$/.test(buildImageId)) {
           throw new Error("Docker build did not report a valid image ID.");
         }
-        const containerName = `vercel-cnb-${buildpack.runtime}-${process.pid}-${(0, import_node_crypto4.randomBytes)(8).toString("hex")}`;
+        const containerName = `vercel-cnb-${buildpack.runtime}-${process.pid}-${(0, import_node_crypto5.randomBytes)(8).toString("hex")}`;
         const initContainerName = `${containerName}-init`;
         containers.push(initContainerName);
         await runDocker2([
@@ -1999,13 +2229,13 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
           `Building and publishing ${params.imageRef} via Vercel ${buildpack.runtime} buildpacks`
         );
         await runDocker2(["start", "--attach", containerName]);
-        const reportPath = (0, import_node_path6.join)(stageDir, "report.toml");
+        const reportPath = (0, import_node_path7.join)(stageDir, "report.toml");
         await runDocker2([
           "cp",
           `${containerName}:/platform-output/report.toml`,
           reportPath
         ]);
-        const digest = readReportDigest((0, import_node_fs6.readFileSync)(reportPath, "utf8"));
+        const digest = readReportDigest((0, import_node_fs7.readFileSync)(reportPath, "utf8"));
         if (!digest) {
           throw new Error(
             `${buildpack.runtime} buildpack lifecycle did not report a digest.`
@@ -2049,7 +2279,7 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
         }
         if (stageDir) {
           try {
-            (0, import_node_fs6.rmSync)(stageDir, { recursive: true, force: true });
+            (0, import_node_fs7.rmSync)(stageDir, { recursive: true, force: true });
           } catch {
             debug(
               `Could not remove Docker build scratch directory ${stageDir}.`
@@ -2063,10 +2293,10 @@ var buildAndPushWithLifecycleDocker = async (buildpack, params, span) => {
 
 // src/buildpacks/node-toolchain.ts
 var import_build_utils4 = require("@vercel/build-utils");
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
 async function selectNodeMajor(workPath, config, meta) {
-  if (!(0, import_node_fs7.existsSync)((0, import_node_path7.join)(workPath, "package.json"))) {
+  if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(workPath, "package.json"))) {
     return void 0;
   }
   const version2 = await (0, import_build_utils4.getNodeVersion)(workPath, void 0, config, meta);
@@ -2087,7 +2317,7 @@ async function resolveNodeToolchain(workPath, config, meta) {
     return void 0;
   }
   for (const executable of ["node", "npm"]) {
-    if (!(0, import_node_fs7.existsSync)((0, import_node_path7.join)(toolchain.home, "bin", executable))) {
+    if (!(0, import_node_fs8.existsSync)((0, import_node_path8.join)(toolchain.home, "bin", executable))) {
       throw new Error(
         `The selected Node.js ${toolchain.version} installation is missing ${toolchain.home}/bin/${executable} in the build environment.`
       );
@@ -2100,12 +2330,12 @@ async function resolveLocalNodeToolchain(workPath, config, meta) {
 }
 
 // src/buildpacks/registry.ts
-var import_node_fs9 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
 
 // src/buildpacks/ruby.ts
-var import_node_fs8 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
 var import_smol_toml2 = require("smol-toml");
 var DEFAULT_RUBY_VERSION = "3.4";
 var RUBY_IMAGE_REPOSITORY = "docker.io/library/ruby";
@@ -2130,10 +2360,10 @@ var ruby = {
     return { version: version2, buildImage: image, runImage: image };
   },
   validate({ workPath, buildEnv }) {
-    const gemfile = (0, import_node_path8.join)(workPath, "Gemfile");
-    if (!(0, import_node_fs8.existsSync)(gemfile))
+    const gemfile = (0, import_node_path9.join)(workPath, "Gemfile");
+    if (!(0, import_node_fs9.existsSync)(gemfile))
       return;
-    if (!GEMFILE_RAILS_GEM_RE.test((0, import_node_fs8.readFileSync)(gemfile, "utf8")))
+    if (!GEMFILE_RAILS_GEM_RE.test((0, import_node_fs9.readFileSync)(gemfile, "utf8")))
       return;
     if (buildEnv?.SECRET_KEY_BASE)
       return;
@@ -2147,13 +2377,13 @@ function isValidVersion(version2) {
 }
 function selectRubyVersion(workPath) {
   for (const name of RUBY_VERSION_FILES) {
-    const file = (0, import_node_path8.join)(workPath, name);
-    if ((0, import_node_fs8.existsSync)(file)) {
-      return parseVersionFile(name, (0, import_node_fs8.readFileSync)(file, "utf8"));
+    const file = (0, import_node_path9.join)(workPath, name);
+    if ((0, import_node_fs9.existsSync)(file)) {
+      return parseVersionFile(name, (0, import_node_fs9.readFileSync)(file, "utf8"));
     }
   }
-  const gemfile = (0, import_node_path8.join)(workPath, "Gemfile");
-  return (0, import_node_fs8.existsSync)(gemfile) ? parseGemfileRubyVersion((0, import_node_fs8.readFileSync)(gemfile, "utf8")) : void 0;
+  const gemfile = (0, import_node_path9.join)(workPath, "Gemfile");
+  return (0, import_node_fs9.existsSync)(gemfile) ? parseGemfileRubyVersion((0, import_node_fs9.readFileSync)(gemfile, "utf8")) : void 0;
 }
 function parseVersionFile(name, contents) {
   let version2;
@@ -2198,13 +2428,13 @@ function requestedBuildpack(config) {
 }
 function hasProjectMarkers(buildpack, workPath) {
   return buildpack.projectMarkers.some(
-    (name) => (0, import_node_fs9.existsSync)((0, import_node_path9.join)(workPath, name))
+    (name) => (0, import_node_fs10.existsSync)((0, import_node_path10.join)(workPath, name))
   );
 }
 
 // src/buildpacks/build.ts
 async function buildAndPushBuildpack(params) {
-  const sourceDir = (0, import_node_fs10.mkdtempSync)((0, import_node_path10.join)((0, import_node_os7.tmpdir)(), "vercel-cnb-source-"));
+  const sourceDir = (0, import_node_fs11.mkdtempSync)((0, import_node_path11.join)((0, import_node_os7.tmpdir)(), "vercel-cnb-source-"));
   try {
     step("Staging buildpack source files");
     await stageWorkspace(params, sourceDir);
@@ -2249,6 +2479,12 @@ async function buildAndPushBuildpack(params) {
           "image.ref": target.imageRef,
           "registry.username": target.username
         });
+        const cache = params.cache && engine.name === "buildah" ? { dir: buildpackCacheDir(params) } : void 0;
+        if (cache)
+          debug(`buildpack cache: ${cache.dir}`);
+        buildSpan?.setAttributes({
+          "buildpack.cache.enabled": String(Boolean(cache))
+        });
         return engine.withRuntime(buildSpan, async () => {
           await withSpan(
             buildSpan,
@@ -2298,7 +2534,8 @@ async function buildAndPushBuildpack(params) {
               imageRef: target.imageRef,
               credentials,
               buildEnv: params.buildEnv,
-              nodeToolchain
+              nodeToolchain,
+              cache
             },
             buildSpan
           );
@@ -2314,7 +2551,7 @@ async function buildAndPushBuildpack(params) {
     );
   } finally {
     try {
-      (0, import_node_fs10.rmSync)(sourceDir, { recursive: true, force: true });
+      (0, import_node_fs11.rmSync)(sourceDir, { recursive: true, force: true });
     } catch {
       debug(`Could not remove buildpack source snapshot ${sourceDir}.`);
     }
@@ -2322,8 +2559,8 @@ async function buildAndPushBuildpack(params) {
 }
 
 // src/image-source.ts
-var import_node_fs11 = require("fs");
-var import_node_path11 = __toESM(require("path"));
+var import_node_fs12 = require("fs");
+var import_node_path12 = __toESM(require("path"));
 var DETECT_SENTINEL = "<detect>";
 function resolveImageSource(options, context) {
   const { config, workPath, entrypoint } = options;
@@ -2337,8 +2574,8 @@ function resolveImageSource(options, context) {
   }
   const dockerfileConfigured = entrypointRef && isDockerfileRef(entrypointRef) ? entrypointRef : findDockerfile(workPath);
   const dockerfileRel = dockerfileConfigured ?? "Dockerfile";
-  const dockerfilePath = import_node_path11.default.join(workPath, dockerfileRel);
-  const hasDockerfile = dockerfileConfigured !== void 0 || !buildpack && (0, import_node_fs11.existsSync)(dockerfilePath);
+  const dockerfilePath = import_node_path12.default.join(workPath, dockerfileRel);
+  const hasDockerfile = dockerfileConfigured !== void 0 || !buildpack && (0, import_node_fs12.existsSync)(dockerfilePath);
   if (hasDockerfile) {
     return { kind: "dockerfile", dockerfileRel, dockerfilePath };
   }
@@ -2356,9 +2593,9 @@ function resolveImageSource(options, context) {
 
 // src/dev.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_os8 = require("os");
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var HOST_ONLY_ENV = /* @__PURE__ */ new Set([
   "TMPDIR",
   "TMP",
@@ -2388,8 +2625,8 @@ function isHostOnlyEnvVar(key) {
   return HOST_ONLY_ENV.has(key) || key.startsWith("__") || key.startsWith("XPC_") || key.startsWith("SSH_") || key.startsWith("Apple");
 }
 function writeEnvFile(env) {
-  const dir = (0, import_node_fs12.mkdtempSync)(import_node_path12.default.join((0, import_node_os8.tmpdir)(), "vercel-container-dev-env-"));
-  const file = import_node_path12.default.join(dir, "env");
+  const dir = (0, import_node_fs13.mkdtempSync)(import_node_path13.default.join((0, import_node_os8.tmpdir)(), "vercel-container-dev-env-"));
+  const file = import_node_path13.default.join(dir, "env");
   const lines = [];
   for (const [key, value] of Object.entries(env)) {
     if (value.includes("\n")) {
@@ -2397,7 +2634,7 @@ function writeEnvFile(env) {
     }
     lines.push(`${key}=${value}`);
   }
-  (0, import_node_fs12.writeFileSync)(file, `${lines.join("\n")}
+  (0, import_node_fs13.writeFileSync)(file, `${lines.join("\n")}
 `);
   return file;
 }
@@ -2422,7 +2659,7 @@ function emit(out, line) {
   }
 }
 function runForwarded(cmd, args, out, opts = {}) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const child = (0, import_node_child_process3.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2459,7 +2696,7 @@ function runForwarded(cmd, args, out, opts = {}) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        resolve2({ stdout });
+        resolve4({ stdout });
       } else {
         const detail = stderr.trim().split("\n").slice(-5).join("\n");
         reject(
@@ -2488,14 +2725,14 @@ async function resolveDevImage(options, out, span) {
     );
   }
   const { dockerfilePath } = source;
-  if (!(0, import_node_fs12.existsSync)(dockerfilePath)) {
+  if (!(0, import_node_fs13.existsSync)(dockerfilePath)) {
     throw new Error(
       `Dockerfile not found at "${dockerfilePath}" for container service.`
     );
   }
   const serviceName = options.service?.name ?? "service";
   const tag = devImageTag(serviceName);
-  const contextDir = import_node_path12.default.dirname(dockerfilePath);
+  const contextDir = import_node_path13.default.dirname(dockerfilePath);
   const buildArgFlags2 = [];
   const buildEnv = options.meta?.buildEnv ?? {};
   for (const [key, value] of Object.entries(buildEnv)) {
@@ -2700,7 +2937,7 @@ async function startContainer(options, reuseKey) {
         }
       });
       const cleanupEnvFile = () => {
-        (0, import_node_fs12.rmSync)(import_node_path12.default.dirname(envFilePath), { recursive: true, force: true });
+        (0, import_node_fs13.rmSync)(import_node_path13.default.dirname(envFilePath), { recursive: true, force: true });
       };
       const shutdown = async () => {
         runningContainers.delete(reuseKey);
@@ -2733,7 +2970,7 @@ async function startContainer(options, reuseKey) {
             break;
           } catch (err) {
             lastErr = err;
-            await new Promise((resolve2) => setTimeout(resolve2, 250));
+            await new Promise((resolve4) => setTimeout(resolve4, 250));
           }
         }
         if (hostPort === void 0) {
@@ -2777,29 +3014,24 @@ async function startContainer(options, reuseKey) {
 
 // src/prepare-cache.ts
 var import_build_utils5 = require("@vercel/build-utils");
-var import_node_fs13 = require("fs");
-var import_node_path13 = require("path");
-var CACHE_ROOT = "/vercel";
-var GRAPH_ROOT_REL = import_node_path13.posix.relative(CACHE_ROOT, BUILDAH_GRAPH_ROOT);
-async function prepareCache(_options) {
-  if (process.env.VERCEL_VCR_DISABLE_LAYER_CACHE) {
-    debug("layer cache disabled (VERCEL_VCR_DISABLE_LAYER_CACHE)");
-    return {};
-  }
-  if (!isBuildContainer()) {
-    debug("skipping container layer cache (not in build container)");
-    return {};
-  }
-  if (!(0, import_node_fs13.existsSync)(BUILDAH_GRAPH_ROOT)) {
-    debug(`no buildah store to cache at ${BUILDAH_GRAPH_ROOT}`);
+var import_node_fs14 = require("fs");
+var import_node_path14 = require("path");
+async function prepareCache(options) {
+  const root = (0, import_node_path14.resolve)(options.repoRootPath || options.workPath);
+  if (!buildpackCacheEnabled()) {
+    (0, import_node_fs14.rmSync)((0, import_node_path14.join)(root, BUILDPACK_CACHE_DIR), { recursive: true, force: true });
     return {};
   }
   const start = Date.now();
-  const files = await (0, import_build_utils5.glob)(`${GRAPH_ROOT_REL}/**`, CACHE_ROOT);
+  const files = await (0, import_build_utils5.glob)(`${BUILDPACK_CACHE_DIR}/**`, root);
   const count = Object.keys(files).length;
-  info(
-    `cached container layer store: ${count} files from ${BUILDAH_GRAPH_ROOT} in ${Date.now() - start}ms`
-  );
+  if (count > 0) {
+    info(
+      `cached buildpack layers: ${count} file${count === 1 ? "" : "s"} under ${BUILDPACK_CACHE_DIR} in ${Date.now() - start}ms`
+    );
+  } else {
+    debug("no buildpack cache to persist");
+  }
   return files;
 }
 
@@ -2997,11 +3229,14 @@ async function resolveImageHandler(options, source, span) {
       buildpack,
       files: options.files,
       workPath: options.workPath,
+      repoRootPath: options.repoRootPath,
+      service: options.service,
       repository: repository2,
       tag: tag2,
       config,
       meta,
       buildEnv: buildArgsFromEnv(meta?.buildEnv),
+      cache: buildpackCacheEnabled(),
       parentSpan: span
     });
   }
@@ -3009,22 +3244,22 @@ async function resolveImageHandler(options, source, span) {
   if (meta?.isDev) {
     const serviceName2 = options.service?.name;
     const tag2 = devImageTag(
-      serviceName2 ?? import_node_path14.default.basename(dockerfileRel).split(".")[0]
+      serviceName2 ?? import_node_path15.default.basename(dockerfileRel).split(".")[0]
     );
     span?.setAttributes({ "container.mode": "dev", "image.tag": tag2 });
     return tag2;
   }
-  if (!(0, import_node_fs14.existsSync)(dockerfilePath)) {
+  if (!(0, import_node_fs15.existsSync)(dockerfilePath)) {
     throw new Error(
       `Dockerfile not found at "${dockerfilePath}" for container service.`
     );
   }
   const serviceName = options.service?.name;
   const repository = sanitizeRepository(
-    serviceName ?? import_node_path14.default.basename(dockerfileRel).split(".")[0]
+    serviceName ?? import_node_path15.default.basename(dockerfileRel).split(".")[0]
   );
   const tag = resolveImageTag();
-  const contextDir = import_node_path14.default.dirname(dockerfilePath);
+  const contextDir = import_node_path15.default.dirname(dockerfilePath);
   const buildArgs = buildArgsFromEnv(meta?.buildEnv);
   span?.setAttributes({
     "container.mode": "build_and_push",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/container",
-  "version": "10.0.0",
+  "version": "10.1.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -31,7 +31,7 @@
     "build": "node ../../utils/build-builder.mjs",
     "type-check": "tsc --noEmit",
     "test": "vitest run --config ../../vitest.config.mts",
-    "test-unit": "vitest run --config ../../vitest.config.mts test/unit.test.ts test/diagnostics.test.ts test/workspace.test.ts test/lifecycle-docker.test.ts test/ruby-version.test.ts test/docker-push.test.ts",
+    "test-unit": "vitest run --config ../../vitest.config.mts test/unit.test.ts test/diagnostics.test.ts test/workspace.test.ts test/lifecycle-docker.test.ts test/ruby-version.test.ts test/docker-push.test.ts test/cache.test.ts",
     "test-e2e": "vitest run --config ../../vitest.config.mts test/e2e.test.ts"
   }
 }