@vercel/python 6.48.0 → 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;
+  if (hasPreDeployCommand)
     return false;
-  return isCompileAllEnabled();
+  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,7 +7864,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 +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(
       {
@@ -8587,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",
@@ -8628,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)) {
@@ -8638,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
@@ -8687,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) {
@@ -8755,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;
@@ -9052,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({
@@ -9085,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;
@@ -9258,16 +9395,12 @@ 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;
-        }
       }
     });
   }
@@ -9371,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/**",
@@ -9443,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).`
@@ -9500,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);
+        }
       }
     }
   });
@@ -9533,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",
@@ -9562,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,
@@ -9664,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.48.0",
+  "version": "6.49.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -37,7 +37,7 @@
     "vitest": "2.1.4",
     "which": "3.0.0",
     "@vercel/error-utils": "2.2.0",
-    "@vercel/build-utils": "13.32.2",
+    "@vercel/build-utils": "13.32.3",
     "@vercel/python-runtime": "0.16.0"
   },
   "scripts": {