@vercel/python 6.28.0 → 6.29.0

package/dist/index.js

@@ -3228,11 +3228,11 @@ var import_fs11 = __toESM(require("fs"));
 var import_path13 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.11.0";
+var VERCEL_RUNTIME_VERSION = "0.12.0";
 var VERCEL_WORKERS_VERSION = "0.0.13";
 
 // src/index.ts
-var import_build_utils14 = require("@vercel/build-utils");
+var import_build_utils15 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -5004,7 +5004,7 @@ var diagnostics = async ({
 var import_child_process2 = require("child_process");
 var import_fs7 = require("fs");
 var import_path9 = require("path");
-var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils10 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
@@ -5013,6 +5013,7 @@ 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 import_build_utils9 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
@@ -5049,7 +5050,7 @@ async function checkEntrypoint(workPath, relPath) {
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils8.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -5074,7 +5075,7 @@ async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
     const varName = await checkEntrypoint(workPath, candidate);
     if (varName) {
-      (0, import_build_utils7.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return { entrypoint: candidate, variableName: varName };
     }
   }
@@ -5086,7 +5087,7 @@ async function checkDjangoManage(workPath) {
     const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils7.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5102,55 +5103,78 @@ async function getSubdirectories(workPath) {
     return [];
   }
 }
-async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+function makeDetectError(framework) {
+  const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+  return new import_build_utils7.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`,
+    action: "Learn More"
+  });
+}
+async function detectGenericPythonEntrypoint(workPath) {
   try {
-    const varName = await checkEntrypoint(workPath, entry);
-    if (varName) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: { entrypoint: entry, variableName: varName } };
-    }
     const found = await findValidEntrypoint(
       workPath,
       PYTHON_CANDIDATE_ENTRYPOINTS
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
-async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+async function detectDjangoPythonEntrypoint(workPath) {
   try {
-    const varName = await checkEntrypoint(workPath, entry);
-    if (varName) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: { entrypoint: entry, variableName: varName } };
-    }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
       const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
-        return { baseDir: rootDir };
+        return { baseDir: rootDir, error: makeDetectError("django") };
       }
     }
     const candidates = getCandidateEntrypointsInDirs(rootDirs);
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
-async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
-  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
+  if (configuredEntrypoint) {
+    const entrypoint = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+    let varName = await checkEntrypoint(workPath, entrypoint);
+    if (!varName) {
+      const isSpecialService = service?.type === "cron" || service?.type === "worker";
+      if (isSpecialService) {
+        varName = "app";
+      }
+    }
+    if (varName) {
+      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      return { entrypoint: { entrypoint, variableName: varName } };
+    } else {
+      return {
+        error: new import_build_utils7.NowBuildError({
+          code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+          message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
+          link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
+          action: "Learn More"
+        })
+      };
+    }
+  }
+  if (!framework) {
+    return null;
+  }
+  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath) : await detectGenericPythonEntrypoint(workPath);
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
+  return pyprojectEntry ? { entrypoint: pyprojectEntry } : { error: makeDetectError(framework) };
 }
 
 // src/start-dev-server.ts
@@ -5240,7 +5264,7 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils9.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils10.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
@@ -5250,7 +5274,7 @@ async function syncDependencies({
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
     (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -5283,7 +5307,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils9.NowBuildError({
+    throw new import_build_utils10.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -5305,7 +5329,7 @@ async function runSync({
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils9.NowBuildError({
+        throw new import_build_utils10.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/",
@@ -5327,11 +5351,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils9.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils10.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils9.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils10.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -5418,13 +5442,13 @@ async function doInstallVercelRuntime({
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.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"] };
@@ -5439,14 +5463,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5514,13 +5538,13 @@ async function doInstallVercelWorkers({
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.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"] };
@@ -5535,14 +5559,14 @@ async function doInstallVercelWorkers({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5572,12 +5596,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -5585,7 +5609,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils10.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -5622,26 +5646,26 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
     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}`);
+    (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils9.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils10.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_utils9.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils10.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path9.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils9.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils10.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
@@ -5654,11 +5678,12 @@ var startDevServer = async (opts) => {
     workPath,
     meta = {},
     config,
+    service,
     onStdout,
     onStderr
   } = opts;
   const framework = config?.framework;
-  const serviceName = typeof meta.serviceName === "string" ? meta.serviceName : void 0;
+  const serviceName = service?.name ?? (typeof meta.serviceName === "string" ? meta.serviceName : void 0);
   const serverKey = serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
@@ -5688,37 +5713,34 @@ var startDevServer = async (opts) => {
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
   const env = { ...process.env, ...meta.env || {} };
-  const serviceType = env.VERCEL_SERVICE_TYPE;
+  const entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
   let resolved;
-  if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
-    resolved = { entrypoint: rawEntrypoint, variableName: "app" };
+  const detected = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    entrypoint,
+    service
+  );
+  if (detected?.entrypoint) {
+    resolved = detected.entrypoint;
   } else {
-    const detected = await detectPythonEntrypoint(
-      framework,
+    const hookResult = await runFrameworkHook(framework, {
+      pythonEnv: env,
+      projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
       workPath,
-      rawEntrypoint
-    );
-    if (detected?.entrypoint) {
-      resolved = detected.entrypoint;
-    } else {
-      const hookResult = await runFrameworkHook(framework, {
-        pythonEnv: env,
-        projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
-        workPath,
-        entrypoint: rawEntrypoint,
-        detected: detected ?? void 0
-      });
-      resolved = hookResult?.entrypoint;
-    }
-    if (!resolved) {
-      const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      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`,
-        action: "Learn More"
-      });
+      entrypoint,
+      detected: detected ?? void 0
+    });
+    resolved = hookResult?.entrypoint;
+  }
+  if (!resolved) {
+    if (detected?.error) {
+      throw detected.error;
     }
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
   }
   const { entrypoint: entry, variableName } = resolved;
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
@@ -5744,7 +5766,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils9.NowBuildError({
+      throw new import_build_utils10.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.`
@@ -5761,11 +5783,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils9.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils10.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -5774,9 +5796,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils9.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils10.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils9.debug)("No virtualenv found");
+        (0, import_build_utils10.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -5857,7 +5879,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -5911,7 +5933,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils12 = require("@vercel/build-utils");
+var import_build_utils13 = require("@vercel/build-utils");
 var import_python_analysis8 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
@@ -5927,7 +5949,7 @@ var matplotlibQuirk = {
 // src/quirks/litellm.ts
 var import_fs8 = __toESM(require("fs"));
 var import_path10 = require("path");
-var import_build_utils10 = require("@vercel/build-utils");
+var import_build_utils11 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -5962,24 +5984,24 @@ var litellmQuirk = {
       );
       try {
         await import_fs8.default.promises.access(schemaPath);
-        (0, import_build_utils10.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils10.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils11.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_utils10.debug)(`LiteLLM quirk: found config at ${configName}`);
+        (0, import_build_utils11.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_utils10.debug)(
+      (0, import_build_utils11.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -5991,7 +6013,7 @@ var litellmQuirk = {
 var import_fs9 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils11 = require("@vercel/build-utils");
+var import_build_utils12 = require("@vercel/build-utils");
 var import_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
@@ -6034,7 +6056,7 @@ async function findUserSchema(workPath) {
       await import_fs9.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils11.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
@@ -6138,7 +6160,7 @@ var prismaQuirk = {
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils11.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils12.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa4.default)(
         pythonPath,
@@ -6150,11 +6172,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.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)
@@ -6173,22 +6195,22 @@ var prismaQuirk = {
         const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
           await import_fs9.default.promises.access(destPath);
-          (0, import_build_utils11.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils11.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
           await import_fs9.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.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_utils11.NowBuildError({
+      throw new import_build_utils12.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}).`
       });
@@ -6215,14 +6237,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils11.debug)(
+          (0, import_build_utils12.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils11.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils12.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa4.default)(
             pythonPath,
@@ -6234,11 +6256,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils11.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils12.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils11.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils12.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils11.NowBuildError({
+          throw new import_build_utils12.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -6254,7 +6276,7 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
       );
       const count = await (0, import_python_analysis7.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils11.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils12.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -6348,13 +6370,13 @@ async function runQuirks(ctx) {
       (0, import_python_analysis8.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -6378,31 +6400,30 @@ async function runQuirks(ctx) {
 var import_fs10 = __toESM(require("fs"));
 var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = 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], {
-      env,
-      cwd: projectDir
-    });
-    const parsed = JSON.parse(stdout);
-    if (!parsed)
-      return null;
-    return {
-      settingsModule: parsed.settings_module,
-      djangoSettings: parsed.django_settings
-    };
-  } catch (err) {
-    (0, import_build_utils13.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
-    return null;
+  const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
+    env,
+    cwd: projectDir
+  });
+  const parsed = JSON.parse(stdout);
+  if (!parsed) {
+    throw new Error("manage.py did not return any settings");
   }
+  return {
+    settingsModule: parsed.settings_module,
+    djangoSettings: parsed.django_settings,
+    djangoVersion: parsed.django_version ?? null
+  };
 }
-async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings) {
+async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings, djangoVersion) {
   const pythonPath = getVenvPythonBin(venvPath);
   const storages = djangoSettings["STORAGES"];
-  const storageBackend = storages?.staticfiles?.BACKEND ?? djangoSettings["STATICFILES_STORAGE"] ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
+  const useLegacySetting = !djangoVersion || djangoVersion[0] < 5 || djangoVersion[0] === 5 && djangoVersion[1] < 1;
+  const legacyBackend = useLegacySetting ? djangoSettings["STATICFILES_STORAGE"] : void 0;
+  const storageBackend = storages?.staticfiles?.BACKEND ?? legacyBackend ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
   const staticUrl = djangoSettings["STATIC_URL"] ?? "/static/";
   const staticRoot = djangoSettings["STATIC_ROOT"] != null ? String(djangoSettings["STATIC_ROOT"]) : null;
   const whitenoiseUseFinders = djangoSettings["WHITENOISE_USE_FINDERS"] === true;
@@ -6471,7 +6492,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     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`);
+    (0, import_build_utils14.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
@@ -6498,14 +6519,31 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils14.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils15.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
-    const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils14.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
-    if (!settingsResult)
-      return;
-    const { djangoSettings, settingsModule } = settingsResult;
+    let settingsResult;
+    try {
+      settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+    } catch (err) {
+      let detail;
+      if (err?.code === "ENOENT") {
+        detail = `command not found: python
+Hint: activate a venv or run with \`uv run vercel dev\``;
+      } else {
+        detail = err?.stderr || err?.message || String(err);
+      }
+      throw new import_build_utils15.NowBuildError({
+        code: "DJANGO_SETTINGS_FAILED",
+        message: `Failed to read Django application settings from ${projectDir}/manage.py:
+${detail}`
+      });
+    }
+    (0, import_build_utils15.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
+    if (djangoVersion) {
+      console.log(`Django ${djangoVersion.join(".")} detected`);
+    }
     let resolvedEntrypoint;
     const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
@@ -6514,7 +6552,7 @@ var frameworkHooks = {
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils14.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils15.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -6523,7 +6561,7 @@ var frameworkHooks = {
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils14.debug)(
+        (0, import_build_utils15.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -6538,7 +6576,8 @@ var frameworkHooks = {
         pythonEnv,
         outputStaticDir,
         settingsModule,
-        djangoSettings
+        djangoSettings,
+        djangoVersion
       );
     }
     return { entrypoint: resolvedEntrypoint, djangoStatic };
@@ -6550,14 +6589,14 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils14.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
-  if (meta.isDev) {
+  (0, import_build_utils15.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils15.download)(files, workPath, meta);
+  if (meta.isDev && entrypoint) {
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
     const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
     const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils14.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
+    await (0, import_build_utils15.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils15.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -6566,19 +6605,20 @@ var build = async ({
   workPath,
   repoRootPath,
   files: originalFiles,
-  entrypoint,
+  entrypoint: rawEntrypoint,
   meta = {},
   config,
   span: parentSpan,
   service
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils14.Span({ name: "vc.builder" });
+  let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
+  const builderSpan = parentSpan ?? new import_build_utils15.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils14.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils15.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -6594,56 +6634,17 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   let detected;
-  let entrypointNotFound;
-  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,
-      workPath,
-      entrypoint
-    ) ?? void 0;
-    if (detected?.entrypoint) {
-      (0, import_build_utils14.debug)(
-        `Resolved Python entrypoint to "${detected.entrypoint.entrypoint}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = detected.entrypoint.entrypoint;
-    } else {
-      const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      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`,
-        action: "Learn More"
-      });
-    }
-  }
-  if (!detected?.entrypoint && entrypoint.endsWith(".py") && fsFiles[entrypoint]) {
-    const content = await import_fs11.default.promises.readFile(
-      (0, import_path13.join)(workPath, entrypoint),
-      "utf-8"
-    );
-    let varName = await (0, import_python_analysis9.findAppOrHandler)(content);
-    if (!varName) {
-      const isSpecialService = service?.type === "cron" || service?.type === "worker";
-      if (isSpecialService) {
-        varName = "app";
-      } else if (!varName) {
-        throw new import_build_utils14.NowBuildError({
-          code: "PYTHON_ENTRYPOINT_NOT_FOUND",
-          message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
-          link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
-          action: "Learn More"
-        });
-      }
-    }
-    detected = { entrypoint: { entrypoint, variableName: varName } };
-  }
-  if (entrypointNotFound && detected?.baseDir === void 0) {
-    throw entrypointNotFound;
+  detected = await detectPythonEntrypoint(
+    config.framework,
+    workPath,
+    entrypoint,
+    service
+  ) ?? void 0;
+  if (detected?.error && detected?.baseDir === void 0) {
+    throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (0, import_path13.dirname)(entrypoint);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (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(
@@ -6674,7 +6675,6 @@ var build = async ({
 `
     );
   }
-  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({
@@ -6682,14 +6682,14 @@ var build = async ({
       venvPath
     });
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils14.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils14.getEnvForPackageManager)({
+    } = await (0, import_build_utils15.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils15.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -6728,14 +6728,14 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils14.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils15.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils14.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils15.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -6775,15 +6775,15 @@ var build = async ({
       });
     }
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils14.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils15.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils14.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils15.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -6805,16 +6805,19 @@ var build = async ({
     detected
   });
   const resolved = hookResult?.entrypoint ?? detected?.entrypoint;
-  if (entrypointNotFound && resolved) {
-    entrypoint = resolved.entrypoint;
-    entrypointNotFound = void 0;
-  }
-  if (entrypointNotFound) {
-    throw entrypointNotFound;
+  if (!resolved && detected?.error) {
+    throw detected?.error;
+  }
+  entrypoint = resolved?.entrypoint;
+  if (!entrypoint) {
+    throw new import_build_utils15.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils14.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils15.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6822,7 +6825,7 @@ var build = async ({
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils14.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils15.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6833,7 +6836,7 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils14.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils15.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
@@ -6841,7 +6844,7 @@ var build = async ({
     const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils14.NowBuildError({
+      throw new import_build_utils15.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -6850,7 +6853,7 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils14.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils15.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerFuncEnvLine = handlerFunction ? `
   "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
   const variableName = resolved?.variableName ?? "";
@@ -6911,18 +6914,6 @@ from vercel_runtime.vc_init import vc_handler
     "**/yarn.lock",
     "**/package-lock.json"
   ];
-  if (djangoStatic) {
-    const dirsToExclude = [
-      ...djangoStatic.staticSourceDirs,
-      ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
-    ];
-    for (const absDir of dirsToExclude) {
-      const rel = (0, import_path13.relative)(workPath, absDir);
-      if (!rel.startsWith("..")) {
-        predefinedExcludes.push(`${rel}/**`);
-      }
-    }
-  }
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
@@ -6933,9 +6924,9 @@ from vercel_runtime.vc_init import vc_handler
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils14.glob)("**", globOptions);
+  const files = await (0, import_build_utils15.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils14.FileFsRef({
+    files[djangoStatic.manifestRelPath] = new import_build_utils15.FileFsRef({
       fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
@@ -6972,12 +6963,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils14.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils15.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils14.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils15.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils14.Lambda({
+  const output = new import_build_utils15.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -6993,33 +6984,33 @@ from vercel_runtime.vc_init import vc_handler
         uvLockPath
       });
     } catch (err) {
-      (0, import_build_utils14.debug)(
+      (0, import_build_utils15.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (djangoStatic?.cdnOutputDir) {
-    const lambdaPath = entrypoint.replace(/\.py$/, "");
-    const staticFiles = await (0, import_build_utils14.glob)("**", { cwd: djangoStatic.cdnOutputDir });
-    return {
-      resultVersion: 2,
-      result: {
-        output: {
-          [lambdaPath]: output,
-          ...staticFiles
-        },
-        routes: [
-          { handle: "filesystem" },
-          { src: "/(.*)", dest: `/${lambdaPath}` }
-        ]
-      }
-    };
+  if (!(0, import_build_utils15.isPythonFramework)(framework)) {
+    return { resultVersion: 3, result: { output } };
   }
-  return { resultVersion: 3, result: { output } };
+  const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils15.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  return {
+    resultVersion: 2,
+    result: {
+      output: {
+        [lambdaPath]: output,
+        ...staticFiles
+      },
+      routes: [
+        { handle: "filesystem" },
+        { src: "/(.*)", dest: `/${lambdaPath}` }
+      ]
+    }
+  };
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.28.0",
+  "version": "6.29.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -36,9 +36,9 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.10.0",
-    "@vercel/python-runtime": "0.11.0",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/build-utils": "13.12.1",
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/python-runtime": "0.12.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/templates/vc_django_settings.py

@@ -33,11 +33,14 @@ else:
 
     mod = importlib.import_module(settings_module)
     settings = {k: getattr(mod, k) for k in dir(mod) if k.isupper()}
+    import django
+
     print(
         json.dumps(
             {
                 "settings_module": settings_module,
                 "django_settings": settings,
+                "django_version": django.VERSION[:3],
             },
             default=str,
         )