vercel 59.1.4 → 59.4.0

package/dist/chunks/{chunk-43DD2KNM.js → chunk-J5Y2QGGU.js}

@@ -5,11 +5,11 @@ const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
-  VERCEL_DIR,
   require_dist as require_dist2,
-  require_dist3,
+  require_dist2 as require_dist3,
+  require_dist4,
   require_lib
-} from "./chunk-VE545BR3.js";
+} from "./chunk-HMJVUXE6.js";
 import {
   output_manager_default,
   require_dist
@@ -7872,7 +7872,7 @@ var require_mime_types = __commonJS({
   "../../node_modules/.pnpm/mime-types@2.1.24/node_modules/mime-types/index.js"(exports) {
     "use strict";
     var db = require_mime_db();
-    var extname2 = __require("path").extname;
+    var extname = __require("path").extname;
     var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
     var TEXT_TYPE_REGEXP = /^text\//i;
     exports.charset = charset;
@@ -7923,11 +7923,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path2) {
-      if (!path2 || typeof path2 !== "string") {
+    function lookup(path) {
+      if (!path || typeof path !== "string") {
         return false;
       }
-      var extension2 = extname2("x." + path2).toLowerCase().substr(1);
+      var extension2 = extname("x." + path).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -7980,13 +7980,13 @@ var require_promisepipe = __commonJS({
       }
       const isReadable = stream.readable || typeof stream._read === "function";
       function on(evt) {
-        function executor(resolve3, reject) {
+        function executor(resolve, reject) {
           const fn = evt === "error" ? (err) => reject(new StreamError(err, stream)) : () => {
             if (isReadable && evt === "finish" && !state.error) {
               return;
             }
             cleanupEventHandlers(stream, fn);
-            resolve3(stream);
+            resolve(stream);
           };
           stream.on(evt, fn);
         }
@@ -8032,6 +8032,77 @@ var require_promisepipe = __commonJS({
   }
 });
 
+// ../../internals/builder-orchestration/dist/merge.js
+var require_merge = __commonJS({
+  "../../internals/builder-orchestration/dist/merge.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var merge_exports = {};
+    __export(merge_exports, {
+      merge: () => merge
+    });
+    module.exports = __toCommonJS(merge_exports);
+    var import_path = __require("path");
+    var import_error_utils = require_dist();
+    var import_fs_extra = require_lib();
+    async function merge(source, destination, ignoreFilter, sourceRoot) {
+      const root = sourceRoot || source;
+      if (ignoreFilter) {
+        const relPath = (0, import_path.relative)(root, source);
+        if (relPath && !ignoreFilter(relPath)) {
+          await (0, import_fs_extra.remove)(source);
+          return;
+        }
+      }
+      const destStat = await (0, import_fs_extra.stat)(destination).catch(
+        (err) => err
+      );
+      if ((0, import_error_utils.isErrnoException)(destStat)) {
+        if (destStat.code === "ENOENT") {
+          await (0, import_fs_extra.move)(source, destination);
+          return;
+        }
+        throw destStat;
+      } else if (destStat.isDirectory()) {
+        const contents = await (0, import_fs_extra.readdir)(
+          source
+        ).catch((err) => err);
+        if ((0, import_error_utils.isErrnoException)(contents)) {
+          if (contents.code !== "ENOTDIR") {
+            throw contents;
+          }
+        } else {
+          await Promise.all(
+            contents.map(
+              (name) => merge((0, import_path.join)(source, name), (0, import_path.join)(destination, name), ignoreFilter, root)
+            )
+          );
+          await (0, import_fs_extra.rmdir)(source);
+          return;
+        }
+      }
+      await (0, import_fs_extra.remove)(destination);
+      await (0, import_fs_extra.move)(source, destination);
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/pend@1.2.0/node_modules/pend/index.js
 var require_pend = __commonJS({
   "../../node_modules/.pnpm/pend@1.2.0/node_modules/pend/index.js"(exports, module) {
@@ -8091,7 +8162,7 @@ var require_pend = __commonJS({
 // ../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/.pnpm/fd-slicer@1.1.0/node_modules/fd-slicer/index.js"(exports) {
-    var fs4 = __require("fs");
+    var fs = __require("fs");
     var util = __require("util");
     var stream = __require("stream");
     var Readable = stream.Readable;
@@ -8116,7 +8187,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs4.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
           cb();
           callback(err, bytesRead, buffer2);
         });
@@ -8125,7 +8196,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
       var self = this;
       self.pend.go(function(cb) {
-        fs4.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        fs.write(self.fd, buffer, offset, length, position, function(err, written, buffer2) {
           cb();
           callback(err, written, buffer2);
         });
@@ -8148,7 +8219,7 @@ var require_fd_slicer = __commonJS({
       if (self.refCount < 0)
         throw new Error("invalid unref");
       if (self.autoClose) {
-        fs4.close(self.fd, onCloseDone);
+        fs.close(self.fd, onCloseDone);
       }
       function onCloseDone(err) {
         if (err) {
@@ -8187,7 +8258,7 @@ var require_fd_slicer = __commonJS({
         if (self.destroyed)
           return cb();
         var buffer = new Buffer(toRead);
-        fs4.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
           if (err) {
             self.destroy(err);
           } else if (bytesRead === 0) {
@@ -8237,7 +8308,7 @@ var require_fd_slicer = __commonJS({
       self.context.pend.go(function(cb) {
         if (self.destroyed)
           return cb();
-        fs4.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
           if (err2) {
             self.destroy();
             cb();
@@ -8666,7 +8737,7 @@ var require_buffer_crc32 = __commonJS({
 // ../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/.pnpm/yauzl@2.10.0/node_modules/yauzl/index.js"(exports) {
-    var fs4 = __require("fs");
+    var fs = __require("fs");
     var zlib = __require("zlib");
     var fd_slicer = require_fd_slicer();
     var crc32 = require_buffer_crc32();
@@ -8684,7 +8755,7 @@ var require_yauzl = __commonJS({
     exports.ZipFile = ZipFile;
     exports.Entry = Entry;
     exports.RandomAccessReader = RandomAccessReader;
-    function open(path2, options, callback) {
+    function open(path, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = null;
@@ -8703,12 +8774,12 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs4.open(path2, "r", function(err, fd) {
+      fs.open(path, "r", function(err, fd) {
         if (err)
           return callback(err);
         fromFd(fd, options, function(err2, zipfile) {
           if (err2)
-            fs4.close(fd, defaultCallback);
+            fs.close(fd, defaultCallback);
           callback(err2, zipfile);
         });
       });
@@ -8732,7 +8803,7 @@ var require_yauzl = __commonJS({
         options.strictFileNames = false;
       if (callback == null)
         callback = defaultCallback;
-      fs4.fstat(fd, function(err, stats) {
+      fs.fstat(fd, function(err, stats) {
         if (err)
           return callback(err);
         var reader = fd_slicer.createFromFd(fd, { autoClose: true });
@@ -9613,27 +9684,27 @@ var require_lib2 = __commonJS({
           return shimmed.call(this, reader, totalSize, options, callback);
         };
       } else {
-        const shimmed = fn(function(path2, unused, options, callback) {
-          return original.call(this, path2, options, callback);
+        const shimmed = fn(function(path, unused, options, callback) {
+          return original.call(this, path, options, callback);
         });
-        yauzl[methodName] = function(path2, options, callback) {
+        yauzl[methodName] = function(path, options, callback) {
           if (typeof options == "function") {
             callback = options;
             options = {};
           } else if (!options) {
             options = {};
           }
-          return shimmed.call(this, path2, null, options, callback);
+          return shimmed.call(this, path, null, options, callback);
         };
       }
       return yauzl[methodName];
     }
     function zipFilePatcher(original, ZipFile) {
-      return function(path2, totalSize, options, callback) {
+      return function(path, totalSize, options, callback) {
         const { lazyEntries } = options, hasLazyEntries = options.hasOwnProperty("lazyEntries");
         if (!lazyEntries)
           options.lazyEntries = true;
-        return original.call(this, path2, totalSize, options, function(err, zipFile) {
+        return original.call(this, path, totalSize, options, function(err, zipFile) {
           if (err)
             return callback(err);
           const zipFileInternal = zipFile;
@@ -9654,8 +9725,8 @@ var require_lib2 = __commonJS({
       };
     }
     function entryPatcher(original, Entry) {
-      return function(path2, totalSize, options, callback) {
-        return original.call(this, path2, totalSize, options, function(err, zipFile) {
+      return function(path, totalSize, options, callback) {
+        return original.call(this, path, totalSize, options, function(err, zipFile) {
           if (err)
             return callback(err);
           zipFile.intercept("entry", function(entry, cb) {
@@ -9706,19 +9777,19 @@ var require_promisify = __commonJS({
     function promisifyMethod(yauzl, Promise2, fnName) {
       const fromBuffer = fnName == "fromBuffer";
       cloner.patch(yauzl, fnName, (original) => {
-        return function(path2, totalSize, options) {
-          return new Promise2((resolve3, reject) => {
+        return function(path, totalSize, options) {
+          return new Promise2((resolve, reject) => {
             options = Object.assign({}, options, { lazyEntries: true, autoClose: false });
-            original(path2, totalSize, options, (err, zipFile) => {
+            original(path, totalSize, options, (err, zipFile) => {
               if (err)
                 return reject(err);
-              opened(zipFile, resolve3, fromBuffer, yauzl);
+              opened(zipFile, resolve, fromBuffer, yauzl);
             });
           });
         };
       });
     }
-    function opened(zipFile, resolve3, fromBuffer, yauzl) {
+    function opened(zipFile, resolve, fromBuffer, yauzl) {
       if (fromBuffer) {
         zipFile.reader.unref = yauzl.RandomAccessReader.prototype.unref;
         zipFile.reader.close = (cb) => cb();
@@ -9729,7 +9800,7 @@ var require_promisify = __commonJS({
       zipFile.intercept("end", emittedEnd);
       zipFile.intercept("close", emittedClose);
       zipFile.intercept("error", emittedError);
-      resolve3(zipFile);
+      resolve(zipFile);
     }
     function emittedError(err) {
       const state = getState(this);
@@ -9748,14 +9819,14 @@ var require_promisify = __commonJS({
     function promisifyClose(ZipFile, Promise2) {
       const close = ZipFile.prototype.close;
       ZipFile.prototype.close = function() {
-        return new Promise2((resolve3, reject) => {
+        return new Promise2((resolve, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           if (!this.isOpen)
-            return resolve3();
+            return resolve();
           if (getState(this))
             return reject(new Error("Previous operation has not completed yet"));
-          setState(this, { action: "close", resolve: resolve3, reject });
+          setState(this, { action: "close", resolve, reject });
           close.call(this);
         });
       };
@@ -9770,14 +9841,14 @@ var require_promisify = __commonJS({
     function promisifyReadEntry(ZipFile, Promise2) {
       const readEntry = ZipFile.prototype.readEntry;
       ZipFile.prototype.readEntry = function() {
-        return new Promise2((resolve3, reject) => {
+        return new Promise2((resolve, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           if (!this.isOpen)
             return reject(new Error("ZipFile is not open"));
           if (getState(this))
             return reject(new Error("Previous operation has not completed yet"));
-          setState(this, { action: "read", resolve: resolve3, reject });
+          setState(this, { action: "read", resolve, reject });
           readEntry.call(this);
         });
       };
@@ -9823,11 +9894,11 @@ var require_promisify = __commonJS({
     function addWalkEntriesMethod(ZipFile, Promise2) {
       ZipFile.prototype.walkEntries = function(callback, numEntries) {
         callback = wrapFunctionToReturnPromise(callback, Promise2);
-        return new Promise2((resolve3, reject) => {
+        return new Promise2((resolve, reject) => {
           walkNextEntry(this, callback, numEntries, 0, (err) => {
             if (err)
               return reject(err);
-            resolve3();
+            resolve();
           });
         });
       };
@@ -9848,13 +9919,13 @@ var require_promisify = __commonJS({
     function promisifyOpenReadStream(ZipFile, Promise2) {
       const openReadStream = ZipFile.prototype.openReadStream;
       ZipFile.prototype.openReadStream = function(entry, options) {
-        return new Promise2((resolve3, reject) => {
+        return new Promise2((resolve, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           openReadStream.call(this, entry, options || {}, (err, stream) => {
             if (err)
               return reject(err);
-            resolve3(stream);
+            resolve(stream);
           });
         });
       };
@@ -9870,7 +9941,7 @@ var require_promisify = __commonJS({
             return result;
           return Promise2.resolve(result);
         } catch (err) {
-          return new Promise2((resolve3, reject) => {
+          return new Promise2((resolve, reject) => {
             reject(err);
           });
         }
@@ -9916,471 +9987,460 @@ var require_lib3 = __commonJS({
   }
 });
 
-// src/util/build/write-build-result.ts
-var import_fs_extra2 = __toESM(require_lib(), 1);
-var import_mime_types = __toESM(require_mime_types(), 1);
-var import_fs_detectors = __toESM(require_dist3(), 1);
-var import_promisepipe2 = __toESM(require_promisepipe(), 1);
-import {
-  basename,
-  dirname,
-  extname,
-  join as join2,
-  relative as relative2,
-  resolve,
-  posix
-} from "path";
-import {
-  FileFsRef,
-  download,
-  downloadFile,
-  getLambdaOptionsFromFunction,
-  normalizePath,
-  isBackendBuilder,
-  isExperimentalBackendsEnabled,
-  isExperimentalService,
-  isExperimentalServiceV2,
-  isSymbolicLink
-} from "@vercel/build-utils";
-
-// src/util/build/merge.ts
-var import_error_utils = __toESM(require_dist(), 1);
-var import_fs_extra = __toESM(require_lib(), 1);
-import { join, relative } from "path";
-async function merge(source, destination, ignoreFilter, sourceRoot) {
-  const root = sourceRoot || source;
-  if (ignoreFilter) {
-    const relPath = relative(root, source);
-    if (relPath && !ignoreFilter(relPath)) {
-      await (0, import_fs_extra.remove)(source);
-      return;
-    }
-  }
-  const destStat = await (0, import_fs_extra.stat)(destination).catch(
-    (err) => err
-  );
-  if ((0, import_error_utils.isErrnoException)(destStat)) {
-    if (destStat.code === "ENOENT") {
-      await (0, import_fs_extra.move)(source, destination);
-      return;
+// ../../internals/builder-orchestration/dist/unzip.js
+var require_unzip = __commonJS({
+  "../../internals/builder-orchestration/dist/unzip.js"(exports, module) {
+    "use strict";
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var unzip_exports = {};
+    __export(unzip_exports, {
+      unzip: () => unzip
+    });
+    module.exports = __toCommonJS(unzip_exports);
+    var import_path = __toESM2(__require("path"));
+    var import_promisepipe = __toESM2(require_promisepipe());
+    var fs = __toESM2(require_lib());
+    var import_build_utils = __require("@vercel/build-utils");
+    var import_yauzl_promise = require_lib3();
+    async function* createZipIterator(zipFile) {
+      let entry;
+      while ((entry = await zipFile.readEntry()) !== null) {
+        yield entry;
+      }
     }
-    throw destStat;
-  } else if (destStat.isDirectory()) {
-    const contents = await (0, import_fs_extra.readdir)(
-      source
-    ).catch((err) => err);
-    if ((0, import_error_utils.isErrnoException)(contents)) {
-      if (contents.code !== "ENOTDIR") {
-        throw contents;
+    async function unzip(buffer, dir) {
+      const zipFile = await (0, import_yauzl_promise.fromBuffer)(buffer);
+      for await (const entry of createZipIterator(zipFile)) {
+        if (entry.fileName.startsWith("__MACOSX/"))
+          continue;
+        try {
+          const destDir = import_path.default.dirname(import_path.default.join(dir, entry.fileName));
+          await fs.mkdirp(destDir);
+          const canonicalDestDir = await fs.realpath(destDir);
+          const relativeDestDir = import_path.default.relative(dir, canonicalDestDir);
+          if (relativeDestDir.split(import_path.default.sep).includes("..")) {
+            throw new Error(
+              `Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`
+            );
+          }
+          await extractEntry(zipFile, entry, dir);
+        } catch (err) {
+          await zipFile.close();
+          throw err;
+        }
       }
-    } else {
-      await Promise.all(
-        contents.map(
-          (name) => merge(join(source, name), join(destination, name), ignoreFilter, root)
-        )
-      );
-      await (0, import_fs_extra.rmdir)(source);
-      return;
     }
-  }
-  await (0, import_fs_extra.remove)(destination);
-  await (0, import_fs_extra.move)(source, destination);
-}
-
-// src/util/build/unzip.ts
-var import_promisepipe = __toESM(require_promisepipe(), 1);
-var fs = __toESM(require_lib(), 1);
-var import_yauzl_promise = __toESM(require_lib3(), 1);
-import path from "path";
-import { streamToBuffer } from "@vercel/build-utils";
-async function* createZipIterator(zipFile) {
-  let entry;
-  while ((entry = await zipFile.readEntry()) !== null) {
-    yield entry;
-  }
-}
-async function unzip(buffer, dir) {
-  const zipFile = await (0, import_yauzl_promise.fromBuffer)(buffer);
-  for await (const entry of createZipIterator(zipFile)) {
-    if (entry.fileName.startsWith("__MACOSX/"))
-      continue;
-    try {
-      const destDir = path.dirname(path.join(dir, entry.fileName));
-      await fs.mkdirp(destDir);
-      const canonicalDestDir = await fs.realpath(destDir);
-      const relativeDestDir = path.relative(dir, canonicalDestDir);
-      if (relativeDestDir.split(path.sep).includes("..")) {
-        throw new Error(
-          `Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`
-        );
+    async function extractEntry(zipFile, entry, dir) {
+      const dest = import_path.default.join(dir, entry.fileName);
+      const mode = entry.externalFileAttributes >> 16 & 65535;
+      const IFMT = 61440;
+      const IFDIR = 16384;
+      const IFLNK = 40960;
+      const symlink = (mode & IFMT) === IFLNK;
+      let isDir = (mode & IFMT) === IFDIR;
+      if (!isDir && entry.fileName.endsWith("/")) {
+        isDir = true;
+      }
+      const madeBy = entry.versionMadeBy >> 8;
+      if (!isDir)
+        isDir = madeBy === 0 && entry.externalFileAttributes === 16;
+      const procMode = getExtractedMode(mode, isDir) & 511;
+      const destDir = isDir ? dest : import_path.default.dirname(dest);
+      const mkdirOptions = { recursive: true };
+      if (isDir) {
+        mkdirOptions.mode = procMode;
+      }
+      await fs.mkdir(destDir, mkdirOptions);
+      if (isDir)
+        return;
+      const readStream = await zipFile.openReadStream(entry);
+      if (symlink) {
+        const link = await (0, import_build_utils.streamToBuffer)(readStream);
+        await fs.symlink(link.toString("utf8"), dest);
+      } else {
+        await (0, import_promisepipe.default)(readStream, fs.createWriteStream(dest, { mode: procMode }));
       }
-      await extractEntry(zipFile, entry, dir);
-    } catch (err) {
-      await zipFile.close();
-      throw err;
     }
-  }
-}
-async function extractEntry(zipFile, entry, dir) {
-  const dest = path.join(dir, entry.fileName);
-  const mode = entry.externalFileAttributes >> 16 & 65535;
-  const IFMT = 61440;
-  const IFDIR = 16384;
-  const IFLNK = 40960;
-  const symlink2 = (mode & IFMT) === IFLNK;
-  let isDir = (mode & IFMT) === IFDIR;
-  if (!isDir && entry.fileName.endsWith("/")) {
-    isDir = true;
-  }
-  const madeBy = entry.versionMadeBy >> 8;
-  if (!isDir)
-    isDir = madeBy === 0 && entry.externalFileAttributes === 16;
-  const procMode = getExtractedMode(mode, isDir) & 511;
-  const destDir = isDir ? dest : path.dirname(dest);
-  const mkdirOptions = { recursive: true };
-  if (isDir) {
-    mkdirOptions.mode = procMode;
-  }
-  await fs.mkdir(destDir, mkdirOptions);
-  if (isDir)
-    return;
-  const readStream = await zipFile.openReadStream(entry);
-  if (symlink2) {
-    const link = await streamToBuffer(readStream);
-    await fs.symlink(link.toString("utf8"), dest);
-  } else {
-    await (0, import_promisepipe.default)(readStream, fs.createWriteStream(dest, { mode: procMode }));
-  }
-}
-function getExtractedMode(entryMode, isDir) {
-  let mode = entryMode;
-  if (mode === 0) {
-    if (isDir) {
-      mode = 493;
-    } else {
-      mode = 420;
+    function getExtractedMode(entryMode, isDir) {
+      let mode = entryMode;
+      if (mode === 0) {
+        if (isDir) {
+          mode = 493;
+        } else {
+          mode = 420;
+        }
+      }
+      return mode;
     }
   }
-  return mode;
-}
+});
 
-// src/util/build/write-build-result.ts
-var import_client = __toESM(require_dist2(), 1);
-var { normalize } = posix;
-var OUTPUT_DIR = join2(VERCEL_DIR, "output");
-var BUILD_OUTPUT_API_ENTRIES = [
-  "config.json",
-  "functions",
-  "routes",
-  "static"
-];
-async function writeBuildResult(args) {
-  const {
-    repoRootPath,
-    outputDir,
-    buildResult,
-    build,
-    builder,
-    builderPkg,
-    vercelConfig,
-    standalone,
-    workPath,
-    service,
-    nestServiceOutput = false,
-    stripServiceRoutePrefix = false
-  } = args;
-  const writeOutputDir = service && nestServiceOutput ? getServiceOutputDir(outputDir, service) : outputDir;
-  let version;
-  let actualResult;
-  if (builder.version === -1) {
-    const vx = buildResult;
-    version = vx.resultVersion;
-    actualResult = vx.result;
-  } else {
-    version = builder.version;
-    actualResult = buildResult;
-  }
-  if (typeof version !== "number" || version === 2) {
-    return writeBuildResultV2({
-      repoRootPath,
-      outputDir: writeOutputDir,
-      buildResult: actualResult,
-      build,
-      vercelConfig,
-      standalone,
-      workPath,
-      service,
-      rootOutputDir: outputDir,
-      stripServiceRoutePrefix
-    });
-  } else if (version === 3) {
-    return writeBuildResultV3({
-      repoRootPath,
-      outputDir: writeOutputDir,
-      buildResult: actualResult,
-      build,
-      vercelConfig,
-      standalone,
-      workPath,
-      service,
-      rootOutputDir: outputDir,
-      stripServiceRoutePrefix
-    });
-  }
-  throw new Error(
-    `Unsupported Builder version \`${version}\` from "${builderPkg.name}"`
-  );
-}
-function isEdgeFunction(v) {
-  return v?.type === "EdgeFunction";
-}
-function isContainerImage(value) {
-  return typeof value === "object" && value !== null && "runtime" in value && value.runtime === "container";
-}
-function isLambda(v) {
-  return v?.type === "Lambda";
-}
-function isPrerender(v) {
-  return v?.type === "Prerender";
-}
-function isFile(v) {
-  const type = v?.type;
-  return type === "FileRef" || type === "FileFsRef" || type === "FileBlob";
-}
-function injectServiceEnvVars(fn, service, stripServiceRoutePrefix = false) {
-  const target = fn.config ?? fn;
-  target.environment ??= {};
-  if (service?.name) {
-    target.environment.VERCEL_SERVICE_NAME = service.name;
-  }
-  if (service?.type) {
-    target.environment.VERCEL_SERVICE_TYPE = service.type;
-  }
-  if (service?.trigger) {
-    target.environment.VERCEL_SERVICE_TRIGGER = service.trigger;
-  }
-  if (service?.routePrefix && service.routePrefix !== "/") {
-    target.environment.VERCEL_SERVICE_ROUTE_PREFIX = service.routePrefix;
-  }
-  if (stripServiceRoutePrefix) {
-    target.environment.VERCEL_SERVICE_ROUTE_PREFIX_STRIP = "1";
-  }
-}
-function stripDuplicateSlashes(path2) {
-  return normalize(path2).replace(/(^\/|\/$)/g, "");
-}
-async function resolveFunctionConfiguration(src, vercelConfig, service) {
-  if (service && isExperimentalServiceV2(service) && service.functions) {
-    let sourceFile = src;
-    const serviceRoot = stripDuplicateSlashes(service.root);
-    if (serviceRoot && serviceRoot !== ".") {
-      const prefix = `${serviceRoot}/`;
-      if (sourceFile.startsWith(prefix)) {
-        sourceFile = sourceFile.slice(prefix.length);
-      }
-    }
-    return getLambdaOptionsFromFunction({
-      sourceFile,
-      config: {
-        ...vercelConfig,
-        functions: service.functions,
-        serviceName: service.name
+// ../../internals/builder-orchestration/dist/write-build-result.js
+var require_write_build_result = __commonJS({
+  "../../internals/builder-orchestration/dist/write-build-result.js"(exports, module) {
+    "use strict";
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
       }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var write_build_result_exports = {};
+    __export(write_build_result_exports, {
+      OUTPUT_DIR: () => OUTPUT_DIR2,
+      createWriteBuildResult: () => createWriteBuildResult2,
+      filesWithoutFsRefs: () => filesWithoutFsRefs2,
+      findDirs: () => findDirs2,
+      isLambda: () => isLambda2,
+      relocateRootBuildOutputToService: () => relocateRootBuildOutputToService2
     });
-  }
-  if (vercelConfig) {
-    return getLambdaOptionsFromFunction({
-      sourceFile: src,
-      config: vercelConfig
-    });
-  }
-  return {};
-}
-function getServiceOutputDir(outputDir, service) {
-  return join2(outputDir, "services", service.name);
-}
-async function writeBuildResultV2(args) {
-  const {
-    repoRootPath,
-    outputDir,
-    buildResult,
-    build,
-    vercelConfig,
-    standalone,
-    workPath,
-    service,
-    rootOutputDir,
-    stripServiceRoutePrefix
-  } = args;
-  if ("buildOutputPath" in buildResult) {
-    await mergeBuilderOutput(outputDir, buildResult, workPath, rootOutputDir);
-    return;
-  }
-  if (!buildResult.output) {
-    const configFile = vercelConfig?.[import_client.fileNameSymbol];
-    const updateMessage = build.use.startsWith("@now/") ? ` Please update from "@now" to "@vercel" in your \`${configFile}\` file.` : "";
-    throw new Error(
-      `The build result from "${build.use}" is missing the "output" property.${updateMessage}`
-    );
-  }
-  const existingFunctions = /* @__PURE__ */ new Map();
-  const overrides = {};
-  const functionConfiguration = build.src ? await resolveFunctionConfiguration(build.src, vercelConfig, service) : {};
-  for (const [path2, output] of Object.entries(buildResult.output)) {
-    const normalizedPath = stripDuplicateSlashes(path2);
-    if (isContainerImage(output)) {
-      injectServiceEnvVars(
-        output,
-        service && isExperimentalService(service) ? service : void 0,
-        stripServiceRoutePrefix
-      );
-      await writeContainerImage(
-        outputDir,
-        output,
-        normalizedPath,
-        functionConfiguration
-      );
-    } else if (isLambda(output)) {
-      injectServiceEnvVars(
-        output,
-        service && isExperimentalService(service) ? service : void 0,
-        stripServiceRoutePrefix
-      );
-      await writeLambda(
+    module.exports = __toCommonJS(write_build_result_exports);
+    var import_fs_extra = __toESM2(require_lib());
+    var import_mime_types = __toESM2(require_mime_types());
+    var import_path = __require("path");
+    var import_build_utils = __require("@vercel/build-utils");
+    var import_promisepipe = __toESM2(require_promisepipe());
+    var import_merge = require_merge();
+    var import_unzip = require_unzip();
+    var import_client = require_dist2();
+    var { normalize } = import_path.posix;
+    var OUTPUT_DIR2 = (0, import_path.join)(".vercel", "output");
+    function createWriteBuildResult2(output) {
+      return {
+        writeBuildResult: (args) => writeBuildResult2(args, output),
+        relocateRootBuildOutputToService: relocateRootBuildOutputToService2,
+        filesWithoutFsRefs: filesWithoutFsRefs2
+      };
+    }
+    var BUILD_OUTPUT_API_ENTRIES = [
+      "config.json",
+      "functions",
+      "routes",
+      "static"
+    ];
+    async function writeBuildResult2(args, outputManager) {
+      const {
         repoRootPath,
         outputDir,
-        output,
-        normalizedPath,
-        void 0,
-        existingFunctions,
-        standalone
-      );
-    } else if (isPrerender(output)) {
-      if (!output.lambda) {
-        throw new Error(
-          `Invalid Prerender with no "lambda" property: ${normalizedPath}`
-        );
+        buildResult,
+        build,
+        builder,
+        builderPkg,
+        vercelConfig,
+        standalone,
+        workPath,
+        service,
+        nestServiceOutput = false,
+        stripServiceRoutePrefix = false
+      } = args;
+      const writeOutputDir = service && nestServiceOutput ? getServiceOutputDir(outputDir, service) : outputDir;
+      let version;
+      let actualResult;
+      if (builder.version === -1) {
+        const vx = buildResult;
+        version = vx.resultVersion;
+        actualResult = vx.result;
+      } else {
+        version = builder.version;
+        actualResult = buildResult;
       }
-      await writeLambda(
-        repoRootPath,
-        outputDir,
-        output.lambda,
-        normalizedPath,
-        void 0,
-        existingFunctions,
-        standalone
+      if (typeof version !== "number" || version === 2) {
+        return writeBuildResultV2({
+          repoRootPath,
+          outputDir: writeOutputDir,
+          buildResult: actualResult,
+          build,
+          vercelConfig,
+          standalone,
+          workPath,
+          service,
+          rootOutputDir: outputDir,
+          stripServiceRoutePrefix,
+          outputManager
+        });
+      } else if (version === 3) {
+        return writeBuildResultV3({
+          repoRootPath,
+          outputDir: writeOutputDir,
+          buildResult: actualResult,
+          build,
+          vercelConfig,
+          standalone,
+          workPath,
+          service,
+          rootOutputDir: outputDir,
+          stripServiceRoutePrefix,
+          outputManager
+        });
+      }
+      throw new Error(
+        `Unsupported Builder version \`${version}\` from "${builderPkg.name}"`
       );
-      let fallback = output.fallback;
-      if (fallback) {
-        const ext = getFileExtension(fallback);
-        const fallbackName = `${normalizedPath}.prerender-fallback${ext}`;
-        const fallbackPath = join2(outputDir, "functions", fallbackName);
-        let usedHardLink = false;
-        if ("fsPath" in fallback) {
-          try {
-            await import_fs_extra2.default.link(fallback.fsPath, fallbackPath);
-            usedHardLink = true;
-          } catch (_) {
+    }
+    function isEdgeFunction(v) {
+      return v?.type === "EdgeFunction";
+    }
+    function isContainerImage(value) {
+      return typeof value === "object" && value !== null && "runtime" in value && value.runtime === "container";
+    }
+    function isLambda2(v) {
+      return v?.type === "Lambda";
+    }
+    function isPrerender(v) {
+      return v?.type === "Prerender";
+    }
+    function isFile(v) {
+      const type = v?.type;
+      return type === "FileRef" || type === "FileFsRef" || type === "FileBlob";
+    }
+    function injectServiceEnvVars(fn, service, stripServiceRoutePrefix = false) {
+      const target = fn.config ?? fn;
+      target.environment ??= {};
+      if (service?.name) {
+        target.environment.VERCEL_SERVICE_NAME = service.name;
+      }
+      if (service?.type) {
+        target.environment.VERCEL_SERVICE_TYPE = service.type;
+      }
+      if (service?.trigger) {
+        target.environment.VERCEL_SERVICE_TRIGGER = service.trigger;
+      }
+      if (service?.routePrefix && service.routePrefix !== "/") {
+        target.environment.VERCEL_SERVICE_ROUTE_PREFIX = service.routePrefix;
+      }
+      if (stripServiceRoutePrefix) {
+        target.environment.VERCEL_SERVICE_ROUTE_PREFIX_STRIP = "1";
+      }
+    }
+    function stripDuplicateSlashes(path) {
+      return normalize(path).replace(/(^\/|\/$)/g, "");
+    }
+    async function resolveFunctionConfiguration(src, vercelConfig, service) {
+      if (service && (0, import_build_utils.isExperimentalServiceV2)(service) && service.functions) {
+        let sourceFile = src;
+        const serviceRoot = stripDuplicateSlashes(service.root);
+        if (serviceRoot && serviceRoot !== ".") {
+          const prefix = `${serviceRoot}/`;
+          if (sourceFile.startsWith(prefix)) {
+            sourceFile = sourceFile.slice(prefix.length);
           }
         }
-        if (!usedHardLink) {
-          const stream = fallback.toStream();
-          await (0, import_promisepipe2.default)(
-            stream,
-            import_fs_extra2.default.createWriteStream(fallbackPath, { mode: fallback.mode })
-          );
-        }
-        fallback = new FileFsRef({
-          ...output.fallback,
-          fsPath: basename(fallbackName)
+        return (0, import_build_utils.getLambdaOptionsFromFunction)({
+          sourceFile,
+          config: {
+            ...vercelConfig,
+            functions: service.functions,
+            serviceName: service.name
+          }
         });
       }
-      const prerenderConfigPath = join2(
-        outputDir,
-        "functions",
-        `${normalizedPath}.prerender-config.json`
-      );
-      const prerenderConfig = {
-        ...output,
-        lambda: void 0,
-        fallback
-      };
-      await import_fs_extra2.default.writeJSON(prerenderConfigPath, prerenderConfig, { spaces: 2 });
-    } else if (isFile(output)) {
-      await writeStaticFile(
+      if (vercelConfig) {
+        return (0, import_build_utils.getLambdaOptionsFromFunction)({
+          sourceFile: src,
+          config: vercelConfig
+        });
+      }
+      return {};
+    }
+    function getServiceOutputDir(outputDir, service) {
+      return (0, import_path.join)(outputDir, "services", service.name);
+    }
+    async function relocateRootBuildOutputToService2(args) {
+      const { outputDir, service, workPath } = args;
+      await relocateBuildOutputApiEntries(
         outputDir,
-        output,
-        normalizedPath,
-        overrides,
-        vercelConfig?.cleanUrls
+        getServiceOutputDir(outputDir, service),
+        workPath
       );
-    } else if (isEdgeFunction(output)) {
-      await writeEdgeFunction(
+    }
+    async function writeBuildResultV2(args) {
+      const {
         repoRootPath,
         outputDir,
-        output,
-        normalizedPath,
-        existingFunctions,
-        standalone
-      );
-    } else {
-      throw new Error(
-        `Unsupported output type: "${output.type}" for ${normalizedPath}`
-      );
-    }
-  }
-  return Object.keys(overrides).length > 0 ? overrides : void 0;
-}
-async function writeBuildResultV3(args) {
-  const {
-    repoRootPath,
-    outputDir,
-    buildResult,
-    build,
-    vercelConfig,
-    standalone,
-    workPath,
-    service,
-    rootOutputDir,
-    stripServiceRoutePrefix
-  } = args;
-  const { output } = buildResult;
-  const routesJsonPath = join2(workPath, ".vercel", "routes.json");
-  if (isBackendBuilder(build) || build.use === "@vercel/python") {
-    if ((0, import_fs_extra2.existsSync)(routesJsonPath)) {
-      try {
-        const newOutput = {
-          index: output
-        };
-        const routesJson = await import_fs_extra2.default.readJSON(routesJsonPath);
-        if (routesJson && typeof routesJson === "object" && "routes" in routesJson && Array.isArray(routesJson.routes)) {
-          for (const route of routesJson.routes) {
-            if (route.source === "/") {
-              continue;
+        buildResult,
+        build,
+        vercelConfig,
+        standalone,
+        workPath,
+        service,
+        rootOutputDir,
+        stripServiceRoutePrefix,
+        outputManager
+      } = args;
+      if ("buildOutputPath" in buildResult) {
+        await mergeBuilderOutput(
+          outputDir,
+          buildResult,
+          workPath,
+          rootOutputDir,
+          outputManager
+        );
+        return;
+      }
+      if (!buildResult.output) {
+        const configFile = vercelConfig?.[import_client.fileNameSymbol];
+        const updateMessage = build.use.startsWith("@now/") ? ` Please update from "@now" to "@vercel" in your \`${configFile}\` file.` : "";
+        throw new Error(
+          `The build result from "${build.use}" is missing the "output" property.${updateMessage}`
+        );
+      }
+      const existingFunctions = /* @__PURE__ */ new Map();
+      const overrides = {};
+      const functionConfiguration = build.src ? await resolveFunctionConfiguration(build.src, vercelConfig, service) : {};
+      for (const [path, output] of Object.entries(buildResult.output)) {
+        const normalizedPath = stripDuplicateSlashes(path);
+        if (isContainerImage(output)) {
+          injectServiceEnvVars(
+            output,
+            service && (0, import_build_utils.isExperimentalService)(service) ? service : void 0,
+            stripServiceRoutePrefix
+          );
+          await writeContainerImage(
+            outputDir,
+            output,
+            normalizedPath,
+            functionConfiguration
+          );
+        } else if (isLambda2(output)) {
+          injectServiceEnvVars(
+            output,
+            service && (0, import_build_utils.isExperimentalService)(service) ? service : void 0,
+            stripServiceRoutePrefix
+          );
+          await writeLambda(
+            repoRootPath,
+            outputDir,
+            output,
+            normalizedPath,
+            void 0,
+            existingFunctions,
+            standalone
+          );
+        } else if (isPrerender(output)) {
+          if (!output.lambda) {
+            throw new Error(
+              `Invalid Prerender with no "lambda" property: ${normalizedPath}`
+            );
+          }
+          await writeLambda(
+            repoRootPath,
+            outputDir,
+            output.lambda,
+            normalizedPath,
+            void 0,
+            existingFunctions,
+            standalone
+          );
+          let fallback = output.fallback;
+          if (fallback) {
+            const ext = getFileExtension(fallback);
+            const fallbackName = `${normalizedPath}.prerender-fallback${ext}`;
+            const fallbackPath = (0, import_path.join)(outputDir, "functions", fallbackName);
+            let usedHardLink = false;
+            if ("fsPath" in fallback) {
+              try {
+                await import_fs_extra.default.link(fallback.fsPath, fallbackPath);
+                usedHardLink = true;
+              } catch (_) {
+              }
             }
-            if (route.source) {
-              newOutput[route.source] = output;
+            if (!usedHardLink) {
+              const stream = fallback.toStream();
+              await (0, import_promisepipe.default)(
+                stream,
+                import_fs_extra.default.createWriteStream(fallbackPath, { mode: fallback.mode })
+              );
             }
+            fallback = new import_build_utils.FileFsRef({
+              ...output.fallback,
+              fsPath: (0, import_path.basename)(fallbackName)
+            });
           }
+          const prerenderConfigPath = (0, import_path.join)(
+            outputDir,
+            "functions",
+            `${normalizedPath}.prerender-config.json`
+          );
+          const prerenderConfig = {
+            ...output,
+            lambda: void 0,
+            fallback
+          };
+          await import_fs_extra.default.writeJSON(prerenderConfigPath, prerenderConfig, { spaces: 2 });
+        } else if (isFile(output)) {
+          await writeStaticFile(
+            outputDir,
+            output,
+            normalizedPath,
+            overrides,
+            vercelConfig?.cleanUrls
+          );
+        } else if (isEdgeFunction(output)) {
+          await writeEdgeFunction(
+            repoRootPath,
+            outputDir,
+            output,
+            normalizedPath,
+            existingFunctions,
+            standalone
+          );
+        } else {
+          throw new Error(
+            `Unsupported output type: "${output.type}" for ${normalizedPath}`
+          );
         }
-        return writeBuildResultV2({
-          repoRootPath,
-          outputDir,
-          buildResult: { output: newOutput, routes: buildResult.routes },
-          build,
-          vercelConfig,
-          standalone,
-          workPath,
-          service,
-          rootOutputDir,
-          stripServiceRoutePrefix
-        });
-      } catch (error) {
-        output_manager_default.error(`Failed to read routes.json: ${error}`);
       }
+      return Object.keys(overrides).length > 0 ? overrides : void 0;
     }
-    if (isBackendBuilder(build) && isExperimentalBackendsEnabled() && "routes" in buildResult) {
-      return writeBuildResultV2({
+    async function writeBuildResultV3(args) {
+      const {
         repoRootPath,
         outputDir,
         buildResult,
@@ -10390,502 +10450,866 @@ async function writeBuildResultV3(args) {
         workPath,
         service,
         rootOutputDir,
-        stripServiceRoutePrefix
-      });
+        stripServiceRoutePrefix,
+        outputManager
+      } = args;
+      const { output } = buildResult;
+      const routesJsonPath = (0, import_path.join)(workPath, ".vercel", "routes.json");
+      if ((0, import_build_utils.isBackendBuilder)(build) || build.use === "@vercel/python") {
+        if ((0, import_fs_extra.existsSync)(routesJsonPath)) {
+          try {
+            const newOutput = {
+              index: output
+            };
+            const routesJson = await import_fs_extra.default.readJSON(routesJsonPath);
+            if (routesJson && typeof routesJson === "object" && "routes" in routesJson && Array.isArray(routesJson.routes)) {
+              for (const route of routesJson.routes) {
+                if (route.source === "/") {
+                  continue;
+                }
+                if (route.source) {
+                  newOutput[route.source] = output;
+                }
+              }
+            }
+            return writeBuildResultV2({
+              repoRootPath,
+              outputDir,
+              buildResult: { output: newOutput, routes: buildResult.routes },
+              build,
+              vercelConfig,
+              standalone,
+              workPath,
+              service,
+              rootOutputDir,
+              stripServiceRoutePrefix,
+              outputManager
+            });
+          } catch (error) {
+            outputManager.error(`Failed to read routes.json: ${error}`);
+          }
+        }
+        if ((0, import_build_utils.isBackendBuilder)(build) && (0, import_build_utils.isExperimentalBackendsEnabled)() && "routes" in buildResult) {
+          return writeBuildResultV2({
+            repoRootPath,
+            outputDir,
+            buildResult,
+            build,
+            vercelConfig,
+            standalone,
+            workPath,
+            service,
+            rootOutputDir,
+            stripServiceRoutePrefix,
+            outputManager
+          });
+        }
+      }
+      const src = build.src;
+      if (typeof src !== "string") {
+        throw new Error(`Expected "build.src" to be a string`);
+      }
+      const functionConfiguration = await resolveFunctionConfiguration(
+        src,
+        vercelConfig,
+        service
+      );
+      const ext = (0, import_path.extname)(src);
+      const path = service && (0, import_build_utils.isExperimentalServiceV2)(service) ? "index" : service && typeof service.runtime === "string" ? stripDuplicateSlashes((0, import_build_utils.getInternalServiceFunctionPath)(service.name)) : stripDuplicateSlashes(
+        build.config?.zeroConfig ? src.substring(0, src.length - ext.length) : src
+      );
+      if (isContainerImage(output)) {
+        injectServiceEnvVars(
+          output,
+          service && (0, import_build_utils.isExperimentalService)(service) ? service : void 0,
+          stripServiceRoutePrefix
+        );
+        await writeContainerImage(outputDir, output, path, functionConfiguration);
+      } else if (isLambda2(output)) {
+        injectServiceEnvVars(
+          output,
+          service && (0, import_build_utils.isExperimentalService)(service) ? service : void 0,
+          stripServiceRoutePrefix
+        );
+        await writeLambda(
+          repoRootPath,
+          outputDir,
+          output,
+          path,
+          functionConfiguration,
+          void 0,
+          standalone
+        );
+      } else if (isEdgeFunction(output)) {
+        await writeEdgeFunction(
+          repoRootPath,
+          outputDir,
+          output,
+          path,
+          void 0,
+          standalone
+        );
+      } else {
+        throw new Error(
+          `Unsupported output type: "${output.type}" for ${build.src}`
+        );
+      }
     }
-  }
-  const src = build.src;
-  if (typeof src !== "string") {
-    throw new Error(`Expected "build.src" to be a string`);
-  }
-  const functionConfiguration = await resolveFunctionConfiguration(
-    src,
-    vercelConfig,
-    service
-  );
-  const ext = extname(src);
-  const path2 = service && isExperimentalServiceV2(service) ? "index" : service && typeof service.runtime === "string" ? stripDuplicateSlashes((0, import_fs_detectors.getInternalServiceFunctionPath)(service.name)) : stripDuplicateSlashes(
-    build.config?.zeroConfig ? src.substring(0, src.length - ext.length) : src
-  );
-  if (isContainerImage(output)) {
-    injectServiceEnvVars(
-      output,
-      service && isExperimentalService(service) ? service : void 0,
-      stripServiceRoutePrefix
-    );
-    await writeContainerImage(outputDir, output, path2, functionConfiguration);
-  } else if (isLambda(output)) {
-    injectServiceEnvVars(
-      output,
-      service && isExperimentalService(service) ? service : void 0,
-      stripServiceRoutePrefix
-    );
-    await writeLambda(
-      repoRootPath,
-      outputDir,
-      output,
-      path2,
-      functionConfiguration,
-      void 0,
-      standalone
-    );
-  } else if (isEdgeFunction(output)) {
-    await writeEdgeFunction(
-      repoRootPath,
-      outputDir,
-      output,
-      path2,
-      void 0,
-      standalone
-    );
-  } else {
-    throw new Error(
-      `Unsupported output type: "${output.type}" for ${build.src}`
-    );
-  }
-}
-async function writeStaticFile(outputDir, file, path2, overrides, cleanUrls = false) {
-  let fsPath = path2;
-  let override = null;
-  const ext = getFileExtension(file);
-  if (ext && extname(path2) !== ext) {
-    fsPath += ext;
-    if (!override)
-      override = {};
-    override.path = path2;
-  }
-  if (cleanUrls && path2.endsWith(".html")) {
-    if (!override)
-      override = {};
-    override.path = path2.slice(0, -5);
-  }
-  if (file.contentType) {
-    if (!override)
-      override = {};
-    override.contentType = file.contentType;
-  }
-  if (override) {
-    overrides[fsPath] = override;
-  }
-  const dest = join2(outputDir, "static", fsPath);
-  await import_fs_extra2.default.mkdirp(dirname(dest));
-  if ("fsPath" in file) {
-    if (resolve(file.fsPath) === resolve(dest)) {
-      return;
+    async function writeStaticFile(outputDir, file, path, overrides, cleanUrls = false) {
+      let fsPath = path;
+      let override = null;
+      const ext = getFileExtension(file);
+      if (ext && (0, import_path.extname)(path) !== ext) {
+        fsPath += ext;
+        if (!override)
+          override = {};
+        override.path = path;
+      }
+      if (cleanUrls && path.endsWith(".html")) {
+        if (!override)
+          override = {};
+        override.path = path.slice(0, -5);
+      }
+      if (file.contentType) {
+        if (!override)
+          override = {};
+        override.contentType = file.contentType;
+      }
+      if (override) {
+        overrides[fsPath] = override;
+      }
+      const dest = (0, import_path.join)(outputDir, "static", fsPath);
+      await import_fs_extra.default.mkdirp((0, import_path.dirname)(dest));
+      if ("fsPath" in file) {
+        if ((0, import_path.resolve)(file.fsPath) === (0, import_path.resolve)(dest)) {
+          return;
+        }
+        try {
+          return await import_fs_extra.default.link(file.fsPath, dest);
+        } catch (_) {
+        }
+      }
+      await (0, import_build_utils.downloadFile)(file, dest);
     }
-    try {
-      return await import_fs_extra2.default.link(file.fsPath, dest);
-    } catch (_) {
+    async function writeFunctionSymlink(outputDir, dest, fn, existingFunctions) {
+      const existingPath = existingFunctions.get(fn);
+      if (!existingPath)
+        return false;
+      const destDir = (0, import_path.dirname)(dest);
+      const targetDest = (0, import_path.join)(outputDir, "functions", `${existingPath}.func`);
+      const target = (0, import_path.relative)(destDir, targetDest);
+      await import_fs_extra.default.mkdirp(destDir);
+      await import_fs_extra.default.symlink(target, dest);
+      return true;
     }
-  }
-  await downloadFile(file, dest);
-}
-async function writeFunctionSymlink(outputDir, dest, fn, existingFunctions) {
-  const existingPath = existingFunctions.get(fn);
-  if (!existingPath)
-    return false;
-  const destDir = dirname(dest);
-  const targetDest = join2(outputDir, "functions", `${existingPath}.func`);
-  const target = relative2(destDir, targetDest);
-  await import_fs_extra2.default.mkdirp(destDir);
-  await import_fs_extra2.default.symlink(target, dest);
-  return true;
-}
-async function writeContainerImage(outputDir, containerImage, path2, functionConfiguration) {
-  const dest = join2(outputDir, "functions", `${path2}.func`);
-  const handler = containerImage.handler;
-  if (typeof handler !== "string" || handler.length === 0) {
-    throw new Error(
-      `Container image output for "${path2}" is missing "handler".`
-    );
-  }
-  const architecture = functionConfiguration?.architecture ?? containerImage.architecture;
-  const memory = functionConfiguration?.memory ?? containerImage.memory;
-  const maxDuration = functionConfiguration?.maxDuration ?? containerImage.maxDuration;
-  const maxConcurrency = functionConfiguration?.maxConcurrency ?? containerImage.maxConcurrency;
-  const regions = functionConfiguration?.regions ?? containerImage.regions;
-  const functionFailoverRegions = functionConfiguration?.functionFailoverRegions ?? containerImage.functionFailoverRegions;
-  const experimentalTriggers = functionConfiguration?.experimentalTriggers ?? containerImage.experimentalTriggers;
-  const supportsCancellation = functionConfiguration?.supportsCancellation ?? containerImage.supportsCancellation;
-  await import_fs_extra2.default.mkdirp(dest);
-  await import_fs_extra2.default.writeJSON(
-    join2(dest, ".vc-config.json"),
-    {
-      handler,
-      runtime: "container",
-      environment: containerImage.environment ?? {},
-      ...containerImage.command ? { command: containerImage.command } : {},
-      ...architecture !== void 0 ? { architecture } : {},
-      ...memory !== void 0 ? { memory } : {},
-      ...maxDuration !== void 0 ? { maxDuration } : {},
-      ...maxConcurrency !== void 0 ? { maxConcurrency } : {},
-      ...regions !== void 0 ? { regions } : {},
-      ...functionFailoverRegions !== void 0 ? { functionFailoverRegions } : {},
-      ...experimentalTriggers !== void 0 ? { experimentalTriggers } : {},
-      ...supportsCancellation !== void 0 ? { supportsCancellation } : {}
-    },
-    { spaces: 2 }
-  );
-}
-async function writeEdgeFunction(repoRootPath, outputDir, edgeFunction, path2, existingFunctions, standalone = false) {
-  const dest = join2(outputDir, "functions", `${path2}.func`);
-  if (existingFunctions) {
-    if (await writeFunctionSymlink(
-      outputDir,
-      dest,
-      edgeFunction,
-      existingFunctions
-    )) {
-      return;
+    async function writeContainerImage(outputDir, containerImage, path, functionConfiguration) {
+      const dest = (0, import_path.join)(outputDir, "functions", `${path}.func`);
+      const handler = containerImage.handler;
+      if (typeof handler !== "string" || handler.length === 0) {
+        throw new Error(
+          `Container image output for "${path}" is missing "handler".`
+        );
+      }
+      const architecture = functionConfiguration?.architecture ?? containerImage.architecture;
+      const memory = functionConfiguration?.memory ?? containerImage.memory;
+      const maxDuration = functionConfiguration?.maxDuration ?? containerImage.maxDuration;
+      const maxConcurrency = functionConfiguration?.maxConcurrency ?? containerImage.maxConcurrency;
+      const regions = functionConfiguration?.regions ?? containerImage.regions;
+      const functionFailoverRegions = functionConfiguration?.functionFailoverRegions ?? containerImage.functionFailoverRegions;
+      const experimentalTriggers = functionConfiguration?.experimentalTriggers ?? containerImage.experimentalTriggers;
+      const supportsCancellation = functionConfiguration?.supportsCancellation ?? containerImage.supportsCancellation;
+      await import_fs_extra.default.mkdirp(dest);
+      await import_fs_extra.default.writeJSON(
+        (0, import_path.join)(dest, ".vc-config.json"),
+        {
+          handler,
+          runtime: "container",
+          environment: containerImage.environment ?? {},
+          ...containerImage.command ? { command: containerImage.command } : {},
+          ...architecture !== void 0 ? { architecture } : {},
+          ...memory !== void 0 ? { memory } : {},
+          ...maxDuration !== void 0 ? { maxDuration } : {},
+          ...maxConcurrency !== void 0 ? { maxConcurrency } : {},
+          ...regions !== void 0 ? { regions } : {},
+          ...functionFailoverRegions !== void 0 ? { functionFailoverRegions } : {},
+          ...experimentalTriggers !== void 0 ? { experimentalTriggers } : {},
+          ...supportsCancellation !== void 0 ? { supportsCancellation } : {}
+        },
+        { spaces: 2 }
+      );
     }
-    existingFunctions.set(edgeFunction, path2);
-  }
-  await import_fs_extra2.default.mkdirp(dest);
-  const ops = [];
-  const { files, filePathMap } = filesWithoutFsRefs(
-    edgeFunction.files,
-    repoRootPath,
-    standalone
-  );
-  ops.push(download(files, dest));
-  const config = {
-    runtime: "edge",
-    ...edgeFunction,
-    entrypoint: normalizePath(edgeFunction.entrypoint),
-    filePathMap,
-    files: void 0,
-    type: void 0
-  };
-  const configPath = join2(dest, ".vc-config.json");
-  ops.push(
-    import_fs_extra2.default.writeJSON(configPath, config, {
-      spaces: 2
-    })
-  );
-  await Promise.all(ops);
-}
-async function writeLambda(repoRootPath, outputDir, lambda, path2, functionConfiguration, existingFunctions, standalone = false) {
-  const dest = join2(outputDir, "functions", `${path2}.func`);
-  if (existingFunctions) {
-    if (await writeFunctionSymlink(outputDir, dest, lambda, existingFunctions)) {
-      return;
+    async function writeEdgeFunction(repoRootPath, outputDir, edgeFunction, path, existingFunctions, standalone = false) {
+      const dest = (0, import_path.join)(outputDir, "functions", `${path}.func`);
+      if (existingFunctions) {
+        if (await writeFunctionSymlink(
+          outputDir,
+          dest,
+          edgeFunction,
+          existingFunctions
+        )) {
+          return;
+        }
+        existingFunctions.set(edgeFunction, path);
+      }
+      await import_fs_extra.default.mkdirp(dest);
+      const ops = [];
+      const { files, filePathMap } = filesWithoutFsRefs2(
+        edgeFunction.files,
+        repoRootPath,
+        standalone
+      );
+      ops.push((0, import_build_utils.download)(files, dest));
+      const config = {
+        runtime: "edge",
+        ...edgeFunction,
+        entrypoint: (0, import_build_utils.normalizePath)(edgeFunction.entrypoint),
+        filePathMap,
+        files: void 0,
+        type: void 0
+      };
+      const configPath = (0, import_path.join)(dest, ".vc-config.json");
+      ops.push(
+        import_fs_extra.default.writeJSON(configPath, config, {
+          spaces: 2
+        })
+      );
+      await Promise.all(ops);
     }
-    existingFunctions.set(lambda, path2);
-  }
-  await import_fs_extra2.default.mkdirp(dest);
-  const ops = [];
-  let filePathMap;
-  if (lambda.files) {
-    const f = filesWithoutFsRefs(lambda.files, repoRootPath, standalone);
-    filePathMap = f.filePathMap;
-    ops.push(download(f.files, dest));
-  } else if (lambda.zipBuffer) {
-    ops.push(unzip(lambda.zipBuffer, dest));
-  } else {
-    throw new Error('Malformed `Lambda` - no "files" present');
-  }
-  const architecture = functionConfiguration?.architecture ?? lambda.architecture;
-  const memory = functionConfiguration?.memory ?? lambda.memory;
-  const maxDuration = functionConfiguration?.maxDuration ?? lambda.maxDuration;
-  const maxConcurrency = functionConfiguration?.maxConcurrency ?? lambda.maxConcurrency;
-  const regions = functionConfiguration?.regions ?? lambda.regions;
-  const functionFailoverRegions = functionConfiguration?.functionFailoverRegions ?? lambda.functionFailoverRegions;
-  const experimentalTriggers = functionConfiguration?.experimentalTriggers ?? lambda.experimentalTriggers;
-  const supportsCancellation = functionConfiguration?.supportsCancellation ?? lambda.supportsCancellation;
-  const config = {
-    ...lambda,
-    handler: normalizePath(lambda.handler),
-    architecture,
-    memory,
-    maxDuration,
-    maxConcurrency,
-    regions,
-    functionFailoverRegions,
-    experimentalTriggers,
-    supportsCancellation,
-    filePathMap,
-    type: void 0,
-    files: void 0,
-    zipBuffer: void 0
-  };
-  const configPath = join2(dest, ".vc-config.json");
-  ops.push(
-    import_fs_extra2.default.writeJSON(configPath, config, {
-      spaces: 2
-    })
-  );
-  await Promise.all(ops);
-  for await (const dir of findDirs(".vercel", dest)) {
-    const absDir = join2(dest, dir);
-    const entries = await import_fs_extra2.default.readdir(absDir);
-    if (entries.includes("cache")) {
+    async function writeLambda(repoRootPath, outputDir, lambda, path, functionConfiguration, existingFunctions, standalone = false) {
+      const dest = (0, import_path.join)(outputDir, "functions", `${path}.func`);
+      if (existingFunctions) {
+        if (await writeFunctionSymlink(outputDir, dest, lambda, existingFunctions)) {
+          return;
+        }
+        existingFunctions.set(lambda, path);
+      }
+      await import_fs_extra.default.mkdirp(dest);
+      const ops = [];
+      let filePathMap;
+      if (lambda.files) {
+        const f = filesWithoutFsRefs2(lambda.files, repoRootPath, standalone);
+        filePathMap = f.filePathMap;
+        ops.push((0, import_build_utils.download)(f.files, dest));
+      } else if (lambda.zipBuffer) {
+        ops.push((0, import_unzip.unzip)(lambda.zipBuffer, dest));
+      } else {
+        throw new Error('Malformed `Lambda` - no "files" present');
+      }
+      const architecture = functionConfiguration?.architecture ?? lambda.architecture;
+      const memory = functionConfiguration?.memory ?? lambda.memory;
+      const maxDuration = functionConfiguration?.maxDuration ?? lambda.maxDuration;
+      const maxConcurrency = functionConfiguration?.maxConcurrency ?? lambda.maxConcurrency;
+      const regions = functionConfiguration?.regions ?? lambda.regions;
+      const functionFailoverRegions = functionConfiguration?.functionFailoverRegions ?? lambda.functionFailoverRegions;
+      const experimentalTriggers = functionConfiguration?.experimentalTriggers ?? lambda.experimentalTriggers;
+      const supportsCancellation = functionConfiguration?.supportsCancellation ?? lambda.supportsCancellation;
+      const config = {
+        ...lambda,
+        handler: (0, import_build_utils.normalizePath)(lambda.handler),
+        architecture,
+        memory,
+        maxDuration,
+        maxConcurrency,
+        regions,
+        functionFailoverRegions,
+        experimentalTriggers,
+        supportsCancellation,
+        filePathMap,
+        type: void 0,
+        files: void 0,
+        zipBuffer: void 0
+      };
+      const configPath = (0, import_path.join)(dest, ".vc-config.json");
+      ops.push(
+        import_fs_extra.default.writeJSON(configPath, config, {
+          spaces: 2
+        })
+      );
+      await Promise.all(ops);
+      for await (const dir of findDirs2(".vercel", dest)) {
+        const absDir = (0, import_path.join)(dest, dir);
+        const entries = await import_fs_extra.default.readdir(absDir);
+        if (entries.includes("cache")) {
+          await Promise.all(
+            entries.filter((e) => e !== "cache").map((entry) => import_fs_extra.default.remove((0, import_path.join)(absDir, entry)))
+          );
+        } else {
+          await import_fs_extra.default.remove(absDir);
+        }
+      }
+    }
+    async function mergeBuilderOutput(outputDir, buildResult, workPath, rootOutputDir, outputManager) {
+      const absOutputDir = (0, import_path.resolve)(outputDir);
+      const absRootOutputDir = (0, import_path.resolve)(rootOutputDir);
+      const { ig } = await (0, import_client.getVercelIgnore)(workPath);
+      const filter = ig.createFilter();
+      if (absOutputDir === buildResult.buildOutputPath) {
+        const staticDir = (0, import_path.join)(outputDir, "static");
+        try {
+          await cleanIgnoredFiles(staticDir, staticDir, filter, outputManager);
+        } catch (err) {
+          if (err.code !== "ENOENT")
+            throw err;
+        }
+        return;
+      }
+      if ((0, import_path.resolve)(buildResult.buildOutputPath) === absRootOutputDir) {
+        await relocateBuildOutputApiEntries(rootOutputDir, outputDir, workPath);
+        return;
+      }
+      const ignoreFilter = (path) => {
+        const normalizedPath = path.replace(/\\/g, "/");
+        if (normalizedPath.startsWith("static/")) {
+          return filter(normalizedPath.substring("static/".length));
+        }
+        return true;
+      };
+      await (0, import_merge.merge)(buildResult.buildOutputPath, outputDir, ignoreFilter);
+    }
+    async function relocateBuildOutputApiEntries(rootOutputDir, outputDir, workPath) {
+      const { ig } = await (0, import_client.getVercelIgnore)(workPath);
+      const filter = ig.createFilter();
+      await import_fs_extra.default.mkdirp(outputDir);
       await Promise.all(
-        entries.filter((e) => e !== "cache").map((entry) => import_fs_extra2.default.remove(join2(absDir, entry)))
+        BUILD_OUTPUT_API_ENTRIES.map(async (entry) => {
+          const src = (0, import_path.join)(rootOutputDir, entry);
+          if (!await import_fs_extra.default.pathExists(src))
+            return;
+          const dest = (0, import_path.join)(outputDir, entry);
+          if (entry === "static") {
+            await (0, import_merge.merge)(src, dest, (path) => filter(path));
+          } else {
+            await (0, import_merge.merge)(src, dest);
+          }
+        })
       );
-    } else {
-      await import_fs_extra2.default.remove(absDir);
     }
-  }
-}
-async function mergeBuilderOutput(outputDir, buildResult, workPath, rootOutputDir) {
-  const absOutputDir = resolve(outputDir);
-  const absRootOutputDir = resolve(rootOutputDir);
-  const { ig } = await (0, import_client.getVercelIgnore)(workPath);
-  const filter = ig.createFilter();
-  if (absOutputDir === buildResult.buildOutputPath) {
-    const staticDir = join2(outputDir, "static");
-    try {
-      await cleanIgnoredFiles(staticDir, staticDir, filter);
-    } catch (err) {
-      if (err.code !== "ENOENT")
-        throw err;
+    async function cleanIgnoredFiles(dir, staticRoot, filter, outputManager) {
+      const entries = await import_fs_extra.default.readdir(dir);
+      await Promise.all(
+        entries.map(async (entry) => {
+          const entryPath = (0, import_path.join)(dir, entry);
+          const stat = await import_fs_extra.default.stat(entryPath);
+          const relativePath = (0, import_path.relative)(staticRoot, entryPath);
+          if (stat.isDirectory()) {
+            await cleanIgnoredFiles(entryPath, staticRoot, filter, outputManager);
+            const remaining = await import_fs_extra.default.readdir(entryPath);
+            if (remaining.length === 0) {
+              await import_fs_extra.default.rmdir(entryPath);
+            }
+          } else if (!filter(relativePath)) {
+            outputManager.debug(`Removing ignored file: ${relativePath}`);
+            await import_fs_extra.default.remove(entryPath);
+          }
+        })
+      );
     }
-    return;
-  }
-  if (resolve(buildResult.buildOutputPath) === absRootOutputDir) {
-    await relocateBuildOutputApiEntries(rootOutputDir, outputDir, workPath);
-    return;
-  }
-  const ignoreFilter = (path2) => {
-    const normalizedPath = path2.replace(/\\/g, "/");
-    if (normalizedPath.startsWith("static/")) {
-      return filter(normalizedPath.substring("static/".length));
+    function getFileExtension(file) {
+      let ext = "";
+      if (file.type === "FileFsRef") {
+        ext = (0, import_path.extname)(file.fsPath);
+      }
+      if (!ext && file.contentType) {
+        const e = import_mime_types.default.extension(file.contentType);
+        if (e) {
+          ext = `.${e}`;
+        }
+      }
+      return ext;
     }
-    return true;
-  };
-  await merge(buildResult.buildOutputPath, outputDir, ignoreFilter);
-}
-async function relocateBuildOutputApiEntries(rootOutputDir, outputDir, workPath) {
-  const { ig } = await (0, import_client.getVercelIgnore)(workPath);
-  const filter = ig.createFilter();
-  await import_fs_extra2.default.mkdirp(outputDir);
-  await Promise.all(
-    BUILD_OUTPUT_API_ENTRIES.map(async (entry) => {
-      const src = join2(rootOutputDir, entry);
-      if (!await import_fs_extra2.default.pathExists(src))
-        return;
-      const dest = join2(outputDir, entry);
-      if (entry === "static") {
-        await merge(src, dest, (path2) => filter(path2));
-      } else {
-        await merge(src, dest);
+    async function* findDirs2(name, dir, root = dir) {
+      let paths;
+      try {
+        paths = await import_fs_extra.default.readdir(dir);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw err;
+        }
+        paths = [];
       }
-    })
-  );
-}
-async function cleanIgnoredFiles(dir, staticRoot, filter) {
-  const entries = await import_fs_extra2.default.readdir(dir);
-  await Promise.all(
-    entries.map(async (entry) => {
-      const entryPath = join2(dir, entry);
-      const stat2 = await import_fs_extra2.default.stat(entryPath);
-      const relativePath = relative2(staticRoot, entryPath);
-      if (stat2.isDirectory()) {
-        await cleanIgnoredFiles(entryPath, staticRoot, filter);
-        const remaining = await import_fs_extra2.default.readdir(entryPath);
-        if (remaining.length === 0) {
-          await import_fs_extra2.default.rmdir(entryPath);
+      for (const path of paths) {
+        const abs = (0, import_path.join)(dir, path);
+        let stat;
+        try {
+          stat = await import_fs_extra.default.lstat(abs);
+        } catch (err) {
+          if (err.code === "ENOENT")
+            continue;
+          throw err;
+        }
+        if (stat.isDirectory()) {
+          if (path === name) {
+            yield (0, import_path.relative)(root, abs);
+          } else {
+            yield* findDirs2(name, abs, root);
+          }
         }
-      } else if (!filter(relativePath)) {
-        output_manager_default.debug(`Removing ignored file: ${relativePath}`);
-        await import_fs_extra2.default.remove(entryPath);
       }
-    })
-  );
-}
-function getFileExtension(file) {
-  let ext = "";
-  if (file.type === "FileFsRef") {
-    ext = extname(file.fsPath);
-  }
-  if (!ext && file.contentType) {
-    const e = import_mime_types.default.extension(file.contentType);
-    if (e) {
-      ext = `.${e}`;
     }
-  }
-  return ext;
-}
-async function* findDirs(name, dir, root = dir) {
-  let paths;
-  try {
-    paths = await import_fs_extra2.default.readdir(dir);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
+    function filesWithoutFsRefs2(files, repoRootPath, standalone) {
+      const symlinkDirs = standalone ? Object.entries(files).filter(([, f]) => f.type === "FileFsRef" && (0, import_build_utils.isSymbolicLink)(f.mode)).map(([p]) => `${(0, import_build_utils.normalizePath)(p)}/`) : [];
+      let filePathMap;
+      const out = {};
+      for (const [path, file] of Object.entries(files)) {
+        if (file.type === "FileFsRef") {
+          if (standalone) {
+            const normalized = (0, import_build_utils.normalizePath)(path);
+            if (symlinkDirs.some((prefix) => normalized.startsWith(prefix))) {
+              continue;
+            }
+            out[normalized] = file;
+          } else {
+            if (!filePathMap)
+              filePathMap = {};
+            filePathMap[(0, import_build_utils.normalizePath)(path)] = (0, import_build_utils.normalizePath)(
+              (0, import_path.relative)(repoRootPath, file.fsPath)
+            );
+          }
+        } else {
+          out[path] = file;
+        }
+      }
+      return { files: out, filePathMap };
     }
-    paths = [];
   }
-  for (const path2 of paths) {
-    const abs = join2(dir, path2);
-    let stat2;
-    try {
-      stat2 = await import_fs_extra2.default.lstat(abs);
-    } catch (err) {
-      if (err.code === "ENOENT")
-        continue;
-      throw err;
+});
+
+// ../../internals/cli-builder-integration/dist/get-services-builders.js
+var require_get_services_builders = __commonJS({
+  "../../internals/cli-builder-integration/dist/get-services-builders.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var get_services_builders_exports = {};
+    __export(get_services_builders_exports, {
+      getServicesBuilders: () => getServicesBuilders,
+      warnIgnoredDirectories: () => warnIgnoredDirectories
+    });
+    module.exports = __toCommonJS(get_services_builders_exports);
+    var import_fs_detectors = require_dist3();
+    var import_service_topology = require_dist4();
+    function isExperimentalServicesAutoDetectionEnabled() {
+      const env = process.env.VERCEL_USE_EXPERIMENTAL_SERVICES;
+      return env === "1" || env?.toLowerCase() === "true";
     }
-    if (stat2.isDirectory()) {
-      if (path2 === name) {
-        yield relative2(root, abs);
-      } else {
-        yield* findDirs(name, abs, root);
+    async function getServicesBuilders(options) {
+      const {
+        workPath,
+        configuredServices,
+        configuredServicesType,
+        projectFramework
+      } = options;
+      const hasServiceDefinitions = configuredServices != null && Object.keys(configuredServices).length > 0;
+      if (projectFramework === "services" && !hasServiceDefinitions && !isExperimentalServicesAutoDetectionEnabled()) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "MISSING_SERVICES",
+              message: 'Project framework is set to "services", but no services are declared. Add `services` to vercel.json with at least one service, or change the project framework setting.'
+            }
+          ],
+          warnings: [],
+          hostRewriteRoutes: null,
+          defaultRoutes: null,
+          fallbackRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
       }
+      if (!workPath) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "MISSING_WORK_PATH",
+              message: "workPath is required for services detection."
+            }
+          ],
+          warnings: [],
+          hostRewriteRoutes: null,
+          defaultRoutes: null,
+          fallbackRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const fs = new import_fs_detectors.LocalFileSystemDetector(workPath);
+      const result = await (0, import_service_topology.detectServices)({
+        fs,
+        configuredServices,
+        configuredServicesType
+      });
+      const warningResponses = result.warnings.map((w) => ({
+        code: w.code,
+        message: w.message
+      }));
+      if (result.errors.length > 0) {
+        return {
+          builders: null,
+          errors: result.errors.map((e) => ({
+            code: e.code,
+            message: e.message
+          })),
+          warnings: warningResponses,
+          hostRewriteRoutes: null,
+          defaultRoutes: null,
+          fallbackRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      if (result.services.length === 0) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "NO_SERVICES_CONFIGURED",
+              message: "No services configured. Add `services` to vercel.json."
+            }
+          ],
+          warnings: warningResponses,
+          hostRewriteRoutes: null,
+          defaultRoutes: null,
+          fallbackRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const builders = result.services.map((service) => service.builder);
+      return {
+        builders: builders.length > 0 ? builders : null,
+        errors: null,
+        warnings: warningResponses,
+        hostRewriteRoutes: result.routes.hostRewrites.length > 0 ? result.routes.hostRewrites : null,
+        defaultRoutes: result.routes.defaults.length > 0 ? result.routes.defaults : null,
+        fallbackRoutes: result.routes.fallbacks.length > 0 ? result.routes.fallbacks : null,
+        redirectRoutes: [],
+        rewriteRoutes: result.routes.rewrites.length > 0 || result.routes.workers.length > 0 || result.routes.crons.length > 0 ? [
+          ...result.routes.rewrites,
+          ...result.routes.workers,
+          ...result.routes.crons
+        ] : null,
+        errorRoutes: [],
+        serviceRewrites: result.rewrites.length > 0 ? result.rewrites : void 0,
+        experimentalServicesV2: result.experimentalServicesV2,
+        services: result.services,
+        useImplicitEnvInjection: result.useImplicitEnvInjection
+      };
     }
-  }
-}
-function filesWithoutFsRefs(files, repoRootPath, standalone) {
-  const symlinkDirs = standalone ? Object.entries(files).filter(([, f]) => f.type === "FileFsRef" && isSymbolicLink(f.mode)).map(([p]) => `${normalizePath(p)}/`) : [];
-  let filePathMap;
-  const out = {};
-  for (const [path2, file] of Object.entries(files)) {
-    if (file.type === "FileFsRef") {
-      if (standalone) {
-        const normalized = normalizePath(path2);
-        if (symlinkDirs.some((prefix) => normalized.startsWith(prefix))) {
-          continue;
+    function warnIgnoredDirectories(files, configuredServices) {
+      const warnings = [];
+      if (files.some((f) => f.startsWith("api/"))) {
+        const serviceCoversApi = Object.values(configuredServices).some((service) => {
+          const root = service.root ?? ".";
+          const entrypoint = service.entrypoint ?? "";
+          return root === "api" || root.startsWith("api/") || root === "." && entrypoint.startsWith("api/");
+        });
+        if (!serviceCoversApi) {
+          warnings.push({
+            code: "api_dir_ignored",
+            message: "The `api/` directory will not be built because services are configured. To serve these files, declare them as a service in your `vercel.json`."
+          });
         }
-        out[normalized] = file;
-      } else {
-        if (!filePathMap)
-          filePathMap = {};
-        filePathMap[normalizePath(path2)] = normalizePath(
-          relative2(repoRootPath, file.fsPath)
-        );
       }
-    } else {
-      out[path2] = file;
+      return warnings;
     }
   }
-  return { files: out, filePathMap };
-}
-
-// src/util/get-files.ts
-var import_fs_extra3 = __toESM(require_lib(), 1);
-var import_client2 = __toESM(require_dist2(), 1);
-import { resolve as resolve2 } from "path";
+});
 
-// src/util/unique-strings.ts
-var unique_strings_default = (arr) => {
-  const len = arr.length;
-  const res = [];
-  const o = {};
-  let i;
-  for (i = 0; i < len; i += 1) {
-    o[arr[i]] = o[arr[i]] || res.push(arr[i]);
+// ../../internals/cli-builder-integration/dist/detect-builders-with-services.js
+var require_detect_builders_with_services = __commonJS({
+  "../../internals/cli-builder-integration/dist/detect-builders-with-services.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var detect_builders_with_services_exports = {};
+    __export(detect_builders_with_services_exports, {
+      detectBuildersWithServices: () => detectBuildersWithServices
+    });
+    module.exports = __toCommonJS(detect_builders_with_services_exports);
+    var import_fs_detectors = require_dist3();
+    var import_get_services_builders = require_get_services_builders();
+    async function detectBuildersWithServices(files, pkg, options = {}) {
+      const {
+        experimentalServices: experimentalServicesV1,
+        services,
+        experimentalServicesV2,
+        projectSettings = {}
+      } = options;
+      if (services != null && experimentalServicesV2 != null) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
+              message: "The `services` option cannot be used in conjunction with its deprecated alias `experimentalServicesV2`. Please use only `services`."
+            }
+          ],
+          warnings: [],
+          defaultRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const proxyError = (0, import_fs_detectors.validateProxy)(options, files, projectSettings.framework);
+      if (proxyError) {
+        return {
+          builders: null,
+          errors: [proxyError],
+          warnings: [],
+          defaultRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const servicesConfig = services ?? experimentalServicesV2;
+      const configuredServices = servicesConfig ?? experimentalServicesV1;
+      const configuredServicesType = servicesConfig ? services ? "services" : "experimentalServicesV2" : "experimentalServices";
+      const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
+      if (!hasServicesConfig && projectSettings.framework !== "services") {
+        return (0, import_fs_detectors.detectBuilders)(files, pkg, options);
+      }
+      const result = await (0, import_get_services_builders.getServicesBuilders)({
+        workPath: options.workPath,
+        configuredServices,
+        configuredServicesType,
+        projectFramework: projectSettings.framework
+      });
+      if (configuredServices != null) {
+        result.warnings.push(...(0, import_get_services_builders.warnIgnoredDirectories)(files, configuredServices));
+      }
+      if (!result.errors && options.proxy) {
+        result.builders = [
+          (0, import_fs_detectors.getProxyBuilder)(options.proxy, options.tag, options.functions),
+          ...result.builders ?? []
+        ];
+      }
+      return result;
+    }
   }
-  return res;
-};
+});
 
-// src/util/get-files.ts
-function flatten(arr, res = []) {
-  for (const cur of arr) {
-    if (Array.isArray(cur)) {
-      flatten(cur, res);
-    } else {
-      res.push(cur);
+// ../../internals/cli-builder-integration/dist/service-schedules.js
+var require_service_schedules = __commonJS({
+  "../../internals/cli-builder-integration/dist/service-schedules.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var service_schedules_exports = {};
+    __export(service_schedules_exports, {
+      getStaticServiceSchedules: () => getStaticServiceSchedules
+    });
+    module.exports = __toCommonJS(service_schedules_exports);
+    var DYNAMIC_SCHEDULE = "<dynamic>";
+    function getStaticServiceSchedules(schedule) {
+      if (!schedule || schedule === DYNAMIC_SCHEDULE) {
+        return [];
+      }
+      return Array.isArray(schedule) ? schedule.filter((item) => item !== DYNAMIC_SCHEDULE) : [schedule];
     }
   }
-  return res;
-}
-var asAbsolute = function(path2, parent) {
-  if (path2[0] === "/") {
-    return path2;
-  }
-  return resolve2(parent, path2);
-};
-async function staticFiles(path2, { src }) {
-  const { debug, time } = output_manager_default;
-  let files = [];
-  const source = src || ".";
-  const search = resolve2(path2, source);
-  const { ig } = await (0, import_client2.getVercelIgnore)(path2);
-  const filter = ig.createFilter();
-  const prefixLength = path2.length + 1;
-  const accepts = (file) => {
-    const relativePath = file.slice(prefixLength);
-    if (relativePath === "") {
-      return true;
-    }
-    const accepted = filter(relativePath);
-    if (!accepted) {
-      debug(`Ignoring ${file}`);
-    }
-    return accepted;
-  };
-  files = await time(
-    `Locating files ${path2}`,
-    explode([search], {
-      accepts
-    })
-  );
-  return unique_strings_default(files);
-}
-async function explode(paths, { accepts }) {
-  const { debug } = output_manager_default;
-  const list = async (file) => {
-    let path2 = file;
-    let s;
-    if (!accepts(file)) {
-      return null;
+});
+
+// ../../internals/cli-builder-integration/dist/get-files.js
+var require_get_files = __commonJS({
+  "../../internals/cli-builder-integration/dist/get-files.js"(exports, module) {
+    "use strict";
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var get_files_exports = {};
+    __export(get_files_exports, {
+      staticFiles: () => staticFiles
+    });
+    module.exports = __toCommonJS(get_files_exports);
+    var import_fs_extra = __toESM2(require_lib());
+    var import_path = __require("path");
+    var import_client = require_dist2();
+    function flatten(arr, res = []) {
+      for (const cur of arr) {
+        if (Array.isArray(cur)) {
+          flatten(cur, res);
+        } else {
+          res.push(cur);
+        }
+      }
+      return res;
     }
-    try {
-      s = await import_fs_extra3.default.stat(path2);
-    } catch (_e) {
-      path2 = `${file}.js`;
-      try {
-        s = await import_fs_extra3.default.stat(path2);
-      } catch (_e2) {
-        debug(`Ignoring invalid file ${file}`);
-        return null;
+    var asAbsolute = function(path, parent) {
+      if (path[0] === "/") {
+        return path;
       }
+      return (0, import_path.resolve)(parent, path);
+    };
+    async function staticFiles(path, { src }, output) {
+      const { debug, time } = output;
+      let files = [];
+      const source = src || ".";
+      const search = (0, import_path.resolve)(path, source);
+      const { ig } = await (0, import_client.getVercelIgnore)(path);
+      const filter = ig.createFilter();
+      const prefixLength = path.length + 1;
+      const accepts = (file) => {
+        const relativePath = file.slice(prefixLength);
+        if (relativePath === "") {
+          return true;
+        }
+        const accepted = filter(relativePath);
+        if (!accepted) {
+          debug(`Ignoring ${file}`);
+        }
+        return accepted;
+      };
+      files = await time(
+        `Locating files ${path}`,
+        explode([search], {
+          accepts,
+          output
+        })
+      );
+      return Array.from(new Set(files));
     }
-    if (s.isDirectory()) {
-      let all;
-      try {
-        all = await import_fs_extra3.default.readdir(file);
-      } catch (err) {
-        const code = err instanceof Error && "code" in err ? err.code : void 0;
-        if (code === "ENOENT" || code === "ENOTDIR") {
-          debug(`Ignoring directory that has since been removed ${file}`);
+    async function explode(paths, { accepts, output }) {
+      const { debug } = output;
+      const list = async (file) => {
+        let path = file;
+        let s;
+        if (!accepts(file)) {
           return null;
         }
-        throw err;
-      }
-      const recursive = many(all.map((subdir) => asAbsolute(subdir, file)));
-      return recursive;
+        try {
+          s = await import_fs_extra.default.stat(path);
+        } catch (_e) {
+          path = `${file}.js`;
+          try {
+            s = await import_fs_extra.default.stat(path);
+          } catch (_e2) {
+            debug(`Ignoring invalid file ${file}`);
+            return null;
+          }
+        }
+        if (s.isDirectory()) {
+          let all;
+          try {
+            all = await import_fs_extra.default.readdir(file);
+          } catch (err) {
+            const code = err instanceof Error && "code" in err ? err.code : void 0;
+            if (code === "ENOENT" || code === "ENOTDIR") {
+              debug(`Ignoring directory that has since been removed ${file}`);
+              return null;
+            }
+            throw err;
+          }
+          return many(all.map((subdir) => asAbsolute(subdir, file)));
+        }
+        if (!s.isFile()) {
+          debug(`Ignoring special file ${file}`);
+          return null;
+        }
+        return path;
+      };
+      const many = (all) => Promise.all(all.map((file) => list(file)));
+      const arrayOfArrays = await many(paths);
+      return flatten(arrayOfArrays).filter(notNull);
     }
-    if (!s.isFile()) {
-      debug(`Ignoring special file ${file}`);
-      return null;
+    function notNull(value) {
+      return value !== null;
     }
-    return path2;
-  };
-  const many = (all) => Promise.all(all.map((file) => list(file)));
-  const arrayOfArrays = await many(paths);
-  return flatten(arrayOfArrays).filter(notNull);
-}
-function notNull(value) {
-  return value !== null;
-}
-
-// src/util/service-schedules.ts
-var DYNAMIC_SCHEDULE = "<dynamic>";
-function getStaticServiceSchedules(schedule) {
-  if (!schedule || schedule === DYNAMIC_SCHEDULE) {
-    return [];
   }
-  return Array.isArray(schedule) ? schedule.filter((item) => item !== DYNAMIC_SCHEDULE) : [schedule];
-}
+});
+
+// src/builders/write-build-result.ts
+var import_write_build_result = __toESM(require_write_build_result(), 1);
+var {
+  filesWithoutFsRefs,
+  relocateRootBuildOutputToService,
+  writeBuildResult
+} = (0, import_write_build_result.createWriteBuildResult)(output_manager_default);
 
 export {
+  require_detect_builders_with_services,
   require_mime_types,
-  OUTPUT_DIR,
-  writeBuildResult,
-  isLambda,
-  staticFiles,
-  getStaticServiceSchedules
+  require_write_build_result,
+  require_service_schedules,
+  require_get_files,
+  import_write_build_result,
+  writeBuildResult
 };
 /*! Bundled license information: