@vercel/python 6.24.0 → 6.25.0

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs10.stat(path, function(er, stat) {
+      fs11.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs10.statSync(path), path, options);
+      return checkStat(fs11.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     function isexe(path, options, cb) {
-      fs10.stat(path, function(er, stat) {
+      fs11.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs10.statSync(path), options);
+      return checkStat(fs11.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs10.openSync(command, "r");
-        fs10.readSync(fd, buffer, 0, size, 0);
-        fs10.closeSync(fd);
+        fd = fs11.openSync(command, "r");
+        fs11.readSync(fd, buffer, 0, size, 0);
+        fs11.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug11;
+    var debug12;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug11 = function() {
+      debug12 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug11 = function() {
+      debug12 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,7 +540,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug11(i, src[i]);
+      debug12(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug11("SemVer", version2, options);
+      debug12("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -654,7 +654,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug11("SemVer.compare", this.version, this.options, other);
+      debug12("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug11("prerelease compare", i2, a, b);
+        debug12("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug11("comparator", comp, options);
+      debug12("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -944,7 +944,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug11("comp", this);
+      debug12("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -967,7 +967,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug11("Comparator.test", version2, this.options.loose);
+      debug12("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug11("hyphen replace", range);
+      debug12("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug11("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug12("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1092,15 +1092,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug11("comp", comp, options);
+      debug12("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug11("caret", comp);
+      debug12("caret", comp);
       comp = replaceTildes(comp, options);
-      debug11("tildes", comp);
+      debug12("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug11("xrange", comp);
+      debug12("xrange", comp);
       comp = replaceStars(comp, options);
-      debug11("stars", comp);
+      debug12("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1114,7 +1114,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug11("tilde", comp, _, M, m, p, pr);
+        debug12("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1123,12 +1123,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug11("replaceTilde pr", pr);
+          debug12("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug11("tilde return", ret);
+        debug12("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug11("caret", comp, options);
+      debug12("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug11("caret", comp, _, M, m, p, pr);
+        debug12("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1154,7 +1154,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug11("replaceCaret pr", pr);
+          debug12("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1165,7 +1165,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug11("no pr");
+          debug12("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1176,12 +1176,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug11("caret return", ret);
+        debug12("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug11("replaceXRanges", comp, options);
+      debug12("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1190,7 +1190,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug11("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug12("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1233,12 +1233,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug11("xRange return", ret);
+        debug12("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug11("replaceStars", comp, options);
+      debug12("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1286,7 +1286,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug11(set[i2].semver);
+          debug12(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs10;
+    var fs11;
     try {
-      fs10 = require("fs");
+      fs11 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs10)
+      if (!fs11)
         return false;
-      return (stream instanceof (fs10.ReadStream || noop) || stream instanceof (fs10.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs11.ReadStream || noop) || stream instanceof (fs11.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2674,27 +2674,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
     "use strict";
-    var fs10 = require("fs");
+    var fs11 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync2 = (path) => {
-      const fd = fs10.openSync(path, "r");
+      const fd = fs11.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs10.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs10.close(fd, () => {
+      const bytesRead = fs11.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs11.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
     var readFile2 = (path) => new Promise((resolve3, reject) => {
-      fs10.open(path, "r", (err, fd) => {
+      fs11.open(path, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs10.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs11.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs10.close(fd, () => {
+            fs11.close(fd, () => {
             });
           });
         }
@@ -3005,7 +3005,7 @@ var require_detect_libc = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join12, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join13, delimiter: delimiter2, sep: sep2, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -3034,7 +3034,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join12(pathPart, cmd);
+      return prefix + join13(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -3213,6 +3213,7 @@ var src_exports = {};
 __export(src_exports, {
   build: () => build,
   defaultShouldServe: () => defaultShouldServe,
+  diagnostics: () => diagnostics,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
@@ -3222,15 +3223,15 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs10 = __toESM(require("fs"));
-var import_path12 = require("path");
+var import_fs11 = __toESM(require("fs"));
+var import_path13 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.9.0";
-var VERCEL_WORKERS_VERSION = "0.0.12";
+var VERCEL_RUNTIME_VERSION = "0.10.0";
+var VERCEL_WORKERS_VERSION = "0.0.13";
 
 // src/index.ts
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -4661,19 +4662,261 @@ async function calculatePerPackageSizes(venvPath) {
   return sizes;
 }
 
+// src/diagnostics.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path7 = require("path");
+var import_build_utils6 = require("@vercel/build-utils");
+var import_python_analysis4 = require("@vercel/python-analysis");
+var MANIFEST_FILENAME = "package-manifest.json";
+var DIAGNOSTICS_PATH = (0, import_path7.join)(".vercel", "python", MANIFEST_FILENAME);
+var MANIFEST_VERSION = "20260304";
+function isDependencyGroupInclude(entry) {
+  return typeof entry === "object" && "include-group" in entry;
+}
+function resolveDependencyGroup(groupName, allGroups, ancestors = /* @__PURE__ */ new Set()) {
+  if (ancestors.has(groupName))
+    return [];
+  const entries = allGroups[groupName];
+  if (!Array.isArray(entries))
+    return [];
+  ancestors.add(groupName);
+  const result = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      result.push(entry);
+    } else if (isDependencyGroupInclude(entry)) {
+      result.push(
+        ...resolveDependencyGroup(entry["include-group"], allGroups, ancestors)
+      );
+    }
+  }
+  ancestors.delete(groupName);
+  return result;
+}
+function mapSource(src) {
+  if (!src)
+    return {};
+  if (src.virtual)
+    return {};
+  if (src.registry) {
+    try {
+      const url = new URL(src.registry);
+      return { source: "registry", sourceUrl: url.origin };
+    } catch {
+      return { source: "registry", sourceUrl: src.registry };
+    }
+  }
+  if (src.git)
+    return { source: "git", sourceUrl: src.git };
+  if (src.url)
+    return { source: "url", sourceUrl: src.url };
+  if (src.editable)
+    return { source: "editable", sourceUrl: src.editable };
+  if (src.path)
+    return { source: "path", sourceUrl: src.path };
+  return {};
+}
+async function generateProjectManifest({
+  workPath,
+  pythonPackage,
+  pythonVersion,
+  uvLockPath
+}) {
+  const resolved = pythonVersionString(pythonVersion);
+  const constraint = pythonPackage.requiresPython?.[0];
+  const requested = constraint?.specifier;
+  const project = pythonPackage.manifest?.data?.project;
+  const pyprojectData = pythonPackage.manifest?.data;
+  const directScopesMap = /* @__PURE__ */ new Map();
+  const directRequested = /* @__PURE__ */ new Map();
+  const allRawDeps = [];
+  if (project?.dependencies && Array.isArray(project.dependencies)) {
+    for (const dep of project.dependencies) {
+      allRawDeps.push({ dep, scope: "main" });
+    }
+  }
+  const optDeps = project?.["optional-dependencies"];
+  if (optDeps) {
+    for (const [group, deps] of Object.entries(optDeps)) {
+      if (Array.isArray(deps)) {
+        for (const dep of deps) {
+          allRawDeps.push({ dep, scope: group });
+        }
+      }
+    }
+  }
+  const depGroups = pyprojectData?.["dependency-groups"];
+  if (depGroups) {
+    for (const group of Object.keys(depGroups)) {
+      const groupDeps = resolveDependencyGroup(group, depGroups);
+      for (const dep of groupDeps) {
+        allRawDeps.push({ dep, scope: group });
+      }
+    }
+  }
+  const uvDevDeps = pyprojectData?.tool?.uv?.["dev-dependencies"];
+  if (uvDevDeps && Array.isArray(uvDevDeps)) {
+    for (const dep of uvDevDeps) {
+      allRawDeps.push({ dep, scope: "dev" });
+    }
+  }
+  const allParsed = await (0, import_python_analysis4.parsePep508)(allRawDeps.map((d) => d.dep));
+  for (let i = 0; i < allRawDeps.length; i++) {
+    const parsed = allParsed[i];
+    if (!parsed)
+      continue;
+    const { dep, scope } = allRawDeps[i];
+    const normalized = (0, import_python_analysis4.normalizePackageName)(parsed.name);
+    let scopes = directScopesMap.get(normalized);
+    if (!scopes) {
+      scopes = /* @__PURE__ */ new Set();
+      directScopesMap.set(normalized, scopes);
+    }
+    scopes.add(scope);
+    if (!directRequested.has(normalized)) {
+      directRequested.set(normalized, dep);
+    }
+  }
+  const directEntries = [];
+  const transitiveEntries = [];
+  {
+    const content = await import_fs5.default.promises.readFile(uvLockPath, "utf-8");
+    const uvLock = (0, import_python_analysis4.parseUvLock)(content, uvLockPath);
+    const projectName = project?.name;
+    const excludeSet = new Set(
+      projectName ? [(0, import_python_analysis4.normalizePackageName)(projectName)] : []
+    );
+    const lockMap = /* @__PURE__ */ new Map();
+    const depGraph = /* @__PURE__ */ new Map();
+    for (const pkg of uvLock.packages) {
+      const normalized = (0, import_python_analysis4.normalizePackageName)(pkg.name);
+      if (excludeSet.has(normalized))
+        continue;
+      if (pkg.source?.virtual)
+        continue;
+      lockMap.set(normalized, { version: pkg.version, source: pkg.source });
+      if (pkg.dependencies) {
+        const deps = /* @__PURE__ */ new Set();
+        for (const d of pkg.dependencies) {
+          deps.add((0, import_python_analysis4.normalizePackageName)(d.name));
+        }
+        depGraph.set(normalized, deps);
+      }
+    }
+    const transitiveScopesMap = /* @__PURE__ */ new Map();
+    for (const [name, scopes] of directScopesMap) {
+      const queue = [name];
+      let head = 0;
+      const visited = /* @__PURE__ */ new Set();
+      while (head < queue.length) {
+        const current = queue[head++];
+        if (visited.has(current))
+          continue;
+        visited.add(current);
+        const children = depGraph.get(current);
+        if (!children)
+          continue;
+        for (const child of children) {
+          if (excludeSet.has(child))
+            continue;
+          if (!directScopesMap.has(child)) {
+            let childScopes = transitiveScopesMap.get(child);
+            if (!childScopes) {
+              childScopes = /* @__PURE__ */ new Set();
+              transitiveScopesMap.set(child, childScopes);
+            }
+            for (const s of scopes) {
+              childScopes.add(s);
+            }
+          }
+          if (!visited.has(child)) {
+            queue.push(child);
+          }
+        }
+      }
+    }
+    for (const [name, scopes] of directScopesMap) {
+      const info = lockMap.get(name);
+      const entry = {
+        name,
+        type: "direct",
+        scopes: [...scopes].sort(),
+        requested: directRequested.get(name)
+      };
+      if (info) {
+        entry.resolved = info.version;
+        const src = mapSource(info.source);
+        if (src.source)
+          entry.source = src.source;
+        if (src.sourceUrl)
+          entry.sourceUrl = src.sourceUrl;
+      }
+      directEntries.push(entry);
+    }
+    for (const [normalized, info] of lockMap) {
+      if (directScopesMap.has(normalized))
+        continue;
+      const scopes = transitiveScopesMap.get(normalized);
+      if (!scopes || scopes.size === 0)
+        continue;
+      const src = mapSource(info.source);
+      transitiveEntries.push({
+        name: normalized,
+        type: "transitive",
+        scopes: [...scopes].sort(),
+        resolved: info.version,
+        ...src.source ? { source: src.source } : {},
+        ...src.sourceUrl ? { sourceUrl: src.sourceUrl } : {}
+      });
+    }
+  }
+  const manifest = {
+    version: MANIFEST_VERSION,
+    runtime: "python",
+    runtimeVersion: {
+      ...requested ? { requested } : {},
+      ...constraint?.source ? { requestedSource: constraint.source } : {},
+      resolved
+    },
+    dependencies: [
+      ...directEntries.sort((a, b) => a.name.localeCompare(b.name)),
+      ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
+    ]
+  };
+  const outPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
+  await import_fs5.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
+  await import_fs5.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
+}
+var diagnostics = async ({
+  workPath
+}) => {
+  try {
+    const manifestPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
+    const data = await import_fs5.default.promises.readFile(manifestPath, "utf-8");
+    return {
+      [MANIFEST_FILENAME]: new import_build_utils6.FileBlob({ data })
+    };
+  } catch (err) {
+    (0, import_build_utils6.debug)(
+      `Diagnostics: no cached manifest found: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return {};
+  }
+};
+
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs6 = require("fs");
-var import_path8 = require("path");
-var import_build_utils8 = require("@vercel/build-utils");
+var import_fs7 = require("fs");
+var import_path9 = require("path");
+var import_build_utils9 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
 // src/entrypoint.ts
-var import_fs5 = __toESM(require("fs"));
-var import_path7 = require("path");
-var import_build_utils6 = require("@vercel/build-utils");
+var import_fs6 = __toESM(require("fs"));
+var import_path8 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -4689,26 +4932,26 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path7.posix.join(dir, `${filename}.py`)
+      (filename) => import_path8.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs5.default.promises.stat(filePath);
+    const stat = await import_fs6.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
   }
 }
 async function checkEntrypoint(workPath, relPath) {
-  const absPath = (0, import_path7.join)(workPath, relPath);
+  const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return false;
-  return (0, import_build_utils6.isPythonEntrypoint)({ fsPath: absPath });
+  return (0, import_build_utils7.isPythonEntrypoint)({ fsPath: absPath });
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils8.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -4719,30 +4962,32 @@ async function getPyprojectEntrypoint(workPath) {
   if (!match)
     return null;
   const modulePath = match[1];
+  const variableName = match[2];
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
-    if (await fileExists((0, import_path7.join)(workPath, candidate)))
-      return candidate;
+    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+      return { entrypoint: candidate, variableName };
+    }
   }
   return null;
 }
 async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
     if (await checkEntrypoint(workPath, candidate)) {
-      (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
+      (0, import_build_utils7.debug)(`Detected Python entrypoint: ${candidate}`);
       return candidate;
     }
   }
   return null;
 }
 async function checkDjangoManage(workPath) {
-  const managePath = (0, import_path7.join)(workPath, "manage.py");
+  const managePath = (0, import_path8.join)(workPath, "manage.py");
   try {
-    const content = await import_fs5.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils6.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils7.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -4750,7 +4995,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs5.default.promises.readdir(workPath, {
+    const entries = await import_fs6.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -4762,7 +5007,7 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
     if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
       return { entrypoint: entry };
     }
     const found = await findValidEntrypoint(
@@ -4771,7 +5016,7 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils7.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
@@ -4779,13 +5024,13 @@ async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
     if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
       return { entrypoint: entry };
     }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path7.join)(workPath, rootDir);
+      const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
         return { baseDir: rootDir };
@@ -4795,7 +5040,7 @@ async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils7.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
@@ -4804,11 +5049,16 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
+  if (!pyprojectEntry)
+    return null;
+  return {
+    entrypoint: pyprojectEntry.entrypoint,
+    variableName: pyprojectEntry.variableName
+  };
 }
 
 // src/start-dev-server.ts
-var import_python_analysis4 = require("@vercel/python-analysis");
+var import_python_analysis5 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
@@ -4835,6 +5085,10 @@ function silenceNodeWarnings() {
   };
 }
 var DEV_SHIM_MODULE = "vc_init_dev";
+function hasWorkerServicesEnabled(env) {
+  const value = env.VERCEL_HAS_WORKER_SERVICES || "";
+  return ["1", "true"].includes(value.trim().toLowerCase());
+}
 function createLogListener(callback, stream) {
   return (buf) => {
     if (callback) {
@@ -4890,17 +5144,17 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils8.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils9.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path8.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs6.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path8.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis4.stringifyManifest)(manifest.data);
-    (0, import_fs6.writeFileSync)(tempPyproject, content, "utf8");
+    const syncDir = (0, import_path9.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs7.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis5.stringifyManifest)(manifest.data);
+    (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils8.debug)(
+    (0, import_build_utils9.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -4933,7 +5187,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils8.NowBuildError({
+    throw new import_build_utils9.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -4948,14 +5202,14 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path8.dirname)(manifestPath);
+  const projectDir = (0, import_path9.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils8.NowBuildError({
+        throw new import_build_utils9.NowBuildError({
           code: "PYTHON_DEPENDENCY_SYNC_FAILED",
           message: "uv is required to install dependencies from uv.lock.",
           link: "https://docs.astral.sh/uv/getting-started/installation/",
@@ -4977,11 +5231,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils8.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils9.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils8.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils9.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -5016,6 +5270,7 @@ async function runSync({
   });
 }
 var PENDING_RUNTIME_INSTALLS = /* @__PURE__ */ new Map();
+var PENDING_WORKERS_INSTALLS = /* @__PURE__ */ new Map();
 async function installVercelRuntime({
   workPath,
   uvPath,
@@ -5024,7 +5279,7 @@ async function installVercelRuntime({
   onStdout,
   onStderr
 }) {
-  const targetDir = (0, import_path8.join)(workPath, ".vercel", "python");
+  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
   let pending = PENDING_RUNTIME_INSTALLS.get(targetDir);
   if (!pending) {
     pending = doInstallVercelRuntime({
@@ -5050,8 +5305,8 @@ async function doInstallVercelRuntime({
   onStdout,
   onStderr
 }) {
-  (0, import_fs6.mkdirSync)(targetDir, { recursive: true });
-  const localRuntimeDir = (0, import_path8.join)(
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  const localRuntimeDir = (0, import_path9.join)(
     __dirname,
     "..",
     "..",
@@ -5059,21 +5314,21 @@ async function doInstallVercelRuntime({
     "python",
     "vercel-runtime"
   );
-  const isLocalDev = (0, import_fs6.existsSync)((0, import_path8.join)(localRuntimeDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
   const runtimeDep = env.VERCEL_RUNTIME_PYTHON || (isLocalDev ? localRuntimeDir : `vercel-runtime==${VERCEL_RUNTIME_VERSION}`);
   if (!isLocalDev && !env.VERCEL_RUNTIME_PYTHON) {
-    const distInfo = (0, import_path8.join)(
+    const distInfo = (0, import_path9.join)(
       targetDir,
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
-    if ((0, import_fs6.existsSync)(distInfo)) {
-      (0, import_build_utils8.debug)(
+    if ((0, import_fs7.existsSync)(distInfo)) {
+      (0, import_build_utils9.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils8.debug)(
+  (0, import_build_utils9.debug)(
     `Installing vercel-runtime into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${runtimeDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -5088,14 +5343,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils8.debug)(data.toString());
+        (0, import_build_utils9.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils8.debug)(data.toString());
+        (0, import_build_utils9.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5112,6 +5367,102 @@ async function doInstallVercelRuntime({
     });
   });
 }
+async function installVercelWorkers({
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
+  let pending = PENDING_WORKERS_INSTALLS.get(targetDir);
+  if (!pending) {
+    pending = doInstallVercelWorkers({
+      targetDir,
+      workPath,
+      uvPath,
+      pythonBin,
+      env,
+      onStdout,
+      onStderr
+    });
+    PENDING_WORKERS_INSTALLS.set(targetDir, pending);
+    pending.finally(() => PENDING_WORKERS_INSTALLS.delete(targetDir));
+  }
+  await pending;
+}
+async function doInstallVercelWorkers({
+  targetDir,
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  const localWorkersDir = (0, import_path9.join)(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "python",
+    "vercel-workers"
+  );
+  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
+  const workersDep = env.VERCEL_WORKERS_PYTHON || (isLocalDev ? localWorkersDir : `vercel-workers==${VERCEL_WORKERS_VERSION}`);
+  if (!isLocalDev && !env.VERCEL_WORKERS_PYTHON) {
+    const distInfo = (0, import_path9.join)(
+      targetDir,
+      `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
+    );
+    if ((0, import_fs7.existsSync)(distInfo)) {
+      (0, import_build_utils9.debug)(
+        `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
+      );
+      return;
+    }
+  }
+  (0, import_build_utils9.debug)(
+    `Installing vercel-workers into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${workersDep})`
+  );
+  const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
+  const spawnArgs = [...pip.prefix, "--target", targetDir, workersDep];
+  await new Promise((resolve3, reject) => {
+    const child = (0, import_child_process2.spawn)(pip.cmd, spawnArgs, {
+      cwd: workPath,
+      env: getProtectedUvEnv(env),
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      if (onStdout) {
+        onStdout(data);
+      } else {
+        (0, import_build_utils9.debug)(data.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (onStderr) {
+        onStderr(data);
+      } else {
+        (0, import_build_utils9.debug)(data.toString());
+      }
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(
+          new Error(
+            `Installing vercel-workers failed with code ${code}, signal ${signal}`
+          )
+        );
+      }
+    });
+  });
+}
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var restoreWarnings = null;
@@ -5125,12 +5476,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils9.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils9.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -5138,7 +5489,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils9.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -5153,52 +5504,52 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevShim(workPath, entry, modulePath, serviceName, framework) {
+function createDevShim(workPath, entry, modulePath, serviceName, framework, variableName) {
   try {
-    const vercelPythonDir = serviceName ? (0, import_path8.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path8.join)(workPath, ".vercel", "python");
-    (0, import_fs6.mkdirSync)(vercelPythonDir, { recursive: true });
+    const vercelPythonDir = serviceName ? (0, import_path9.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path9.join)(workPath, ".vercel", "python");
+    (0, import_fs7.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs6.existsSync)((0, import_path8.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path8.basename)(workPath);
+    if ((0, import_fs7.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path9.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path8.dirname)(workPath);
+      extraPythonPath = (0, import_path9.dirname)(workPath);
     }
-    const entryAbs = (0, import_path8.join)(workPath, entry);
-    const shimPath = (0, import_path8.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path8.join)(
+    const entryAbs = (0, import_path9.join)(workPath, entry);
+    const shimPath = (0, import_path9.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path9.join)(
       __dirname,
       "..",
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs6.readFileSync)(templatePath, "utf8");
-    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework);
-    (0, import_fs6.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
+    const template = (0, import_fs7.readFileSync)(templatePath, "utf8");
+    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework).replace(/__VC_DEV_VARIABLE_NAME__/g, variableName);
+    (0, import_fs7.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils9.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils8.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils9.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
   const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
   if (venvRoot) {
-    (0, import_build_utils8.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils9.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path8.join)(workPath, ".venv");
+  const venvPath = (0, import_path9.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils9.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path8.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path9.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -5243,6 +5594,7 @@ var startDevServer = async (opts) => {
   const env = { ...process.env, ...meta.env || {} };
   const serviceType = env.VERCEL_SERVICE_TYPE;
   let entry;
+  let variableName;
   if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
     entry = rawEntrypoint;
   } else {
@@ -5252,19 +5604,21 @@ var startDevServer = async (opts) => {
       rawEntrypoint
     );
     entry = detected?.entrypoint;
+    variableName = detected?.variableName;
     if (!entry) {
       const hookResult = await runFrameworkHook(framework, {
         pythonEnv: env,
-        projectDir: (0, import_path8.join)(workPath, detected?.baseDir ?? ""),
+        projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
         workPath,
         entrypoint: rawEntrypoint,
         detected: detected ?? void 0
       });
       entry = hookResult?.entrypoint;
+      variableName = hookResult?.variableName;
     }
     if (!entry) {
       const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils9.NowBuildError({
         code: "PYTHON_ENTRYPOINT_NOT_FOUND",
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
@@ -5295,7 +5649,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils9.NowBuildError({
         code: "PYTHON_EXTERNAL_VENV_DETECTED",
         message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
 Run ${white}deactivate${reset} and try again.`
@@ -5312,11 +5666,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils8.debug)(
+      (0, import_build_utils9.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils8.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils9.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -5325,9 +5679,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils8.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils9.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils8.debug)("No virtualenv found");
+        (0, import_build_utils9.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -5366,24 +5720,35 @@ If you are using a virtual environment, activate it before running "vercel dev",
       pythonBin: spawnCommand,
       env
     });
+    if (hasWorkerServicesEnabled(env)) {
+      await installVercelWorkers({
+        workPath,
+        uvPath,
+        pythonBin: spawnCommand,
+        env,
+        onStdout,
+        onStderr
+      });
+    }
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
     if (config.handlerFunction && typeof config?.handlerFunction === "string") {
       env.__VC_HANDLER_FUNC_NAME = config.handlerFunction;
     }
     if (entry) {
-      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path8.join)(workPath, entry);
+      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path9.join)(workPath, entry);
     }
     const devShim = createDevShim(
       workPath,
       entry,
       modulePath,
       serviceName,
-      framework
+      framework,
+      variableName ?? ""
     );
     if (devShim) {
-      const shimDir = devShim.shimDir || (0, import_path8.join)(workPath, ".vercel", "python");
-      const runtimeDir = (0, import_path8.join)(workPath, ".vercel", "python");
+      const shimDir = devShim.shimDir || (0, import_path9.join)(workPath, ".vercel", "python");
+      const runtimeDir = (0, import_path9.join)(workPath, ".vercel", "python");
       const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
@@ -5392,12 +5757,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path8.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path9.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils8.debug)(
+    (0, import_build_utils9.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -5451,8 +5816,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils11 = require("@vercel/build-utils");
-var import_python_analysis6 = require("@vercel/python-analysis");
+var import_build_utils12 = require("@vercel/build-utils");
+var import_python_analysis7 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -5465,9 +5830,9 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path9 = require("path");
-var import_build_utils9 = require("@vercel/build-utils");
+var import_fs8 = __toESM(require("fs"));
+var import_path10 = require("path");
+var import_build_utils10 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -5477,9 +5842,9 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path9.join)(workPath, name);
+    const candidate = (0, import_path10.join)(workPath, name);
     try {
-      await import_fs7.default.promises.access(candidate);
+      await import_fs8.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -5494,32 +5859,32 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path9.join)(
+      const schemaPath = (0, import_path10.join)(
         sitePackages,
         "litellm",
         "proxy",
         "schema.prisma"
       );
       try {
-        await import_fs7.default.promises.access(schemaPath);
-        (0, import_build_utils9.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        await import_fs8.default.promises.access(schemaPath);
+        (0, import_build_utils10.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils9.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils10.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
     }
     if (!process.env.CONFIG_FILE_PATH) {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
-        (0, import_build_utils9.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path9.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path9.join)(LAMBDA_ROOT, configName);
+        (0, import_build_utils10.debug)(`LiteLLM quirk: found config at ${configName}`);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path10.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path10.join)(LAMBDA_ROOT, configName);
       }
     } else {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -5528,11 +5893,11 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path10 = require("path");
+var import_fs9 = __toESM(require("fs"));
+var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils10 = require("@vercel/build-utils");
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_build_utils11 = require("@vercel/build-utils");
+var import_python_analysis6 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -5569,22 +5934,22 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path10.isAbsolute)(envPath) ? envPath : (0, import_path10.join)(workPath, envPath);
+    const resolved = (0, import_path11.isAbsolute)(envPath) ? envPath : (0, import_path11.join)(workPath, envPath);
     try {
-      await import_fs8.default.promises.access(resolved);
+      await import_fs9.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils10.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils11.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
   const candidates = [
-    (0, import_path10.join)(workPath, "schema.prisma"),
-    (0, import_path10.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path11.join)(workPath, "schema.prisma"),
+    (0, import_path11.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs8.default.promises.access(candidate);
+      await import_fs9.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -5595,32 +5960,32 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs8.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs9.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path10.join)(dir, entry.name);
+    const full = (0, import_path11.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path10.relative)(base, full));
+      result.push((0, import_path11.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path10.join)(cacheDir, "node_modules"),
-    (0, import_path10.join)(cacheDir, "package.json"),
-    (0, import_path10.join)(cacheDir, "package-lock.json"),
+    (0, import_path11.join)(cacheDir, "node_modules"),
+    (0, import_path11.join)(cacheDir, "package.json"),
+    (0, import_path11.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
     try {
-      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -5644,7 +6009,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path10.join)(
+    const runtimeCacheDir = (0, import_path11.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -5654,7 +6019,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs8.default.promises.access((0, import_path10.join)(dir, "prisma"));
+        await import_fs9.default.promises.access((0, import_path11.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -5666,19 +6031,19 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path10.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs8.default.promises.mkdir(cacheDir, { recursive: true });
+    const cacheDir = (0, import_path11.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs9.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path10.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path10.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs8.default.promises.writeFile(
+    const generatedDir = (0, import_path11.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path11.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs9.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils10.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils11.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa4.default)(
         pythonPath,
@@ -5690,11 +6055,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils10.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils11.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils10.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils11.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: "PRISMA_GENERATE_FAILED",
         message: `Prisma engine download failed during \`prisma generate\`. Check that your prisma version is compatible with this Python version.
 ` + execErrorMessage(err)
@@ -5702,47 +6067,47 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path10.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path11.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs8.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs9.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path10.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path10.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path11.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
-          await import_fs8.default.promises.access(destPath);
-          (0, import_build_utils10.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          await import_fs9.default.promises.access(destPath);
+          (0, import_build_utils11.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils10.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs8.default.promises.copyFile(srcPath, destPath);
+          (0, import_build_utils11.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          await import_fs9.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not read Prisma engine directory "${nodeModulesDir}". This may indicate an incompatible prisma version.
 ` + (err instanceof Error ? err.message : String(err))
       });
     }
     if (!engineCopied) {
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
     }
-    const shimPath = (0, import_path10.join)(cacheDir, "openssl");
-    await import_fs8.default.promises.writeFile(
+    const shimPath = (0, import_path11.join)(cacheDir, "openssl");
+    await import_fs9.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs8.default.promises.chmod(shimPath, 493);
+    await import_fs9.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -5755,14 +6120,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils10.debug)(
+          (0, import_build_utils11.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils10.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils11.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa4.default)(
             pythonPath,
@@ -5774,11 +6139,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils10.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils11.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils10.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils11.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils10.NowBuildError({
+          throw new import_build_utils11.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -5789,12 +6154,12 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path10.join)(sitePackages, "prisma"),
+        (0, import_path11.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis5.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis6.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils10.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils11.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -5817,7 +6182,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis6.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis7.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -5828,7 +6193,7 @@ function toposortQuirks(activated) {
   for (const q of activated) {
     if (q.runsBefore) {
       for (const dep of q.runsBefore) {
-        const target = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -5837,7 +6202,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -5878,23 +6243,23 @@ async function runQuirks(ctx) {
   const installedNames = /* @__PURE__ */ new Set();
   const sitePackageDirs = await getVenvSitePackagesDirs(ctx.venvPath);
   for (const dir of sitePackageDirs) {
-    const distributions = await (0, import_python_analysis6.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis7.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis6.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis7.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis6.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis7.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -5915,12 +6280,12 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path11 = require("path");
+var import_fs10 = __toESM(require("fs"));
+var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils12 = require("@vercel/build-utils");
-var scriptPath = (0, import_path11.join)(__dirname, "..", "templates", "vc_django_settings.py");
-var script = import_fs9.default.readFileSync(scriptPath, "utf-8");
+var import_build_utils13 = require("@vercel/build-utils");
+var scriptPath = (0, import_path12.join)(__dirname, "..", "templates", "vc_django_settings.py");
+var script = import_fs10.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   try {
     const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
@@ -5935,7 +6300,7 @@ async function getDjangoSettings(projectDir, env) {
       djangoSettings: parsed.django_settings
     };
   } catch (err) {
-    (0, import_build_utils12.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
+    (0, import_build_utils13.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
     return null;
   }
 }
@@ -5949,10 +6314,10 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
   const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
   const staticSourceDirs = [
-    ...installedApps.map((app) => (0, import_path11.join)(workPath, ...app.split("."), "static")),
+    ...installedApps.map((app) => (0, import_path12.join)(workPath, ...app.split("."), "static")),
     // TODO: Deal with optional prefixes in STATICFILES_DIRS.
     ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
-  ].filter((d) => import_fs9.default.existsSync(d));
+  ].filter((d) => import_fs10.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
@@ -5963,7 +6328,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     });
     return {
       staticSourceDirs,
-      staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+      staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
       manifestRelPath: null
     };
   }
@@ -5974,9 +6339,9 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     return null;
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
-  const staticOutputDir = (0, import_path11.join)(outputStaticDir, staticUrlPath);
-  await import_fs9.default.promises.mkdir(staticOutputDir, { recursive: true });
-  const shimPath = (0, import_path11.join)(workPath, "_vercel_collectstatic_settings.py");
+  const staticOutputDir = (0, import_path12.join)(outputStaticDir, staticUrlPath);
+  await import_fs10.default.promises.mkdir(staticOutputDir, { recursive: true });
+  const shimPath = (0, import_path12.join)(workPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
     `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
@@ -5984,7 +6349,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs9.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs10.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
     await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
@@ -5995,7 +6360,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
       cwd: workPath
     });
   } finally {
-    await import_fs9.default.promises.unlink(shimPath).catch(() => {
+    await import_fs10.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -6004,24 +6369,24 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   ];
   let manifestRelPath = null;
   if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
-    const manifestSrc = (0, import_path11.join)(staticOutputDir, "staticfiles.json");
-    const resolvedStaticRoot = (0, import_path11.resolve)(workPath, staticRoot);
-    const manifestDest = (0, import_path11.join)(resolvedStaticRoot, "staticfiles.json");
-    await import_fs9.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs9.default.promises.copyFile(manifestSrc, manifestDest);
-    manifestRelPath = (0, import_path11.relative)(workPath, manifestDest);
-    (0, import_build_utils12.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    const manifestSrc = (0, import_path12.join)(staticOutputDir, "staticfiles.json");
+    const resolvedStaticRoot = (0, import_path12.resolve)(workPath, staticRoot);
+    const manifestDest = (0, import_path12.join)(resolvedStaticRoot, "staticfiles.json");
+    await import_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
+    manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
+    (0, import_build_utils13.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
-    staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+    staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
     manifestRelPath
   };
 }
 
 // src/index.ts
-var import_python_analysis7 = require("@vercel/python-analysis");
-var writeFile = import_fs10.default.promises.writeFile;
+var import_python_analysis8 = require("@vercel/python-analysis");
+var writeFile = import_fs11.default.promises.writeFile;
 var version = 3;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -6036,32 +6401,41 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils13.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils14.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
     const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils14.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     if (!settingsResult)
       return;
     const { djangoSettings, settingsModule } = settingsResult;
     let entrypoint;
+    let variableName;
     const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
-      const rel = `${asgiApp.split(".").slice(0, -1).join("/")}.py`;
+      const parts = asgiApp.split(".");
+      variableName = parts.at(-1);
+      const rel = `${parts.slice(0, -1).join("/")}.py`;
       entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils13.debug)(`Django hook: ASGI entrypoint: ${entrypoint}`);
+      (0, import_build_utils14.debug)(
+        `Django hook: ASGI entrypoint: ${entrypoint} (variable: ${variableName})`
+      );
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
       if (typeof wsgiApp === "string") {
-        const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
+        const parts = wsgiApp.split(".");
+        variableName = parts.at(-1);
+        const rel = `${parts.slice(0, -1).join("/")}.py`;
         entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
+        (0, import_build_utils14.debug)(
+          `Django hook: WSGI entrypoint: ${entrypoint} (variable: ${variableName})`
+        );
       }
     }
     let djangoStatic = null;
-    if (venvPath) {
-      const outputStaticDir = (0, import_path12.join)(workPath, ".vercel", "output", "static");
+    if (workPath && venvPath) {
+      const outputStaticDir = (0, import_path13.join)(workPath, ".vercel", "output", "static");
       djangoStatic = await runDjangoCollectStatic(
         venvPath,
         workPath,
@@ -6071,7 +6445,7 @@ var frameworkHooks = {
         djangoSettings
       );
     }
-    return { entrypoint, djangoStatic };
+    return { entrypoint, variableName, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -6080,13 +6454,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils13.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils13.download)(files, workPath, meta);
+  (0, import_build_utils14.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path12.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path12.join)(devCacheDir, (0, import_path12.basename)(entrypoint, ".py"));
-    await (0, import_build_utils13.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils13.glob)("**", destCache);
+    const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path13.join)(devCacheDir, (0, import_path13.basename)(entrypoint, ".py"));
+    await (0, import_build_utils14.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -6098,15 +6472,16 @@ var build = async ({
   entrypoint,
   meta = {},
   config,
-  span: parentSpan
+  span: parentSpan,
+  service
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils13.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils14.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils13.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils14.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -6115,17 +6490,17 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path12.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path13.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils13.glob)("**", workPath);
+  let fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   let detected;
   let entrypointNotFound;
-  if ((0, import_build_utils13.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
+  if ((0, import_build_utils14.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
   (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     detected = await detectPythonEntrypoint(
       config.framework,
@@ -6133,13 +6508,13 @@ var build = async ({
       entrypoint
     ) ?? void 0;
     if (detected?.entrypoint) {
-      (0, import_build_utils13.debug)(
+      (0, import_build_utils14.debug)(
         `Resolved Python entrypoint to "${detected.entrypoint}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected.entrypoint;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      entrypointNotFound = new import_build_utils13.NowBuildError({
+      entrypointNotFound = new import_build_utils14.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -6150,8 +6525,8 @@ var build = async ({
   if (entrypointNotFound && detected?.baseDir === void 0) {
     throw entrypointNotFound;
   }
-  const entryDirectory = detected?.baseDir ?? (0, import_path12.dirname)(entrypoint);
-  const entrypointAbsDir = (0, import_path12.join)(workPath, entryDirectory);
+  const entryDirectory = detected?.baseDir ?? (0, import_path13.dirname)(entrypoint);
+  const entrypointAbsDir = (0, import_path13.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
@@ -6181,22 +6556,22 @@ var build = async ({
 `
     );
   }
-  fsFiles = await (0, import_build_utils13.glob)("**", workPath);
-  const venvPath = (0, import_path12.join)(workPath, ".vercel", "python", ".venv");
+  fsFiles = await (0, import_build_utils14.glob)("**", workPath);
+  const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
       venvPath
     });
   });
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils13.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils13.getEnvForPackageManager)({
+    } = await (0, import_build_utils14.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils14.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -6232,14 +6607,14 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils13.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils14.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils13.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils14.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -6278,15 +6653,15 @@ var build = async ({
       });
     }
   });
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils13.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils14.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils13.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils14.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -6301,7 +6676,7 @@ var build = async ({
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    projectDir: (0, import_path13.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -6316,18 +6691,18 @@ var build = async ({
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils13.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils14.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    projectDir: (0, import_path13.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils13.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils14.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
-      projectDir: (0, import_path12.join)(workPath, entryDirectory),
+      projectDir: (0, import_path13.join)(workPath, entryDirectory),
       args: ["install", workersDep]
     });
   }
@@ -6335,15 +6710,15 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils13.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils14.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
-    const entrypointPath = (0, import_path12.join)(workPath, entrypoint);
-    const source = await import_fs10.default.promises.readFile(entrypointPath, "utf-8");
-    const found = await (0, import_python_analysis7.containsTopLevelCallable)(source, handlerFunction);
+    const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
+    const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
+    const found = await (0, import_python_analysis8.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils13.NowBuildError({
+      throw new import_build_utils14.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -6352,9 +6727,10 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils13.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils14.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerFuncEnvLine = handlerFunction ? `
   "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
+  const variableName = hookResult?.variableName ?? detected?.variableName ?? "";
   const runtimeTrampoline = `
 import importlib
 import os
@@ -6368,7 +6744,8 @@ os.environ.update({
   "__VC_HANDLER_MODULE_NAME": "${moduleName}",
   "__VC_HANDLER_ENTRYPOINT": "${entrypointWithSuffix}",
   "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypointWithSuffix}"),
-  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",${handlerFuncEnvLine}
+  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
+  "__VC_HANDLER_VARIABLE_NAME": "${variableName}",${handlerFuncEnvLine}
 })
 
 _vendor_rel = '${vendorDir}'
@@ -6417,7 +6794,7 @@ from vercel_runtime.vc_init import vc_handler
       ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
     ];
     for (const absDir of dirsToExclude) {
-      const rel = (0, import_path12.relative)(workPath, absDir);
+      const rel = (0, import_path13.relative)(workPath, absDir);
       if (!rel.startsWith("..")) {
         predefinedExcludes.push(`${rel}/**`);
       }
@@ -6426,14 +6803,17 @@ from vercel_runtime.vc_init import vc_handler
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
+  if (shouldInstallVercelWorkers) {
+    lambdaEnv.VERCEL_HAS_WORKER_SERVICES = "1";
+  }
   const globOptions = {
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils13.glob)("**", globOptions);
+  const files = await (0, import_build_utils14.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils13.FileFsRef({
-      fsPath: (0, import_path12.join)(workPath, djangoStatic.manifestRelPath)
+    files[djangoStatic.manifestRelPath] = new import_build_utils14.FileFsRef({
+      fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
   const depExternalizer = new PythonDependencyExternalizer({
@@ -6469,23 +6849,37 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils13.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils14.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils13.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils14.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils13.Lambda({
+  const output = new import_build_utils14.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
     environment: lambdaEnv,
     supportsResponseStreaming: true
   });
+  if (uvLockPath) {
+    try {
+      await generateProjectManifest({
+        workPath,
+        pythonPackage,
+        pythonVersion,
+        uvLockPath
+      });
+    } catch (err) {
+      (0, import_build_utils14.debug)(
+        `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   return { output };
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -6504,7 +6898,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path12.parse)(entrypoint);
+  const { dir, name } = (0, import_path13.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -6517,6 +6911,7 @@ function hasProp(obj, key) {
 0 && (module.exports = {
   build,
   defaultShouldServe,
+  diagnostics,
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,