@vercel/python 6.47.3 → 6.49.0

package/dist/index.js

@@ -4366,6 +4366,7 @@ __export(src_exports, {
   detectEntrypoint: () => detectEntrypoint,
   diagnostics: () => diagnostics,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
+  getDevSidecars: () => getDevSidecars,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
   prepareCache: () => prepareCache,
@@ -5649,33 +5650,26 @@ 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;
+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,
@@ -5698,7 +5692,10 @@ async function runCompileAll({
     ...filesOrDirectories
   ];
   try {
-    await (0, import_execa4.default)(pythonBin, args, { env: env || process.env });
+    await (0, import_execa4.default)(pythonBin, args, {
+      env: env || process.env,
+      timeout: COMPILEALL_TIMEOUT_MS
+    });
   } catch (err) {
     (0, import_build_utils6.debug)(`compileall error details: ${JSON.stringify(err)}`);
   }
@@ -5774,6 +5771,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,6 +5797,8 @@ 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 MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE = 5 * 1024 * 1024 * 1024;
 var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
@@ -6510,10 +6515,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 +6528,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 +6551,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 [];
@@ -6870,7 +6886,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 +6962,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 +7146,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 +7185,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 +7225,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 +7462,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 +7622,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 +7784,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,14 +7864,15 @@ 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) {
     resolved = detected.entrypoint;
   } else {
-    const hookResult = await runFrameworkHook(framework, {
+    hookResult = await runFrameworkHook(framework, {
       pythonEnv: env,
-      projectDir: (0, import_path10.join)(workPath, detected?.baseDir ?? ""),
       workPath,
       entrypoint,
       detected: detected ?? void 0
@@ -7893,7 +7979,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(
       {
@@ -7945,6 +8035,9 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
       }
+      if (hookResult?.extraPythonPath) {
+        pathParts.push(hookResult.extraPythonPath);
+      }
       const existingPythonPath = env.PYTHONPATH || "";
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
@@ -8493,7 +8586,7 @@ async function getDjangoSettings(projectDir, env) {
     djangoVersion: parsed.django_version ?? null
   };
 }
-async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings, djangoVersion) {
+async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outputStaticDir, settingsModule, djangoSettings, djangoVersion) {
   const pythonPath = getVenvPythonBin(venvPath);
   const storages = djangoSettings["STORAGES"];
   const useLegacySetting = !djangoVersion || djangoVersion[0] < 5 || djangoVersion[0] === 5 && djangoVersion[1] < 1;
@@ -8505,7 +8598,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
   const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
   const staticSourceDirs = [
-    ...installedApps.map((app) => (0, import_path13.join)(workPath, ...app.split("."), "static")),
+    ...installedApps.map((app) => (0, import_path13.join)(djangoPath, ...app.split("."), "static")),
     // TODO: Deal with optional prefixes in STATICFILES_DIRS.
     ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
   ].filter((d) => import_fs13.default.existsSync(d));
@@ -8515,11 +8608,11 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     );
     await (0, import_execa7.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
       env: { ...env, DJANGO_SETTINGS_MODULE: settingsModule },
-      cwd: workPath
+      cwd: djangoPath
     });
     return {
       staticSourceDirs,
-      staticRoot: staticRoot ? (0, import_path13.resolve)(workPath, staticRoot) : null,
+      staticRoot: staticRoot ? (0, import_path13.resolve)(djangoPath, staticRoot) : null,
       cdnOutputDir: null,
       manifestRelPath: null
     };
@@ -8533,7 +8626,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
   const staticOutputDir = (0, import_path13.join)(outputStaticDir, staticUrlPath);
   await import_fs13.default.promises.mkdir(staticOutputDir, { recursive: true });
-  const shimPath = (0, import_path13.join)(workPath, "_vercel_collectstatic_settings.py");
+  const shimPath = (0, import_path13.join)(djangoPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
     `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
@@ -8549,7 +8642,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
         ...env,
         DJANGO_SETTINGS_MODULE: "_vercel_collectstatic_settings"
       },
-      cwd: workPath
+      cwd: djangoPath
     });
   } finally {
     await import_fs13.default.promises.unlink(shimPath).catch(() => {
@@ -8562,7 +8655,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   let manifestRelPath = null;
   if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
     const manifestSrc = (0, import_path13.join)(staticOutputDir, "staticfiles.json");
-    const resolvedStaticRoot = (0, import_path13.resolve)(workPath, staticRoot);
+    const resolvedStaticRoot = (0, import_path13.resolve)(djangoPath, staticRoot);
     const manifestDest = (0, import_path13.join)(resolvedStaticRoot, "staticfiles.json");
     await import_fs13.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
     await import_fs13.default.promises.copyFile(manifestSrc, manifestDest);
@@ -8571,7 +8664,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   }
   return {
     staticSourceDirs,
-    staticRoot: staticRoot ? (0, import_path13.resolve)(workPath, staticRoot) : null,
+    staticRoot: staticRoot ? (0, import_path13.resolve)(djangoPath, staticRoot) : null,
     cdnOutputDir: outputStaticDir,
     manifestRelPath
   };
@@ -8584,8 +8677,8 @@ var import_python_analysis9 = require("@vercel/python-analysis");
 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]*)$/;
+var SUBSCRIBER_OUTPUT_DIR = "_py_subscribers";
 var TRIGGER_NUMBER_FIELDS = [
   {
     field: "max_deliveries",
@@ -8625,6 +8718,12 @@ function safePathSegment(value) {
     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)) {
@@ -8635,37 +8734,38 @@ 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(
-      `subscriber "${name}" must define string field "entrypoint"`
-    );
+    throw subscriberError(`${label} must define string field "entrypoint"`);
   }
-  const entrypoint = parseEntrypoint(name, config.entrypoint);
+  const entrypoint = parseEntrypoint(label, config.entrypoint);
+  const name = getSubscriberName(entrypoint);
   const existingEntrypoint = await resolveExistingEntrypoint(
     workPath,
     entrypoint.filePath
@@ -8684,6 +8784,12 @@ async function parseSubscriber(workPath, name, config) {
     triggerDefaults: parseTriggerDefaults(name, config)
   };
 }
+function getSubscriberName({
+  moduleName,
+  variableName
+}) {
+  return `${moduleName.replace(/\./g, "-")}_${variableName}`;
+}
 function parseEntrypoint(name, value) {
   const match = MODULE_ATTR_RE.exec(value);
   if (!match) {
@@ -8752,6 +8858,40 @@ function subscriberError(message) {
 var writeFile = import_fs15.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_utils19.isPythonFramework)(framework)) {
+    return [];
+  }
+  const subscribers = await getPyprojectSubscribers(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)
+  }));
+}
 function addFiles(target, source) {
   for (const [p, f] of Object.entries(source)) {
     target[p] = f;
@@ -8807,18 +8947,22 @@ async function runFrameworkHook(framework, ctx) {
 var frameworkHooks = {
   django: async ({
     pythonEnv,
-    projectDir,
     workPath,
     venvPath,
     detected
   }) => {
-    if (detected?.baseDir === void 0) {
-      (0, import_build_utils19.debug)("Django hook: no manage.py detected, skipping");
-      return;
+    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");
+        return;
+      }
+      baseDir = "";
     }
+    const djangoPath = (0, import_path15.join)(workPath, baseDir);
     let settingsResult;
     try {
-      settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+      settingsResult = await getDjangoSettings(djangoPath, pythonEnv);
     } catch (err) {
       let detail;
       if (err?.code === "ENOENT") {
@@ -8829,7 +8973,7 @@ Hint: activate a venv or run with \`uv run vercel dev\``;
       }
       throw new import_build_utils19.NowBuildError({
         code: "DJANGO_SETTINGS_FAILED",
-        message: `Failed to read Django application settings from ${projectDir}/manage.py:
+        message: `Failed to read Django application settings from ${djangoPath}/manage.py:
 ${detail}`
       });
     }
@@ -8839,7 +8983,6 @@ ${detail}`
       console.log(`Django ${djangoVersion.join(".")} detected`);
     }
     let resolvedEntrypoint;
-    const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
       const parts = asgiApp.split(".");
@@ -8867,6 +9010,7 @@ ${detail}`
       djangoStatic = await runDjangoCollectStatic(
         venvPath,
         workPath,
+        djangoPath,
         pythonEnv,
         outputStaticDir,
         settingsModule,
@@ -8874,7 +9018,11 @@ ${detail}`
         djangoVersion
       );
     }
-    return { entrypoint: resolvedEntrypoint, djangoStatic };
+    return {
+      entrypoint: resolvedEntrypoint,
+      djangoStatic,
+      extraPythonPath: baseDir ? (0, import_path15.join)(workPath, baseDir) : void 0
+    };
   }
 };
 function createRuntimeTrampoline({
@@ -9041,7 +9189,6 @@ var build = async ({
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  let hasCustomBuildCommand = false;
   const target = getTargetPlatform(meta.isDev ?? false);
   (0, import_build_utils19.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
@@ -9074,7 +9221,8 @@ var build = async ({
       // 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
+    service,
+    repoRootPath
   ) ?? void 0;
   if (detected?.error && detected?.baseDir === void 0) {
     throw detected?.error;
@@ -9247,22 +9395,17 @@ var build = async ({
           env: pythonEnv,
           cwd: workPath
         });
-        hasCustomBuildCommand = true;
       } else {
-        const ranBuildScript = await runPyprojectScript(
+        await runPyprojectScript(
           workPath,
           ["vercel-build", "now-build", "build"],
           pythonEnv
         );
-        if (ranBuildScript) {
-          hasCustomBuildCommand = true;
-        }
       }
     });
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path15.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -9361,10 +9504,12 @@ var build = async ({
     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/**",
@@ -9433,55 +9578,63 @@ 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)
-        });
-        console.log("Compiling Python dependency bytecode...");
-        await runCompileAll({
-          pythonBin,
-          filesOrDirectories: sitePackageDirs,
-          env: pythonEnv
-        });
-        compileSpan.setAttributes({
-          "python.compileall.enabled": "true",
-          "python.compileall.sitePackageDirectoryCount": String(
-            sitePackageDirs.length
-          )
+    const runCompileAllAndFillBytecode = async (capacityBytes) => {
+      try {
+        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 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
+            )
+          });
         });
-      });
-      const currentSize = await calculateBundleSize(files);
-      let remainingCapacity = MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE - currentSize;
-      if (pythonVersion.major != null && pythonVersion.minor != null) {
-        const appBytecodeInfo = await collectAppBytecodeFiles({
-          workPath,
+        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
+          );
+        }
+        const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles(
+          {
+            vendorDirName: vendorDir
+          }
+        );
+        await addVendorBytecodeWithinCapacity({
           files,
-          pythonMajor: pythonVersion.major,
-          pythonMinor: pythonVersion.minor
+          depExternalizer,
+          vendorDir,
+          bytecodeInfo: vendorBytecodeInfo,
+          capacity: remainingCapacity
         });
-        remainingCapacity = addBytecodeWithinCapacity(
-          files,
-          appBytecodeInfo,
-          remainingCapacity
+      } catch (err) {
+        console.log(
+          "Bytecode precompilation failed; continuing without precompiled bytecode."
         );
+        (0, import_build_utils19.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).`
@@ -9490,17 +9643,29 @@ var build = async ({
       const { fellBackToFullBundle } = await depExternalizer.generateBundle(files);
       if (fellBackToFullBundle) {
         announceLargeFunction();
-        if (automaticCompileAllEnabled) {
-          await runCompileAllAndFillBytecode();
+        if (compileAllEnabled) {
+          await runCompileAllAndFillBytecode(
+            MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE
+          );
         }
       }
     } 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);
+        }
       }
     }
   });
@@ -9523,9 +9688,8 @@ var build = async ({
   });
   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",
@@ -9552,6 +9716,7 @@ var build = async ({
       environment: {
         ...lambdaEnv,
         VERCEL_HAS_WORKER_SERVICES: "1",
+        // Compatibility marker consumed by the current Python runtime.
         VERCEL_SERVICE_TYPE: "worker"
       },
       experimentalTriggers,
@@ -9654,6 +9819,7 @@ function hasProp(obj, key) {
   detectEntrypoint,
   diagnostics,
   downloadFilesInWorkPath,
+  getDevSidecars,
   installRequirement,
   installRequirementsFile,
   prepareCache,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.47.3",
+  "version": "6.49.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -36,8 +36,8 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.32.1",
     "@vercel/error-utils": "2.2.0",
+    "@vercel/build-utils": "13.32.3",
     "@vercel/python-runtime": "0.16.0"
   },
   "scripts": {