@vercel/python 6.48.0 → 6.50.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 fs14 = require("fs");
+    var fs16 = 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) {
-      fs14.stat(path, function(er, stat) {
+      fs16.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs14.statSync(path), path, options);
+      return checkStat(fs16.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 fs14 = require("fs");
+    var fs16 = require("fs");
     function isexe(path, options, cb) {
-      fs14.stat(path, function(er, stat) {
+      fs16.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs14.statSync(path), options);
+      return checkStat(fs16.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 fs14 = require("fs");
+    var fs16 = 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 fs14 = require("fs");
+    var fs16 = 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 = fs14.openSync(command, "r");
-        fs14.readSync(fd, buffer, 0, size, 0);
-        fs14.closeSync(fd);
+        fd = fs16.openSync(command, "r");
+        fs16.readSync(fd, buffer, 0, size, 0);
+        fs16.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs14;
+    var fs16;
     try {
-      fs14 = require("fs");
+      fs16 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs14)
+      if (!fs16)
         return false;
-      return (stream instanceof (fs14.ReadStream || noop) || stream instanceof (fs14.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs16.ReadStream || noop) || stream instanceof (fs16.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 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: join15, delimiter: delimiter2, sep: sep3, posix } = require("path");
+    var { join: join17, delimiter: delimiter2, sep: sep3, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep3 === posix.sep ? "" : sep3}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,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 + join15(pathPart, cmd);
+      return prefix + join17(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -3912,27 +3912,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 fs14 = require("fs");
+    var fs16 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync2 = (path) => {
-      const fd = fs14.openSync(path, "r");
+      const fd = fs16.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs14.close(fd, () => {
+      const bytesRead = fs16.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs16.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
     var readFile2 = (path) => new Promise((resolve3, reject) => {
-      fs14.open(path, "r", (err, fd) => {
+      fs16.open(path, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs16.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs14.close(fd, () => {
+            fs16.close(fd, () => {
             });
           });
         }
@@ -4361,11 +4361,14 @@ var require_is_port_reachable = __commonJS({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  addCollectedVendorBytecode: () => addCollectedVendorBytecode,
+  addVendorBytecodeInTiers: () => addVendorBytecodeInTiers,
   build: () => build,
   defaultShouldServe: () => defaultShouldServe,
   detectEntrypoint: () => detectEntrypoint,
   diagnostics: () => diagnostics,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
+  getDevSidecars: () => getDevSidecars,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
   prepareCache: () => prepareCache,
@@ -4376,15 +4379,15 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_assert = __toESM(require("assert"));
-var import_fs15 = __toESM(require("fs"));
-var import_path15 = require("path");
+var import_fs17 = __toESM(require("fs"));
+var import_path17 = require("path");
 
 // src/package-versions.ts
 var VERCEL_RUNTIME_VERSION = "0.16.0";
 var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/index.ts
-var import_build_utils19 = require("@vercel/build-utils");
+var import_build_utils20 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -5649,39 +5652,35 @@ var import_execa4 = __toESM(require_execa());
 var import_build_utils6 = require("@vercel/build-utils");
 var import_fs5 = __toESM(require("fs"));
 var import_path6 = require("path");
-
-// src/large-functions.ts
-function isLargeFunctionsEnabled() {
-  const value = process.env.VERCEL_SUPPORT_LARGE_FUNCTIONS;
-  return value === "1" || value === "true";
-}
-
-// src/compileall.ts
-function isCompileAllEnabled() {
-  if (!isLargeFunctionsEnabled())
-    return false;
+var COMPILEALL_TIMEOUT_MS = 5 * 60 * 1e3;
+var PYCACHE_PREFIX_DIR = "_vc_pycache";
+var RUNTIME_PYCACHE_PREFIX = `/var/task/${PYCACHE_PREFIX_DIR}`;
+function isCompileAllFlagEnabled() {
   const val = process.env.VERCEL_PYTHON_COMPILEALL;
   if (val === void 0 || val === "")
     return false;
   const lower = val.toLowerCase();
   return lower === "1" || lower === "true";
 }
-function shouldUseCompileAll({
+function shouldCompileAll({
   isDev,
   hasCustomCommand,
-  hasCustomBuildCommand
+  hasPreDeployCommand
 }) {
   if (isDev)
     return false;
-  if (hasCustomCommand || hasCustomBuildCommand)
+  if (hasCustomCommand)
     return false;
-  return isCompileAllEnabled();
+  if (hasPreDeployCommand)
+    return false;
+  return isCompileAllFlagEnabled();
 }
 async function runCompileAll({
   pythonBin,
   filesOrDirectories,
   env,
-  excludeRegex
+  excludeRegex,
+  pycachePrefix
 }) {
   if (filesOrDirectories.length === 0)
     return;
@@ -5697,8 +5696,13 @@ async function runCompileAll({
     ...excludeRegex ? ["-x", excludeRegex] : [],
     ...filesOrDirectories
   ];
+  const baseEnv = env || process.env;
+  const subprocessEnv = pycachePrefix ? { ...baseEnv, PYTHONPYCACHEPREFIX: pycachePrefix } : baseEnv;
   try {
-    await (0, import_execa4.default)(pythonBin, args, { env: env || process.env });
+    await (0, import_execa4.default)(pythonBin, args, {
+      env: subprocessEnv,
+      timeout: COMPILEALL_TIMEOUT_MS
+    });
   } catch (err) {
     (0, import_build_utils6.debug)(`compileall error details: ${JSON.stringify(err)}`);
   }
@@ -5711,6 +5715,42 @@ function derivePycPath(pyRelPath, pythonMajor, pythonMinor) {
   const baseName = pyRelPath.slice(lastSlash + 1, -3);
   return `${dir}__pycache__/${baseName}.cpython-${pythonMajor}${pythonMinor}.pyc`;
 }
+function derivePrefixPycRelPath(pyRelPath, pythonMajor, pythonMinor) {
+  if (!pyRelPath.endsWith(".py"))
+    return null;
+  return `${pyRelPath.slice(0, -3)}.cpython-${pythonMajor}${pythonMinor}.pyc`;
+}
+function stripPycachePrefixRoot(head) {
+  const pycachePathSeparators = /* @__PURE__ */ new Set(["/", "\\"]);
+  if (head.length > 1 && head[1] === ":" && !pycachePathSeparators.has(head[0])) {
+    head = head.slice(2);
+  }
+  let start = 0;
+  while (start < head.length && pycachePathSeparators.has(head[start])) {
+    start++;
+  }
+  return head.slice(start);
+}
+function deriveStagedPycFsPath(stagingDir, srcAbsPath, pythonMajor, pythonMinor) {
+  const rel = derivePrefixPycRelPath(
+    stripPycachePrefixRoot(srcAbsPath),
+    pythonMajor,
+    pythonMinor
+  );
+  if (!rel)
+    return null;
+  return (0, import_path6.join)(stagingDir, rel.replaceAll("/", import_path6.sep));
+}
+function derivePrefixPycBundlePath(runtimeAbsPath, pythonMajor, pythonMinor) {
+  const rel = derivePrefixPycRelPath(
+    stripPycachePrefixRoot(runtimeAbsPath),
+    pythonMajor,
+    pythonMinor
+  );
+  if (!rel)
+    return null;
+  return `${PYCACHE_PREFIX_DIR}/${rel}`;
+}
 var COMPILEALL_APP_EXCLUDED_DIRS = [
   ".git",
   ".vercel",
@@ -5732,6 +5772,58 @@ function getCompileAllAppExcludeRegex(workPath) {
   const excludedDirs = COMPILEALL_APP_EXCLUDED_DIRS.map(escapePythonRegex).join("|");
   return `${escapePythonRegex(workPath)}[/\\\\](?:${excludedDirs})(?:[/\\\\]|$)`;
 }
+async function collectAppPrefixBytecodeFiles({
+  stagingDir,
+  workPath,
+  files: appFiles,
+  runtimeTaskRoot,
+  pythonMajor,
+  pythonMinor
+}) {
+  const pending = [];
+  for (const bundlePath of Object.keys(appFiles)) {
+    if (!bundlePath.endsWith(".py"))
+      continue;
+    const stagedFsPath = deriveStagedPycFsPath(
+      stagingDir,
+      (0, import_path6.join)(workPath, bundlePath.replaceAll("/", import_path6.sep)),
+      pythonMajor,
+      pythonMinor
+    );
+    const pycBundlePath = derivePrefixPycBundlePath(
+      `${runtimeTaskRoot}/${bundlePath}`,
+      pythonMajor,
+      pythonMinor
+    );
+    if (!stagedFsPath || !pycBundlePath)
+      continue;
+    pending.push({ bundlePath: pycBundlePath, srcFsPath: stagedFsPath });
+  }
+  const results = await Promise.all(
+    pending.map(async ({ bundlePath, srcFsPath }) => {
+      try {
+        const stats = await import_fs5.default.promises.stat(srcFsPath);
+        return { bundlePath, srcFsPath, size: stats.size };
+      } catch {
+        return null;
+      }
+    })
+  );
+  const files = {};
+  const perItemSizes = /* @__PURE__ */ new Map();
+  let totalSize = 0;
+  for (const result of results) {
+    if (!result)
+      continue;
+    files[result.bundlePath] = new import_build_utils6.FileFsRef({
+      fsPath: result.srcFsPath,
+      size: result.size
+    });
+    perItemSizes.set(result.bundlePath, result.size);
+    totalSize += result.size;
+  }
+  return { files, totalSize, perItemSizes };
+}
 async function collectAppBytecodeFiles({
   workPath,
   files: appFiles,
@@ -5774,6 +5866,12 @@ async function collectAppBytecodeFiles({
   return { files, totalSize, perItemSizes };
 }
 
+// src/large-functions.ts
+function isLargeFunctionsEnabled() {
+  const value = process.env.VERCEL_SUPPORT_LARGE_FUNCTIONS;
+  return value === "1" || value === "true";
+}
+
 // src/dependency-externalizer.ts
 var readFile = (0, import_util.promisify)(import_fs6.default.readFile);
 var STRIP_BASENAMES = /* @__PURE__ */ new Set([
@@ -5794,7 +5892,11 @@ function shouldStripVendorFile(filePath) {
   return false;
 }
 var LAMBDA_SIZE_THRESHOLD_BYTES = 225 * 1024 * 1024;
+var BYTECODE_FILL_MARGIN_BYTES = 5 * 1024 * 1024;
+var BYTECODE_FILL_CEILING_BYTES = LAMBDA_SIZE_THRESHOLD_BYTES - BYTECODE_FILL_MARGIN_BYTES;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
+var EPHEMERAL_INSTALL_BUDGET_BYTES = LAMBDA_EPHEMERAL_STORAGE_BYTES - 50 * 1024 * 1024;
+var RUNTIME_DEPS_DIR = "/tmp/_vc_deps";
 var MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE = 5 * 1024 * 1024 * 1024;
 var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
 var PythonDependencyExternalizer = class {
@@ -5905,7 +6007,7 @@ application into smaller functions.`,
    * back to bundling everything for Hive and returns `fellBackToFullBundle:
    * true` so the caller can apply the same compileall handling.
    */
-  async generateBundle(files) {
+  async generateBundle(files, options = {}) {
     if (!this.analyzed) {
       throw new Error(
         "PythonDependencyExternalizer.analyze() must be called before generateBundle()"
@@ -6066,7 +6168,20 @@ To fix this, either:
         ([name]) => externalizableSet.has((0, import_python_analysis3.normalizePackageName)(name))
       )
     );
-    const bundledPublic = lambdaKnapsack(publicPackageSizes, remainingCapacity);
+    const { packingMode, bundledPublic } = planPublicPackagePacking({
+      publicPackageSizes,
+      zipCapacity: remainingCapacity,
+      bytecodeFirst: options.bytecodeFirst ?? false
+    });
+    if (options.bytecodeFirst && packingMode === "knapsack") {
+      (0, import_build_utils7.debug)(
+        `bytecode-first packing disabled: the public package set exceeds the ephemeral install budget (${(EPHEMERAL_INSTALL_BUDGET_BYTES / (1024 * 1024)).toFixed(2)} MB); falling back to knapsack packing`
+      );
+    }
+    const bundledPublicSet = new Set(bundledPublic.map(import_python_analysis3.normalizePackageName));
+    const externalizedPublic = externalizablePublic.filter(
+      (name) => !bundledPublicSet.has((0, import_python_analysis3.normalizePackageName)(name))
+    );
     const allBundledPackages = [...alwaysBundled, ...bundledPublic];
     const selectedVendorFiles = await this.mirrorPackagesIntoVendor({
       vendorDirName: this.vendorDir,
@@ -6138,7 +6253,13 @@ functions.`,
         action: "Learn More"
       });
     }
-    return { fellBackToFullBundle: false };
+    return {
+      fellBackToFullBundle: false,
+      packingMode,
+      alwaysBundledPackages: alwaysBundled,
+      bundledPublicPackages: bundledPublic,
+      externalizedPublicPackages: externalizedPublic
+    };
   }
   /**
    * Discard any runtime-install artifacts added so far and bundle every
@@ -6451,6 +6572,92 @@ functions.`,
     );
     return { files, totalSize, perItemSizes };
   }
+  /**
+   * Collect staged prefix `.pyc` files for vendor packages, keyed under
+   * `_vc_pycache/<runtimeRoot>/...` (`runtimeRoot` = `/var/task/_vendor`
+   * for bundled packages, the /tmp site-packages dir for externalized
+   * ones). Missing staged files are silently skipped. Must be called after
+   * `analyze()`.
+   */
+  async collectPrefixBytecodeFiles({
+    stagingDir,
+    runtimeRoot,
+    includePackages
+  }) {
+    if (!this.sitePackageDirs || !this.distributions) {
+      throw new Error(
+        "collectPrefixBytecodeFiles() must be called after analyze()"
+      );
+    }
+    if (this.pythonMajor == null || this.pythonMinor == null) {
+      return { files: {}, totalSize: 0, perItemSizes: /* @__PURE__ */ new Map() };
+    }
+    const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
+    const pending = [];
+    for (const dir of this.sitePackageDirs) {
+      const dirDistributions = this.distributions.get(dir);
+      if (!dirDistributions)
+        continue;
+      const resolvedDir = (0, import_path7.resolve)(dir);
+      const dirPrefix = resolvedDir + import_path7.sep;
+      for (const [name, dist] of dirDistributions) {
+        if (includeSet && !includeSet.has(name))
+          continue;
+        for (const { path: rawPath } of dist.files) {
+          if (!rawPath.endsWith(".py"))
+            continue;
+          const filePath = rawPath.replaceAll("/", import_path7.sep);
+          if (!(0, import_path7.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+            continue;
+          }
+          const srcFsPath = deriveStagedPycFsPath(
+            stagingDir,
+            (0, import_path7.join)(dir, filePath),
+            this.pythonMajor,
+            this.pythonMinor
+          );
+          const bundlePath = derivePrefixPycBundlePath(
+            `${runtimeRoot}/${rawPath}`,
+            this.pythonMajor,
+            this.pythonMinor
+          );
+          if (!srcFsPath || !bundlePath)
+            continue;
+          pending.push({ bundlePath, srcFsPath, packageName: name });
+        }
+      }
+    }
+    const results = await Promise.all(
+      pending.map(async ({ bundlePath, srcFsPath, packageName }) => {
+        try {
+          const stats = await import_fs6.default.promises.stat(srcFsPath);
+          return { bundlePath, srcFsPath, size: stats.size, packageName };
+        } catch {
+          return null;
+        }
+      })
+    );
+    const files = {};
+    let totalSize = 0;
+    const perItemSizes = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      if (!result)
+        continue;
+      files[result.bundlePath] = new import_build_utils7.FileFsRef({
+        fsPath: result.srcFsPath,
+        size: result.size
+      });
+      totalSize += result.size;
+      perItemSizes.set(
+        result.packageName,
+        (perItemSizes.get(result.packageName) ?? 0) + result.size
+      );
+    }
+    (0, import_build_utils7.debug)(
+      `Collected ${Object.keys(files).length} prefix bytecode files (${(totalSize / (1024 * 1024)).toFixed(2)} MB) for runtime root ${runtimeRoot}` + (includePackages ? ` from ${includePackages.length} packages` : "")
+    );
+    return { files, totalSize, perItemSizes };
+  }
 };
 async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
   if (!projectName)
@@ -6510,10 +6717,12 @@ async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor
   }
   return visited;
 }
-async function calculateBundleSize(files) {
+async function calculateBundleSize(files, filter) {
   let knownSize = 0;
   const statPromises = [];
   for (const filePath of Object.keys(files)) {
+    if (filter && !filter(filePath))
+      continue;
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
       const fsRef = file;
@@ -6521,7 +6730,10 @@ async function calculateBundleSize(files) {
         knownSize += fsRef.size;
       } else {
         statPromises.push(
-          import_fs6.default.promises.stat(fsRef.fsPath).then((stats) => stats.size).catch((err) => {
+          import_fs6.default.promises.stat(fsRef.fsPath).then((stats) => {
+            fsRef.size = stats.size;
+            return stats.size;
+          }).catch((err) => {
             console.warn(
               `Warning: Failed to stat file ${fsRef.fsPath}, size will not be included in bundle calculation: ${err}`
             );
@@ -6541,6 +6753,12 @@ async function calculateBundleSize(files) {
   }
   return totalSize;
 }
+var PYC_TO_PY_RATIO = 1.2;
+var BYTECODE_COVERAGE_FLOOR = 0.5;
+async function estimateBytecodeSize(files) {
+  const pyBytes = await calculateBundleSize(files, (p) => p.endsWith(".py"));
+  return PYC_TO_PY_RATIO * pyBytes;
+}
 function lambdaKnapsack(packages, capacity) {
   if (capacity <= 0) {
     return [];
@@ -6556,6 +6774,23 @@ function lambdaKnapsack(packages, capacity) {
   }
   return bundled;
 }
+function planPublicPackagePacking({
+  publicPackageSizes,
+  zipCapacity,
+  bytecodeFirst
+}) {
+  let totalPublicSize = 0;
+  for (const size of publicPackageSizes.values()) {
+    totalPublicSize += size;
+  }
+  if (bytecodeFirst && totalPublicSize <= EPHEMERAL_INSTALL_BUDGET_BYTES) {
+    return { packingMode: "bytecode-first", bundledPublic: [] };
+  }
+  return {
+    packingMode: "knapsack",
+    bundledPublic: lambdaKnapsack(publicPackageSizes, zipCapacity)
+  };
+}
 
 // src/diagnostics.ts
 var import_fs7 = __toESM(require("fs"));
@@ -6870,7 +7105,7 @@ function getMissingExportMessage(framework, entrypoints) {
   }
 }
 function entrypointToModule(entrypoint) {
-  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\//g, ".");
+  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\/__init__$/i, "").replace(/\//g, ".");
 }
 async function checkEntrypoint(workPath, relPath) {
   const absPath = (0, import_path8.join)(workPath, relPath);
@@ -6946,14 +7181,37 @@ async function resolveModuleAttrEntrypoint(workPath, value) {
   }
   return null;
 }
-async function getVercelToolsEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils11.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+async function getVercelToolsEntrypoint(workPath, repoRootPath) {
+  const pyprojectPath = (0, import_path8.join)(workPath, "pyproject.toml");
+  const pyprojectData = await (0, import_build_utils11.readConfigFile)(pyprojectPath);
   if (!pyprojectData)
     return null;
   const vercelEntrypoint = pyprojectData.tool?.vercel?.entrypoint;
-  if (typeof vercelEntrypoint !== "string")
+  if (vercelEntrypoint === void 0)
     return null;
-  return resolveModuleAttrEntrypoint(workPath, vercelEntrypoint);
+  const relPyprojectPath = (0, import_path8.relative)(repoRootPath ?? workPath, pyprojectPath);
+  const displayPath = !relPyprojectPath || relPyprojectPath.startsWith("..") ? pyprojectPath : relPyprojectPath;
+  if (typeof vercelEntrypoint !== "string") {
+    throw new import_build_utils9.NowBuildError({
+      code: "PYTHON_INVALID_ENTRYPOINT",
+      message: `"tool.vercel.entrypoint" in "${displayPath}" must be a string in "module:object" format (e.g. "main:app").`,
+      link: PYTHON_ENTRYPOINT_DOCS_URL,
+      action: "Learn More"
+    });
+  }
+  const resolved = await resolveModuleAttrEntrypoint(
+    workPath,
+    vercelEntrypoint
+  );
+  if (!resolved) {
+    throw new import_build_utils9.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: `"tool.vercel.entrypoint" in "${displayPath}" is "${vercelEntrypoint}" but no matching module file was found. Use "module:object" format (e.g. "main:app") and ensure the module file exists, or remove the setting to use automatic entrypoint detection.`,
+      link: PYTHON_ENTRYPOINT_DOCS_URL,
+      action: "Learn More"
+    });
+  }
+  return resolved;
 }
 async function getPyprojectEntrypointWithDiagnostics(workPath) {
   const pyprojectData = await (0, import_build_utils11.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
@@ -7107,7 +7365,7 @@ async function detectDjangoPythonEntrypoint(workPath) {
     return emptyResult;
   }
 }
-async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service, repoRootPath) {
   if (configuredEntrypoint) {
     const { filePath: configEntryFile, varName: configEntryVar } = configuredEntrypoint;
     const entrypoint = configEntryFile.endsWith(".py") ? configEntryFile : `${configEntryFile}.py`;
@@ -7146,7 +7404,7 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (!framework) {
     return null;
   }
-  const vercelEntry = await getVercelToolsEntrypoint(workPath);
+  const vercelEntry = await getVercelToolsEntrypoint(workPath, repoRootPath);
   if (vercelEntry)
     return { entrypoint: vercelEntry };
   let findDiagnostics;
@@ -7186,10 +7444,18 @@ var detectEntrypoint = async ({
 }) => {
   if (!(0, import_build_utils9.isPythonFramework)(framework))
     return null;
-  const detected = await detectPythonEntrypoint(
-    framework,
-    workPath
-  );
+  let detected;
+  try {
+    detected = await detectPythonEntrypoint(
+      framework,
+      workPath
+    );
+  } catch (err) {
+    (0, import_build_utils10.debug)(
+      `Python entrypoint detection failed for ${workPath}: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
   if (!detected?.entrypoint)
     return null;
   const { entrypoint, variableName } = detected.entrypoint;
@@ -7415,6 +7681,23 @@ async function getReachableHost(port) {
   ]);
   return results.find(Boolean) || false;
 }
+async function dedupePendingOperation(operations, key, operation) {
+  const existing = operations.get(key);
+  if (existing) {
+    return existing;
+  }
+  const pending = operation();
+  operations.set(key, pending);
+  try {
+    return await pending;
+  } finally {
+    if (operations.get(key) === pending) {
+      operations.delete(key);
+    }
+  }
+}
+var PENDING_MANAGED_VENV_CREATIONS = /* @__PURE__ */ new Map();
+var PENDING_DEPENDENCY_SYNCS = /* @__PURE__ */ new Map();
 async function syncDependencies({
   workPath,
   uvPath,
@@ -7558,16 +7841,29 @@ async function runSync({
   });
 }
 var PENDING_INSTALLS = /* @__PURE__ */ new Map();
+var COMPLETED_INSTALLS = /* @__PURE__ */ new Set();
+function hasInstalledDistribution(targetDir, packageName) {
+  const prefix = `${packageName.replace("-", "_")}-`;
+  try {
+    return (0, import_fs10.readdirSync)(targetDir).some(
+      (entry) => entry.startsWith(prefix) && entry.endsWith(".dist-info")
+    );
+  } catch {
+    return false;
+  }
+}
 async function installInjectedDevPackage(pkg, opts) {
   const targetDir = (0, import_path10.join)(opts.workPath, ".vercel", "python");
-  const key = `${targetDir}:${pkg.name}`;
-  let pending = PENDING_INSTALLS.get(key);
-  if (!pending) {
-    pending = doInstallInjectedDevPackage(pkg, { ...opts, targetDir });
-    PENDING_INSTALLS.set(key, pending);
-    pending.finally(() => PENDING_INSTALLS.delete(key));
+  const source = pkg.envOverride || pkg.pinnedVersion;
+  const key = `${targetDir}:${pkg.name}:${source}`;
+  if (COMPLETED_INSTALLS.has(key) && hasInstalledDistribution(targetDir, pkg.name)) {
+    return;
   }
-  await pending;
+  COMPLETED_INSTALLS.delete(key);
+  await dedupePendingOperation(PENDING_INSTALLS, key, async () => {
+    await doInstallInjectedDevPackage(pkg, { ...opts, targetDir });
+    COMPLETED_INSTALLS.add(key);
+  });
 }
 async function doInstallInjectedDevPackage(pkg, opts) {
   const { targetDir, workPath, uvPath, pythonBin, env, onStdout, onStderr } = opts;
@@ -7707,18 +8003,26 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
+  const venvPath = (0, import_path10.join)(workPath, ".venv");
+  const pendingCreation = PENDING_MANAGED_VENV_CREATIONS.get(venvPath);
+  if (pendingCreation) {
+    await pendingCreation;
+  }
   const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
   if (venvRoot) {
     (0, import_build_utils13.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path10.join)(workPath, ".venv");
-  await ensureVenv({
-    pythonVersion: { pythonPath: systemPython },
+  await dedupePendingOperation(
+    PENDING_MANAGED_VENV_CREATIONS,
     venvPath,
-    uvPath,
-    quiet: true
-  });
+    () => ensureVenv({
+      pythonVersion: { pythonPath: systemPython },
+      venvPath,
+      uvPath,
+      quiet: true
+    })
+  );
   (0, import_build_utils13.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
@@ -7779,7 +8083,8 @@ var startDevServer = async (opts) => {
       // Other services use handlerFunction as the entrypoint variable name.
       varName: service && (0, import_build_utils13.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
     } : void 0,
-    service
+    service,
+    opts.repoRootPath
   );
   let hookResult;
   if (detected?.entrypoint) {
@@ -7893,7 +8198,11 @@ If you are using a virtual environment, activate it before running "vercel dev",
       } else {
         console.log(syncMessage);
       }
-      await syncDependencies(devOpts);
+      await dedupePendingOperation(
+        PENDING_DEPENDENCY_SYNCS,
+        workPath,
+        () => syncDependencies(devOpts)
+      );
     }
     await installInjectedDevPackage(
       {
@@ -8584,11 +8893,55 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
 var import_python_analysis9 = require("@vercel/python-analysis");
 
 // src/subscribers.ts
+var import_path15 = require("path");
+var import_fs15 = __toESM(require("fs"));
+var import_build_utils18 = require("@vercel/build-utils");
+
+// src/module-entrypoint.ts
 var import_path14 = require("path");
 var import_fs14 = __toESM(require("fs"));
-var import_build_utils18 = require("@vercel/build-utils");
-var SUBSCRIBER_NAME_RE = /^[A-Za-z]([A-Za-z0-9_-]*[A-Za-z0-9])?$/;
 var MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+function parseModuleEntrypoint(value) {
+  const match = MODULE_ATTR_RE.exec(value);
+  if (!match) {
+    return null;
+  }
+  return {
+    moduleName: match[1],
+    variableName: match[2],
+    filePath: `${match[1].replace(/\./g, "/")}.py`
+  };
+}
+function getModuleEntrypointName({
+  moduleName,
+  variableName
+}) {
+  return `${moduleName.replace(/\./g, "-")}_${variableName}`;
+}
+function safePathSegment(value) {
+  return [...value].map((char) => {
+    if (char === "_") {
+      return "__";
+    }
+    return /[A-Za-z0-9-]/.test(char) ? char : `_${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
+  }).join("");
+}
+async function resolveExistingEntrypoint(workPath, filePath) {
+  const candidates = [filePath, filePath.replace(/\.py$/i, "/__init__.py")];
+  for (const candidate of candidates) {
+    try {
+      const stat = await import_fs14.default.promises.stat((0, import_path14.join)(workPath, candidate));
+      if (stat.isFile()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/subscribers.ts
+var SUBSCRIBER_OUTPUT_DIR = "_py_subscribers";
 var TRIGGER_NUMBER_FIELDS = [
   {
     field: "max_deliveries",
@@ -8620,17 +8973,15 @@ var SUBSCRIBER_FIELD_NAMES = /* @__PURE__ */ new Set([
   "topics",
   ...TRIGGER_NUMBER_FIELDS.map(({ field }) => field)
 ]);
-function safePathSegment(value) {
-  return [...value].map((char) => {
-    if (char === "_") {
-      return "__";
-    }
-    return /[A-Za-z0-9-]/.test(char) ? char : `_${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
-  }).join("");
+function getSubscriberOutputPath(subscriberName) {
+  return `${SUBSCRIBER_OUTPUT_DIR}/${safePathSegment(subscriberName)}`;
+}
+function getSubscriberConsumerName(subscriberName) {
+  return (0, import_build_utils18.sanitizeConsumerName)(getSubscriberOutputPath(subscriberName));
 }
 async function getPyprojectSubscribers(workPath) {
-  const pyprojectPath = (0, import_path14.join)(workPath, "pyproject.toml");
-  if (!import_fs14.default.existsSync(pyprojectPath)) {
+  const pyprojectPath = (0, import_path15.join)(workPath, "pyproject.toml");
+  if (!import_fs15.default.existsSync(pyprojectPath)) {
     return [];
   }
   const pyproject = await (0, import_build_utils18.readConfigFile)(pyprojectPath);
@@ -8638,37 +8989,43 @@ async function getPyprojectSubscribers(workPath) {
   if (!subscribers) {
     return [];
   }
-  if (typeof subscribers !== "object" || Array.isArray(subscribers)) {
-    throw subscriberError('"tool.vercel.subscribers" must be an object');
+  if (!Array.isArray(subscribers)) {
+    throw subscriberError('"tool.vercel.subscribers" must be an array');
   }
-  return Promise.all(
-    Object.entries(subscribers).map(
-      ([name, config]) => parseSubscriber(workPath, name, config)
-    )
+  const parsedSubscribers = await Promise.all(
+    subscribers.map((config, index) => parseSubscriber(workPath, index, config))
   );
-}
-async function parseSubscriber(workPath, name, config) {
-  if (!SUBSCRIBER_NAME_RE.test(name)) {
-    throw subscriberError(
-      `subscriber name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores`
-    );
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const subscriber of parsedSubscribers) {
+    if (seenNames.has(subscriber.name)) {
+      throw subscriberError(
+        `subscriber "${subscriber.name}" is declared more than once`
+      );
+    }
+    seenNames.add(subscriber.name);
   }
+  return parsedSubscribers;
+}
+async function parseSubscriber(workPath, index, config) {
+  const label = `subscriber #${index + 1}`;
   if (!config || typeof config !== "object" || Array.isArray(config)) {
-    throw subscriberError(`subscriber "${name}" must be an object`);
+    throw subscriberError(`${label} must be an object`);
   }
   for (const key of Object.keys(config)) {
     if (!SUBSCRIBER_FIELD_NAMES.has(key)) {
-      throw subscriberError(
-        `subscriber "${name}" has unrecognized field "${key}"`
-      );
+      throw subscriberError(`${label} has unrecognized field "${key}"`);
     }
   }
   if (typeof config.entrypoint !== "string") {
+    throw subscriberError(`${label} must define string field "entrypoint"`);
+  }
+  const entrypoint = parseModuleEntrypoint(config.entrypoint);
+  if (!entrypoint) {
     throw subscriberError(
-      `subscriber "${name}" must define string field "entrypoint"`
+      `${label} has invalid entrypoint "${config.entrypoint}". Use "module:object"`
     );
   }
-  const entrypoint = parseEntrypoint(name, config.entrypoint);
+  const name = getModuleEntrypointName(entrypoint);
   const existingEntrypoint = await resolveExistingEntrypoint(
     workPath,
     entrypoint.filePath
@@ -8687,32 +9044,6 @@ async function parseSubscriber(workPath, name, config) {
     triggerDefaults: parseTriggerDefaults(name, config)
   };
 }
-function parseEntrypoint(name, value) {
-  const match = MODULE_ATTR_RE.exec(value);
-  if (!match) {
-    throw subscriberError(
-      `subscriber "${name}" has invalid entrypoint "${value}". Use "module:object"`
-    );
-  }
-  return {
-    moduleName: match[1],
-    variableName: match[2],
-    filePath: `${match[1].replace(/\./g, "/")}.py`
-  };
-}
-async function resolveExistingEntrypoint(workPath, filePath) {
-  const candidates = [filePath, filePath.replace(/\.py$/i, "/__init__.py")];
-  for (const candidate of candidates) {
-    try {
-      const stat = await import_fs14.default.promises.stat((0, import_path14.join)(workPath, candidate));
-      if (stat.isFile()) {
-        return candidate;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
 function parseTopics(name, value) {
   if (!Array.isArray(value) || value.length === 0) {
     throw subscriberError(
@@ -8751,10 +9082,145 @@ function subscriberError(message) {
   });
 }
 
+// src/workflows.ts
+var import_path16 = require("path");
+var import_fs16 = __toESM(require("fs"));
+var import_build_utils19 = require("@vercel/build-utils");
+var WORKFLOW_OUTPUT_DIR = "_py_workflows";
+var WORKFLOW_TOPIC_PATTERN = "__wkf_*";
+var WORKFLOW_FIELD_NAMES = /* @__PURE__ */ new Set(["entrypoint"]);
+function getWorkflowOutputPath(workflowName) {
+  return `${WORKFLOW_OUTPUT_DIR}/${safePathSegment(workflowName)}`;
+}
+function getWorkflowConsumerName(workflowName) {
+  return (0, import_build_utils19.sanitizeConsumerName)(getWorkflowOutputPath(workflowName));
+}
+async function getPyprojectWorkflows(workPath) {
+  const pyprojectPath = (0, import_path16.join)(workPath, "pyproject.toml");
+  if (!import_fs16.default.existsSync(pyprojectPath)) {
+    return [];
+  }
+  const pyproject = await (0, import_build_utils19.readConfigFile)(pyprojectPath);
+  const workflows = pyproject?.tool?.vercel?.workflows;
+  if (!workflows) {
+    return [];
+  }
+  if (!Array.isArray(workflows)) {
+    throw workflowError('"tool.vercel.workflows" must be an array');
+  }
+  if (workflows.length > 1) {
+    throw workflowError(
+      '"tool.vercel.workflows" must declare a single entrypoint that registers every workflow'
+    );
+  }
+  return Promise.all(
+    workflows.map((config, index) => parseWorkflow(workPath, index, config))
+  );
+}
+async function parseWorkflow(workPath, index, config) {
+  const label = `workflow #${index + 1}`;
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw workflowError(`${label} must be an object`);
+  }
+  for (const key of Object.keys(config)) {
+    if (!WORKFLOW_FIELD_NAMES.has(key)) {
+      throw workflowError(`${label} has unrecognized field "${key}"`);
+    }
+  }
+  if (typeof config.entrypoint !== "string") {
+    throw workflowError(`${label} must define string field "entrypoint"`);
+  }
+  const entrypoint = parseModuleEntrypoint(config.entrypoint);
+  if (!entrypoint) {
+    throw workflowError(
+      `${label} has invalid entrypoint "${config.entrypoint}". Use "module:object"`
+    );
+  }
+  const name = getModuleEntrypointName(entrypoint);
+  const existingEntrypoint = await resolveExistingEntrypoint(
+    workPath,
+    entrypoint.filePath
+  );
+  if (!existingEntrypoint) {
+    throw workflowError(
+      `workflow "${name}" has entrypoint "${config.entrypoint}" but file "${entrypoint.filePath}" does not exist`
+    );
+  }
+  return {
+    name,
+    entrypoint: existingEntrypoint,
+    moduleName: entrypoint.moduleName,
+    variableName: entrypoint.variableName
+  };
+}
+function workflowError(message) {
+  return new import_build_utils19.NowBuildError({
+    code: "PYTHON_INVALID_WORKFLOW_CONFIG",
+    message
+  });
+}
+
 // src/index.ts
-var writeFile = import_fs15.default.promises.writeFile;
+var writeFile = import_fs17.default.promises.writeFile;
 var PYTHON_ENTRYPOINT_DOCS_URL2 = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 var version = -1;
+function getDevSubscriberTopics(subscriber) {
+  const { retryAfterSeconds, initialDelaySeconds } = subscriber.triggerDefaults;
+  return subscriber.topics.map((topic) => ({
+    topic,
+    ...retryAfterSeconds === void 0 ? {} : { retryAfterSeconds },
+    ...initialDelaySeconds === void 0 ? {} : { initialDelaySeconds }
+  }));
+}
+async function getDevSidecars({
+  workPath,
+  build: build2
+}) {
+  const framework = build2.config?.framework;
+  if (build2.config?.middleware === true || typeof framework !== "string" || !(0, import_build_utils20.isPythonFramework)(framework)) {
+    return [];
+  }
+  const subscribers = await getPyprojectSubscribers(workPath);
+  const workflows = await getPyprojectWorkflows(workPath);
+  return [
+    ...subscribers.map(
+      (subscriber) => ({
+        type: "subscriber",
+        name: subscriber.name,
+        consumer: getSubscriberConsumerName(subscriber.name),
+        workspace: ".",
+        framework,
+        runtime: "python",
+        builder: {
+          use: build2.use,
+          src: subscriber.entrypoint,
+          config: {
+            handlerFunction: subscriber.variableName
+          }
+        },
+        topics: getDevSubscriberTopics(subscriber)
+      })
+    ),
+    ...workflows.map(
+      (workflow) => ({
+        type: "subscriber",
+        name: workflow.name,
+        consumer: getWorkflowConsumerName(workflow.name),
+        workspace: ".",
+        framework,
+        runtime: "python",
+        builder: {
+          use: build2.use,
+          src: workflow.entrypoint,
+          config: {
+            handlerFunction: workflow.variableName
+          }
+        },
+        topics: [{ topic: WORKFLOW_TOPIC_PATTERN }]
+      })
+    )
+  ];
+}
 function addFiles(target, source) {
   for (const [p, f] of Object.entries(source)) {
     target[p] = f;
@@ -8803,6 +9269,54 @@ async function addVendorBytecodeWithinCapacity({
   addFiles(files, selectedBytecode.files);
   return capacity - selectedBytecode.totalSize;
 }
+async function addVendorBytecodeInTiers({
+  files,
+  depExternalizer,
+  vendorDir,
+  capacity,
+  vendorPackageTiers
+}) {
+  let remainingCapacity = capacity;
+  for (const tier of vendorPackageTiers) {
+    if (remainingCapacity <= 0)
+      break;
+    if (tier && tier.length === 0)
+      continue;
+    const bytecodeInfo = await depExternalizer.collectBytecodeFiles({
+      vendorDirName: vendorDir,
+      includePackages: tier
+    });
+    remainingCapacity = await addVendorBytecodeWithinCapacity({
+      files,
+      depExternalizer,
+      vendorDir,
+      bytecodeInfo,
+      capacity: remainingCapacity
+    });
+  }
+  return remainingCapacity;
+}
+async function addCollectedVendorBytecode({
+  files,
+  capacity,
+  collect
+}) {
+  if (capacity <= 0)
+    return capacity;
+  const info = await collect(void 0);
+  if (!info || info.totalSize <= 0)
+    return capacity;
+  if (info.totalSize <= capacity) {
+    addFiles(files, info.files);
+    return capacity - info.totalSize;
+  }
+  const selected = lambdaKnapsack(info.perItemSizes, capacity);
+  if (selected.length === 0)
+    return capacity;
+  const selectedInfo = await collect(selected);
+  addFiles(files, selectedInfo.files);
+  return capacity - selectedInfo.totalSize;
+}
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
   return hook?.(ctx);
@@ -8816,13 +9330,13 @@ var frameworkHooks = {
   }) => {
     let baseDir = detected?.baseDir;
     if (baseDir === void 0) {
-      if (!import_fs15.default.existsSync((0, import_path15.join)(workPath, "manage.py"))) {
-        (0, import_build_utils19.debug)("Django hook: no manage.py detected, skipping");
+      if (!import_fs17.default.existsSync((0, import_path17.join)(workPath, "manage.py"))) {
+        (0, import_build_utils20.debug)("Django hook: no manage.py detected, skipping");
         return;
       }
       baseDir = "";
     }
-    const djangoPath = (0, import_path15.join)(workPath, baseDir);
+    const djangoPath = (0, import_path17.join)(workPath, baseDir);
     let settingsResult;
     try {
       settingsResult = await getDjangoSettings(djangoPath, pythonEnv);
@@ -8834,13 +9348,13 @@ Hint: activate a venv or run with \`uv run vercel dev\``;
       } else {
         detail = err?.stderr || err?.message || String(err);
       }
-      throw new import_build_utils19.NowBuildError({
+      throw new import_build_utils20.NowBuildError({
         code: "DJANGO_SETTINGS_FAILED",
         message: `Failed to read Django application settings from ${djangoPath}/manage.py:
 ${detail}`
       });
     }
-    (0, import_build_utils19.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils20.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
     if (djangoVersion) {
       console.log(`Django ${djangoVersion.join(".")} detected`);
@@ -8852,7 +9366,7 @@ ${detail}`
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils19.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils20.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -8861,7 +9375,7 @@ ${detail}`
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils19.debug)(
+        (0, import_build_utils20.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -8869,7 +9383,7 @@ ${detail}`
     }
     let djangoStatic = null;
     if (workPath && venvPath) {
-      const outputStaticDir = (0, import_path15.join)(workPath, ".vercel", "output", "static");
+      const outputStaticDir = (0, import_path17.join)(workPath, ".vercel", "output", "static");
       djangoStatic = await runDjangoCollectStatic(
         venvPath,
         workPath,
@@ -8884,7 +9398,7 @@ ${detail}`
     return {
       entrypoint: resolvedEntrypoint,
       djangoStatic,
-      extraPythonPath: baseDir ? (0, import_path15.join)(workPath, baseDir) : void 0
+      extraPythonPath: baseDir ? (0, import_path17.join)(workPath, baseDir) : void 0
     };
   }
 };
@@ -8943,23 +9457,23 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils19.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils19.download)(files, workPath, meta);
+  (0, import_build_utils20.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils20.download)(files, workPath, meta);
   if (meta.isDev && entrypoint) {
     const normalizedEntrypoint = entrypoint.endsWith(".py") ? entrypoint : `${entrypoint}.py`;
     if (!hasProp(downloadedFiles, entrypoint) && !hasProp(downloadedFiles, normalizedEntrypoint)) {
-      throw new import_build_utils19.NowBuildError({
+      throw new import_build_utils20.NowBuildError({
         code: "PYTHON_ENTRYPOINT_NOT_FOUND",
         message: `Configured Python entrypoint "${normalizedEntrypoint}" was not found.`,
         link: PYTHON_ENTRYPOINT_DOCS_URL2,
         action: "Learn More"
       });
     }
-    const { devCacheDir = (0, import_path15.join)(workPath, ".now", "cache") } = meta;
-    const cacheKey = (0, import_path15.basename)(entrypoint).replace(/\./g, "_");
-    const destCache = (0, import_path15.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils19.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils19.glob)("**", destCache);
+    const { devCacheDir = (0, import_path17.join)(workPath, ".now", "cache") } = meta;
+    const cacheKey = (0, import_path17.basename)(entrypoint).replace(/\./g, "_");
+    const destCache = (0, import_path17.join)(devCacheDir, cacheKey);
+    await (0, import_build_utils20.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils20.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -8995,7 +9509,7 @@ async function getPythonLambdaOptions({
     sources.add(entrypoint.slice(0, -".py".length));
   }
   for (const sourceFile of sources) {
-    const lambdaOptions = await (0, import_build_utils19.getLambdaOptionsFromFunction)({
+    const lambdaOptions = await (0, import_build_utils20.getLambdaOptionsFromFunction)({
       sourceFile,
       config
     });
@@ -9015,11 +9529,11 @@ async function installInjectedPackage({
   projectDir,
   pipPlatformArgs
 }) {
-  const localDir = (0, import_path15.join)(__dirname, "..", "..", "..", "python", name);
-  const isLocalDev = import_fs15.default.existsSync((0, import_path15.join)(localDir, "pyproject.toml"));
+  const localDir = (0, import_path17.join)(__dirname, "..", "..", "..", "python", name);
+  const isLocalDev = import_fs17.default.existsSync((0, import_path17.join)(localDir, "pyproject.toml"));
   const dep = envOverride || (isLocalDev ? localDir : pinned);
   const noExclude = ["--exclude-newer-package", `${name}=false`];
-  (0, import_build_utils19.debug)(`Installing ${dep}`);
+  (0, import_build_utils20.debug)(`Installing ${dep}`);
   await uv.pip({
     venvPath,
     projectDir,
@@ -9045,29 +9559,37 @@ var build = async ({
   registerPreDeploy
 }) => {
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
-  const builderSpan = parentSpan ?? new import_build_utils19.Span({ name: "vc.builder" });
+  const isPyprojectEntrypoint = entrypoint !== void 0 && (0, import_path17.basename)(entrypoint) === "pyproject.toml";
+  if (isPyprojectEntrypoint && entrypoint !== "pyproject.toml") {
+    throw new import_build_utils20.NowBuildError({
+      code: "PYTHON_INVALID_PYPROJECT_ENTRYPOINT",
+      message: `A "pyproject.toml" entrypoint must sit at the service root. Set the service "root" to "${(0, import_path17.dirname)(entrypoint)}" and use entrypoint "pyproject.toml".`
+    });
+  }
+  const builderSpan = parentSpan ?? new import_build_utils20.Span({ name: "vc.builder" });
   const framework = config?.framework;
   let shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let subscribers = [];
+  let workflows = [];
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  let hasCustomBuildCommand = false;
   const target = getTargetPlatform(meta.isDev ?? false);
-  (0, import_build_utils19.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils20.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
     entrypoint,
     meta
   });
-  if (!service && (0, import_build_utils19.isPythonFramework)(framework)) {
+  if (isPyprojectEntrypoint || !service && (0, import_build_utils20.isPythonFramework)(framework)) {
     subscribers = await getPyprojectSubscribers(workPath);
-    shouldInstallVercelWorkers ||= subscribers.length > 0;
+    workflows = await getPyprojectWorkflows(workPath);
+    shouldInstallVercelWorkers ||= subscribers.length > 0 || workflows.length > 0;
   }
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path15.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path17.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
@@ -9076,22 +9598,36 @@ var build = async ({
   }
   let detected;
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
-  detected = await detectPythonEntrypoint(
-    config.framework,
-    workPath,
-    entrypoint ? {
-      filePath: entrypoint,
-      // For schedule-triggered jobs, the WSGI variable is always 'app' (created dynamically).
-      // For other services, handlerFunction is used as the entrypoint variable name.
-      varName: service && (0, import_build_utils19.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
-    } : void 0,
-    service
-  ) ?? void 0;
+  if (isPyprojectEntrypoint) {
+    const declared = await getVercelToolsEntrypoint(workPath, repoRootPath);
+    if (declared) {
+      detected = { entrypoint: declared };
+    } else if (subscribers.length === 0 && workflows.length === 0) {
+      throw new import_build_utils20.NowBuildError({
+        code: "PYTHON_PYPROJECT_NOTHING_TO_BUILD",
+        message: 'Entrypoint "pyproject.toml" declares nothing to build. Set "tool.vercel.entrypoint" for a web app and/or declare "[[tool.vercel.subscribers]]" or "[[tool.vercel.workflows]]" entries in pyproject.toml.'
+      });
+    }
+    entrypoint = void 0;
+  } else {
+    detected = await detectPythonEntrypoint(
+      config.framework,
+      workPath,
+      entrypoint ? {
+        filePath: entrypoint,
+        // For schedule-triggered jobs, the WSGI variable is always 'app' (created dynamically).
+        // For other services, handlerFunction is used as the entrypoint variable name.
+        varName: service && (0, import_build_utils20.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
+      } : void 0,
+      service,
+      repoRootPath
+    ) ?? void 0;
+  }
   if (detected?.error && detected?.baseDir === void 0) {
     throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path15.dirname)(entrypoint) : ".");
-  const entrypointAbsDir = (0, import_path15.join)(workPath, entryDirectory);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path17.dirname)(entrypoint) : ".");
+  const entrypointAbsDir = (0, import_path17.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
@@ -9132,12 +9668,12 @@ var build = async ({
   }
   const uvVersion = checkUvBinaryVersion(uv.getPath());
   console.log(`Using ${uvVersion}`);
-  const venvPath = service?.name ? (0, import_path15.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path15.join)(workPath, ".vercel", "python", ".venv");
-  const hasCachedVenv = import_fs15.default.existsSync((0, import_path15.join)(venvPath, "pyvenv.cfg"));
-  const hasCachedUv = import_fs15.default.existsSync(uvCacheDir);
+  const venvPath = service?.name ? (0, import_path17.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path17.join)(workPath, ".vercel", "python", ".venv");
+  const hasCachedVenv = import_fs17.default.existsSync((0, import_path17.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs17.default.existsSync(uvCacheDir);
   const restoredCache = hasCachedVenv && hasCachedUv ? "both" : hasCachedVenv ? "venv" : hasCachedUv ? "uv" : "none";
   if (hasCachedVenv || hasCachedUv) {
-    (0, import_build_utils19.debug)(
+    (0, import_build_utils20.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
     );
   }
@@ -9149,14 +9685,14 @@ var build = async ({
       uvCacheDir
     });
   });
-  if ((0, import_build_utils19.isPythonFramework)(framework)) {
+  if ((0, import_build_utils20.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils19.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils19.getEnvForPackageManager)({
+    } = await (0, import_build_utils20.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils20.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -9181,13 +9717,13 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils19.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils20.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0,
     runtime: "python",
     "python.cache.restored": restoredCache
   }).trace(async () => {
     if (projectInstallCommand) {
-      await import_fs15.default.promises.rm(venvPath, { recursive: true, force: true });
+      await import_fs17.default.promises.rm(venvPath, { recursive: true, force: true });
       await ensureVenv({
         pythonVersion,
         venvPath,
@@ -9198,7 +9734,7 @@ var build = async ({
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils19.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils20.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -9219,7 +9755,7 @@ var build = async ({
     }
     if (!assumeDepsInstalled) {
       const lockCacheKey = service?.name ? `uv.lock.${service.name}` : "uv.lock";
-      const cachedLockPath = (0, import_path15.join)(uvCacheDir, lockCacheKey);
+      const cachedLockPath = (0, import_path17.join)(uvCacheDir, lockCacheKey);
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
         rootDir,
@@ -9240,34 +9776,30 @@ var build = async ({
         locked: !lockFileProvidedByUser,
         pythonPlatform: target.uvPlatform
       });
-      if (lockPath && import_fs15.default.existsSync(lockPath)) {
-        await import_fs15.default.promises.mkdir(uvCacheDir, { recursive: true });
-        await import_fs15.default.promises.copyFile(lockPath, cachedLockPath);
+      if (lockPath && import_fs17.default.existsSync(lockPath)) {
+        await import_fs17.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs17.default.promises.copyFile(lockPath, cachedLockPath);
       }
     }
   });
-  if ((0, import_build_utils19.isPythonFramework)(framework)) {
+  if ((0, import_build_utils20.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils19.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils20.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils19.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils20.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
-        hasCustomBuildCommand = true;
       } else {
-        const ranBuildScript = await runPyprojectScript(
+        await runPyprojectScript(
           workPath,
           ["vercel-build", "now-build", "build"],
           pythonEnv
         );
-        if (ranBuildScript) {
-          hasCustomBuildCommand = true;
-        }
       }
     });
   }
@@ -9278,13 +9810,14 @@ var build = async ({
     entrypoint,
     detected
   });
-  const resolved = hookResult?.entrypoint ?? detected?.entrypoint;
+  const resolved = isPyprojectEntrypoint ? detected?.entrypoint : hookResult?.entrypoint ?? detected?.entrypoint;
   if (!resolved && detected?.error) {
     throw detected?.error;
   }
   entrypoint = resolved?.entrypoint;
-  if (!entrypoint) {
-    throw new import_build_utils19.NowBuildError({
+  const isWorkersOnly = !entrypoint && isPyprojectEntrypoint && (subscribers.length > 0 || workflows.length > 0);
+  if (!entrypoint && !isWorkersOnly) {
+    throw new import_build_utils20.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
@@ -9297,7 +9830,7 @@ var build = async ({
     envOverride: baseEnv.VERCEL_RUNTIME_PYTHON,
     uv,
     venvPath,
-    projectDir: (0, import_path15.join)(workPath, entryDirectory),
+    projectDir: (0, import_path17.join)(workPath, entryDirectory),
     pipPlatformArgs
   });
   if (shouldInstallVercelWorkers) {
@@ -9307,7 +9840,7 @@ var build = async ({
       envOverride: baseEnv.VERCEL_WORKERS_PYTHON,
       uv,
       venvPath,
-      projectDir: (0, import_path15.join)(workPath, entryDirectory),
+      projectDir: (0, import_path17.join)(workPath, entryDirectory),
       pipPlatformArgs
     });
   }
@@ -9320,61 +9853,67 @@ var build = async ({
     const capturedEnv = { ...pythonEnv };
     const capturedCwd = workPath;
     registerPreDeploy(async () => {
-      await builderSpan.child(import_build_utils19.BUILDER_PRE_DEPLOY_STEP, {
+      await builderSpan.child(import_build_utils20.BUILDER_PRE_DEPLOY_STEP, {
         preDeployCommand
       }).trace(async () => {
         console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
-        await (0, import_build_utils19.execCommand)(preDeployCommand, {
+        await (0, import_build_utils20.execCommand)(preDeployCommand, {
           env: capturedEnv,
           cwd: capturedCwd
         });
       });
     });
   }
-  (0, import_build_utils19.debug)("Entrypoint is", entrypoint);
-  const moduleName = entrypointToModule(entrypoint);
-  if (handlerFunction) {
-    const entrypointPath = (0, import_path15.join)(workPath, entrypoint);
-    const source = await import_fs15.default.promises.readFile(entrypointPath, "utf-8");
-    const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
-    if (!found) {
-      throw new import_build_utils19.NowBuildError({
-        code: "PYTHON_HANDLER_NOT_FOUND",
-        message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
-      });
+  const vendorDir = resolveVendorDir();
+  let crons;
+  let runtimeTrampoline;
+  if (entrypoint) {
+    (0, import_build_utils20.debug)("Entrypoint is", entrypoint);
+    const moduleName = entrypointToModule(entrypoint);
+    if (handlerFunction) {
+      const entrypointPath = (0, import_path17.join)(workPath, entrypoint);
+      const source = await import_fs17.default.promises.readFile(entrypointPath, "utf-8");
+      const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
+      if (!found) {
+        throw new import_build_utils20.NowBuildError({
+          code: "PYTHON_HANDLER_NOT_FOUND",
+          message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+        });
+      }
     }
+    const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
+    const entrypointWithSuffix = `${entrypoint}${suffix}`;
+    (0, import_build_utils20.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+    crons = await getServiceCrons({
+      service,
+      entrypoint,
+      rawEntrypoint,
+      handlerFunction,
+      pythonBin: getVenvPythonBin(venvPath),
+      env: pythonEnv,
+      workPath
+    });
+    const extraTrampolineEnv = [];
+    if (crons?.length) {
+      const json = JSON.stringify(buildCronRouteTable(crons));
+      (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
+      extraTrampolineEnv.push(`"__VC_CRON_ROUTES": '${json}'`);
+    }
+    const variableName = resolved?.variableName ?? "";
+    runtimeTrampoline = createRuntimeTrampoline({
+      moduleName,
+      entrypoint: entrypointWithSuffix,
+      vendorDir,
+      variableName,
+      extraEnv: extraTrampolineEnv
+    });
   }
-  const vendorDir = resolveVendorDir();
-  const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
-  const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils19.debug)("Entrypoint with suffix is", entrypointWithSuffix);
-  const crons = await getServiceCrons({
-    service,
-    entrypoint,
-    rawEntrypoint,
-    handlerFunction,
-    pythonBin: getVenvPythonBin(venvPath),
-    env: pythonEnv,
-    workPath
-  });
-  const extraTrampolineEnv = [];
-  if (crons?.length) {
-    const json = JSON.stringify(buildCronRouteTable(crons));
-    (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
-    extraTrampolineEnv.push(`"__VC_CRON_ROUTES": '${json}'`);
-  }
-  const variableName = resolved?.variableName ?? "";
-  const runtimeTrampoline = createRuntimeTrampoline({
-    moduleName,
-    entrypoint: entrypointWithSuffix,
-    vendorDir,
-    variableName,
-    extraEnv: extraTrampolineEnv
-  });
-  const automaticCompileAllEnabled = shouldUseCompileAll({
+  const compileAllEnabled = shouldCompileAll({
     isDev: meta.isDev,
     hasCustomCommand,
-    hasCustomBuildCommand
+    // A pre-deploy command can rewrite source after the build, which would make
+    // unchecked-hash precompiled bytecode stale; skip precompilation to avoid serving it.
+    hasPreDeployCommand: typeof preDeployCommand === "string"
   });
   const predefinedExcludes = [
     ".git/**",
@@ -9405,16 +9944,16 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils19.glob)("**", globOptions);
+  const files = await (0, import_build_utils20.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils19.FileFsRef({
-      fsPath: (0, import_path15.join)(workPath, djangoStatic.manifestRelPath)
+    files[djangoStatic.manifestRelPath] = new import_build_utils20.FileFsRef({
+      fsPath: (0, import_path17.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
   const handlerPyFilename = "vc__handler__python";
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils19.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils20.FileBlob({ data: `"${SESSKEY}"` });
   }
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
@@ -9443,99 +9982,217 @@ var build = async ({
         });
       }
     });
-    const runCompileAllAndFillBytecode = async () => {
-      await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
-        const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs15.default.existsSync(d));
-        const pythonBin = getVenvPythonBin(venvPath);
-        console.log("Compiling Python application bytecode...");
-        await runCompileAll({
-          pythonBin,
-          filesOrDirectories: [workPath],
-          env: pythonEnv,
-          excludeRegex: getCompileAllAppExcludeRegex(workPath)
+    const runCompileAllAndFillBytecode = async (capacityBytes, vendorPackageTiers) => {
+      try {
+        await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
+          const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs17.default.existsSync(d));
+          const pythonBin = getVenvPythonBin(venvPath);
+          console.log("Compiling Python bytecode...");
+          await runCompileAll({
+            pythonBin,
+            filesOrDirectories: [workPath],
+            env: pythonEnv,
+            excludeRegex: getCompileAllAppExcludeRegex(workPath)
+          });
+          await runCompileAll({
+            pythonBin,
+            filesOrDirectories: sitePackageDirs,
+            env: pythonEnv
+          });
+          compileSpan.setAttributes({
+            "python.compileall.enabled": "true",
+            "python.compileall.sitePackageDirectoryCount": String(
+              sitePackageDirs.length
+            )
+          });
         });
-        console.log("Compiling Python dependency bytecode...");
-        await runCompileAll({
-          pythonBin,
-          filesOrDirectories: sitePackageDirs,
-          env: pythonEnv
+        const currentSize = await calculateBundleSize(files);
+        let remainingCapacity = capacityBytes - currentSize;
+        if (pythonVersion.major != null && pythonVersion.minor != null) {
+          const appBytecodeInfo = await collectAppBytecodeFiles({
+            workPath,
+            files,
+            pythonMajor: pythonVersion.major,
+            pythonMinor: pythonVersion.minor
+          });
+          remainingCapacity = addBytecodeWithinCapacity(
+            files,
+            appBytecodeInfo,
+            remainingCapacity
+          );
+        }
+        await addVendorBytecodeInTiers({
+          files,
+          depExternalizer,
+          vendorDir,
+          capacity: remainingCapacity,
+          vendorPackageTiers: vendorPackageTiers ?? [void 0]
         });
-        compileSpan.setAttributes({
-          "python.compileall.enabled": "true",
-          "python.compileall.sitePackageDirectoryCount": String(
-            sitePackageDirs.length
-          )
+      } catch (err) {
+        console.log(
+          "Bytecode precompilation failed; continuing without precompiled bytecode."
+        );
+        (0, import_build_utils20.debug)(`bytecode precompilation error details: ${err}`);
+      }
+    };
+    const runPrefixCompileAndFill = async (bundleResult) => {
+      const pyMajor = pythonVersion.major;
+      const pyMinor = pythonVersion.minor;
+      if (pyMajor == null || pyMinor == null)
+        return;
+      try {
+        const currentSize = await calculateBundleSize(files);
+        let remainingCapacity = BYTECODE_FILL_CEILING_BYTES - currentSize;
+        if (remainingCapacity <= 0) {
+          (0, import_build_utils20.debug)(
+            `skipping bytecode precompilation: no zip capacity remaining (bundle is ${(currentSize / (1024 * 1024)).toFixed(2)} MB)`
+          );
+          return;
+        }
+        const stagingDir = (0, import_path17.join)(workPath, ".vercel", "python", "pycache");
+        await import_fs17.default.promises.rm(stagingDir, { recursive: true, force: true });
+        await import_fs17.default.promises.mkdir(stagingDir, { recursive: true });
+        await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
+          const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs17.default.existsSync(d));
+          const pythonBin = getVenvPythonBin(venvPath);
+          console.log("Compiling Python bytecode...");
+          await runCompileAll({
+            pythonBin,
+            filesOrDirectories: [workPath],
+            env: pythonEnv,
+            excludeRegex: getCompileAllAppExcludeRegex(workPath),
+            pycachePrefix: stagingDir
+          });
+          await runCompileAll({
+            pythonBin,
+            filesOrDirectories: sitePackageDirs,
+            env: pythonEnv,
+            pycachePrefix: stagingDir
+          });
+          compileSpan.setAttributes({
+            "python.compileall.enabled": "true",
+            "python.compileall.mode": "pycache-prefix",
+            "python.compileall.sitePackageDirectoryCount": String(
+              sitePackageDirs.length
+            )
+          });
         });
-      });
-      const currentSize = await calculateBundleSize(files);
-      let remainingCapacity = MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE - currentSize;
-      if (pythonVersion.major != null && pythonVersion.minor != null) {
-        const appBytecodeInfo = await collectAppBytecodeFiles({
+        const beforeCount = Object.keys(files).length;
+        const appInfo = await collectAppPrefixBytecodeFiles({
+          stagingDir,
           workPath,
           files,
-          pythonMajor: pythonVersion.major,
-          pythonMinor: pythonVersion.minor
+          runtimeTaskRoot: "/var/task",
+          pythonMajor: pyMajor,
+          pythonMinor: pyMinor
         });
         remainingCapacity = addBytecodeWithinCapacity(
           files,
-          appBytecodeInfo,
+          appInfo,
           remainingCapacity
         );
+        const alwaysBundled = bundleResult.alwaysBundledPackages ?? [];
+        remainingCapacity = await addCollectedVendorBytecode({
+          files,
+          capacity: remainingCapacity,
+          collect: (include) => depExternalizer.collectPrefixBytecodeFiles({
+            stagingDir,
+            runtimeRoot: `/var/task/${vendorDir}`,
+            includePackages: include ?? alwaysBundled
+          })
+        });
+        const externalized = bundleResult.externalizedPublicPackages ?? [];
+        await addCollectedVendorBytecode({
+          files,
+          capacity: remainingCapacity,
+          collect: (include) => depExternalizer.collectPrefixBytecodeFiles({
+            stagingDir,
+            runtimeRoot: `${RUNTIME_DEPS_DIR}/lib/python${pyMajor}.${pyMinor}/site-packages`,
+            includePackages: include ?? externalized
+          })
+        });
+        if (Object.keys(files).length > beforeCount) {
+          lambdaEnv.PYTHONPYCACHEPREFIX = RUNTIME_PYCACHE_PREFIX;
+        }
+      } catch (err) {
+        console.log(
+          "Bytecode precompilation failed; continuing without precompiled bytecode."
+        );
+        (0, import_build_utils20.debug)(`bytecode precompilation error details: ${err}`);
       }
-      const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles({
-        vendorDirName: vendorDir
-      });
-      await addVendorBytecodeWithinCapacity({
-        files,
-        depExternalizer,
-        vendorDir,
-        bytecodeInfo: vendorBytecodeInfo,
-        capacity: remainingCapacity
-      });
     };
     const announceLargeFunction = () => console.log(
-      `Function "${entrypoint}" exceeds the standard size limit; enabling large functions (beta).`
+      `Function "${entrypoint ?? rawEntrypoint}" exceeds the standard size limit; enabling large functions (beta).`
     );
     if (depAnalysis.runtimeInstallEnabled) {
-      const { fellBackToFullBundle } = await depExternalizer.generateBundle(files);
-      if (fellBackToFullBundle) {
+      const bytecodeFirst = compileAllEnabled && pythonVersion.major != null && pythonVersion.minor != null;
+      const bundleResult = await depExternalizer.generateBundle(files, {
+        bytecodeFirst
+      });
+      if (bundleResult.fellBackToFullBundle) {
         announceLargeFunction();
-        if (automaticCompileAllEnabled) {
-          await runCompileAllAndFillBytecode();
+        if (compileAllEnabled) {
+          await runCompileAllAndFillBytecode(
+            MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE
+          );
+        }
+      } else if (bundleResult.packingMode === "bytecode-first") {
+        await runPrefixCompileAndFill(bundleResult);
+      } else if (compileAllEnabled) {
+        const currentSize = await calculateBundleSize(files);
+        const capacity = BYTECODE_FILL_CEILING_BYTES - currentSize;
+        const estimate = await estimateBytecodeSize(files);
+        if (capacity >= BYTECODE_COVERAGE_FLOOR * estimate) {
+          await runCompileAllAndFillBytecode(BYTECODE_FILL_CEILING_BYTES, [
+            bundleResult.alwaysBundledPackages ?? [],
+            bundleResult.bundledPublicPackages ?? []
+          ]);
         }
       }
     } else {
       addFiles(files, depAnalysis.allVendorFiles);
-      if (isLargeFunctionsEnabled() && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
-        announceLargeFunction();
-      }
-      if (automaticCompileAllEnabled && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
-        await runCompileAllAndFillBytecode();
+      if (depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+        if (isLargeFunctionsEnabled()) {
+          announceLargeFunction();
+        }
+        if (compileAllEnabled) {
+          await runCompileAllAndFillBytecode(
+            MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE
+          );
+        }
+      } else if (compileAllEnabled) {
+        const capacity = BYTECODE_FILL_CEILING_BYTES - depAnalysis.totalBundleSize;
+        const estimate = await estimateBytecodeSize(files);
+        if (capacity >= BYTECODE_COVERAGE_FLOOR * estimate) {
+          await runCompileAllAndFillBytecode(BYTECODE_FILL_CEILING_BYTES);
+        }
       }
     }
   });
-  const webFiles = {
-    ...files,
-    [`${handlerPyFilename}.py`]: new import_build_utils19.FileBlob({ data: runtimeTrampoline })
-  };
-  const lambdaOptions = await getPythonLambdaOptions({
-    config,
-    entrypoint
-  });
-  const output = new import_build_utils19.Lambda({
-    files: webFiles,
-    handler: `${handlerPyFilename}.vc_handler`,
-    runtime: pythonVersion.runtime,
-    ...lambdaOptions,
-    architecture: target.architecture,
-    environment: lambdaEnv,
-    supportsResponseStreaming: true
-  });
+  let output;
+  if (entrypoint && runtimeTrampoline) {
+    const webFiles = {
+      ...files,
+      [`${handlerPyFilename}.py`]: new import_build_utils20.FileBlob({ data: runtimeTrampoline })
+    };
+    const lambdaOptions = await getPythonLambdaOptions({
+      config,
+      entrypoint
+    });
+    output = new import_build_utils20.Lambda({
+      files: webFiles,
+      handler: `${handlerPyFilename}.vc_handler`,
+      runtime: pythonVersion.runtime,
+      ...lambdaOptions,
+      architecture: target.architecture,
+      environment: lambdaEnv,
+      supportsResponseStreaming: true
+    });
+  }
   const subscriberLambdas = {};
   for (const subscriber of subscribers) {
-    const safeName = safePathSegment(subscriber.name);
-    const outputPath = `_py_subscribers/${safeName}`;
-    const consumer = (0, import_build_utils19.sanitizeConsumerName)(outputPath);
+    const outputPath = getSubscriberOutputPath(subscriber.name);
+    const consumer = getSubscriberConsumerName(subscriber.name);
     const experimentalTriggers = subscriber.topics.map(
       (topic) => ({
         type: "queue/v2beta",
@@ -9544,10 +10201,10 @@ var build = async ({
         ...subscriber.triggerDefaults
       })
     );
-    subscriberLambdas[outputPath] = new import_build_utils19.Lambda({
+    subscriberLambdas[outputPath] = new import_build_utils20.Lambda({
       files: {
         ...files,
-        [`${handlerPyFilename}.py`]: new import_build_utils19.FileBlob({
+        [`${handlerPyFilename}.py`]: new import_build_utils20.FileBlob({
           data: createRuntimeTrampoline({
             moduleName: subscriber.moduleName,
             entrypoint: subscriber.entrypoint,
@@ -9562,6 +10219,42 @@ var build = async ({
       environment: {
         ...lambdaEnv,
         VERCEL_HAS_WORKER_SERVICES: "1",
+        // Compatibility marker consumed by the current Python runtime.
+        VERCEL_SERVICE_TYPE: "worker"
+      },
+      experimentalTriggers,
+      supportsResponseStreaming: true
+    });
+  }
+  const workflowLambdas = {};
+  for (const workflow of workflows) {
+    const outputPath = getWorkflowOutputPath(workflow.name);
+    const experimentalTriggers = [
+      {
+        type: "queue/v2beta",
+        topic: WORKFLOW_TOPIC_PATTERN,
+        consumer: getWorkflowConsumerName(workflow.name)
+      }
+    ];
+    workflowLambdas[outputPath] = new import_build_utils20.Lambda({
+      files: {
+        ...files,
+        [`${handlerPyFilename}.py`]: new import_build_utils20.FileBlob({
+          data: createRuntimeTrampoline({
+            moduleName: workflow.moduleName,
+            entrypoint: workflow.entrypoint,
+            vendorDir,
+            variableName: workflow.variableName
+          })
+        })
+      },
+      handler: `${handlerPyFilename}.vc_handler`,
+      runtime: pythonVersion.runtime,
+      architecture: target.architecture,
+      environment: {
+        ...lambdaEnv,
+        VERCEL_HAS_WORKER_SERVICES: "1",
+        // Compatibility marker consumed by the current Python runtime.
         VERCEL_SERVICE_TYPE: "worker"
       },
       experimentalTriggers,
@@ -9576,21 +10269,22 @@ var build = async ({
         pythonVersion,
         uvLockPath,
         framework,
-        serviceType: service ? (0, import_build_utils19.getReportedServiceType)(service) : void 0
+        serviceType: service ? (0, import_build_utils20.getReportedServiceType)(service) : void 0
       });
     } catch (err) {
-      (0, import_build_utils19.debug)(
+      (0, import_build_utils20.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (!(0, import_build_utils19.isPythonFramework)(framework) && !service?.name) {
+  if (!(0, import_build_utils20.isPythonFramework)(framework) && !service?.name && !isPyprojectEntrypoint) {
+    (0, import_assert.default)(output, "web Lambda must exist for non-service builds");
     return { resultVersion: 3, result: { output } };
   }
   const lambdaPath = service?.name && service.type ? `_svc/${service.name}/index` : "index";
-  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils19.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils20.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
   const isNonWebService = service?.name && service.type && service.type !== "web";
-  const routes = isNonWebService ? void 0 : [
+  const routes = isNonWebService || !output ? void 0 : [
     { handle: "filesystem" },
     { src: "/(.*)", dest: `/${lambdaPath}` }
   ];
@@ -9598,8 +10292,9 @@ var build = async ({
     resultVersion: 2,
     result: {
       output: {
-        [lambdaPath]: output,
+        ...output ? { [lambdaPath]: output } : {},
         ...subscriberLambdas,
+        ...workflowLambdas,
         ...staticFiles
       },
       ...routes ? { routes } : {},
@@ -9622,14 +10317,14 @@ var prepareCache = async ({
     }
   } catch {
   }
-  return (0, import_build_utils19.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
+  return (0, import_build_utils20.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
     cwd: root,
     ignore
   });
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils19.isPythonFramework)(framework)) {
+  if ((0, import_build_utils20.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -9648,7 +10343,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path15.parse)(entrypoint);
+  const { dir, name } = (0, import_path17.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -9659,11 +10354,14 @@ function hasProp(obj, key) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addCollectedVendorBytecode,
+  addVendorBytecodeInTiers,
   build,
   defaultShouldServe,
   detectEntrypoint,
   diagnostics,
   downloadFilesInWorkPath,
+  getDevSidecars,
   installRequirement,
   installRequirementsFile,
   prepareCache,