@vercel/python 14.2.1 → 16.0.0

package/dist/index.js

@@ -7078,6 +7078,7 @@ var UvRunner = class {
       frozen,
       noBuild,
       noInstallProject,
+      onlyGroup,
       pythonPlatform
     } = options;
     const args = ["sync", "--active", "--no-dev", "--link-mode", "hardlink"];
@@ -7092,6 +7093,9 @@ var UvRunner = class {
     if (noInstallProject) {
       args.push("--no-install-project");
     }
+    if (onlyGroup) {
+      args.push("--only-group", onlyGroup);
+    }
     if (pythonPlatform) {
       args.push("--python-platform", pythonPlatform);
     }
@@ -12935,6 +12939,7 @@ function getImportClosureOptions({
 }
 
 // src/index.ts
+var import_build_utils25 = require("@vercel/build-utils");
 var writeFile = import_fs20.default.promises.writeFile;
 var PYTHON_ENTRYPOINT_DOCS_URL2 = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 var version = -1;
@@ -13330,95 +13335,17 @@ async function installInjectedPackage({
     ]
   });
 }
-var build = async ({
+async function setupPythonToolchain({
+  builderSpan,
   workPath,
-  repoRootPath,
-  files: originalFiles,
-  entrypoint: rawEntrypoint,
-  meta = {},
-  config,
-  span: parentSpan,
-  service,
-  registerPreDeploy
-}) => {
-  let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
-  const isPyprojectEntrypoint = entrypoint !== void 0 && (0, import_path21.basename)(entrypoint) === "pyproject.toml";
-  if (isPyprojectEntrypoint && entrypoint !== "pyproject.toml") {
-    throw new import_build_utils24.NowBuildError({
-      code: "PYTHON_INVALID_PYPROJECT_ENTRYPOINT",
-      message: `A "pyproject.toml" entrypoint must sit at the service root. Set the service "root" to "${(0, import_path21.dirname)(entrypoint)}" and use entrypoint "pyproject.toml".`
-    });
-  }
-  const builderSpan = parentSpan ?? new import_build_utils24.Span({ name: "vc.builder" });
-  const framework = config?.framework;
-  let subscriberDeclarations = [];
-  let subscribers = [];
-  let workflows = [];
-  let legacyWorkersProject = false;
-  let workflowMode = "workers";
-  let spawnEnv;
-  let projectInstallCommand;
-  let hasCustomCommand = false;
-  const target = getTargetPlatform(meta.isDev ?? false);
-  (0, import_build_utils24.debug)(`workPath: ${workPath}`);
-  workPath = await downloadFilesInWorkPath({
-    workPath,
-    files: originalFiles,
-    entrypoint,
-    meta
-  });
-  legacyWorkersProject = await isLegacyWorkersProject(workPath);
-  if (isPyprojectEntrypoint || !service && (0, import_build_utils24.isPythonFramework)(framework)) {
-    subscriberDeclarations = await getPyprojectSubscribers(workPath, {
-      legacySchema: legacyWorkersProject
-    });
-    workflows = await getPyprojectWorkflows(workPath);
-  }
-  try {
-    if (meta.isDev) {
-      const setupCfg = (0, import_path21.join)(workPath, "setup.cfg");
-      await writeFile(setupCfg, "[install]\nprefix=\n");
-    }
-  } catch (err) {
-    console.log('Failed to create "setup.cfg" file');
-    throw err;
-  }
-  let detected;
-  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
-  if (isPyprojectEntrypoint) {
-    const declared = await getVercelToolsEntrypoint(workPath, repoRootPath);
-    if (declared) {
-      detected = { entrypoint: declared };
-    } else if (subscriberDeclarations.length === 0 && workflows.length === 0) {
-      throw new import_build_utils24.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_utils24.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_path21.dirname)(entrypoint) : ".");
-  const entrypointAbsDir = (0, import_path21.join)(workPath, entryDirectory);
-  const rootDir = repoRootPath ?? workPath;
+  entrypointDir,
+  rootDir,
+  venvPath,
+  meta
+}) {
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
-      entrypointDir: entrypointAbsDir,
+      entrypointDir,
       rootDir
     })
   );
@@ -13455,7 +13382,6 @@ var build = async ({
   }
   const uvVersion = checkUvBinaryVersion(uv.getPath());
   console.log(`Using ${uvVersion}`);
-  const venvPath = service?.name ? (0, import_path21.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path21.join)(workPath, ".vercel", "python", ".venv");
   const hasCachedVenv = import_fs20.default.existsSync((0, import_path21.join)(venvPath, "pyvenv.cfg"));
   const hasCachedUv = import_fs20.default.existsSync(uvCacheDir);
   const restoredCache = hasCachedVenv && hasCachedUv ? "both" : hasCachedVenv ? "venv" : hasCachedUv ? "uv" : "none";
@@ -13472,377 +13398,67 @@ var build = async ({
       uvCacheDir
     });
   });
-  if ((0, import_build_utils24.isPythonFramework)(framework)) {
-    const {
-      cliType,
-      lockfileVersion,
-      packageJsonPackageManager,
-      packageJsonDevEngines,
-      turboSupportsCorepackHome
-    } = await (0, import_build_utils24.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils24.getEnvForPackageManager)({
-      cliType,
-      lockfileVersion,
-      packageJsonPackageManager,
-      packageJsonDevEngines,
-      env: process.env,
-      turboSupportsCorepackHome,
-      projectCreatedAt: config?.projectSettings?.createdAt
-    });
-    const installCommand = config?.projectSettings?.installCommand;
-    if (typeof installCommand === "string") {
-      const trimmed = installCommand.trim();
-      if (trimmed) {
-        projectInstallCommand = trimmed;
-      } else {
-        console.log('Skipping "install" command...');
-      }
-    }
-  }
-  const baseEnv = spawnEnv || process.env;
-  const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
-  pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
-  let assumeDepsInstalled = false;
-  let uvLockPath = null;
-  let uvProjectDir = null;
-  let projectName;
-  let usedUvManagedInstall = false;
-  await builderSpan.child(import_build_utils24.BUILDER_INSTALLER_STEP, {
-    installCommand: projectInstallCommand || void 0,
-    runtime: "python",
-    "python.cache.restored": restoredCache
-  }).trace(async () => {
-    if (projectInstallCommand) {
-      await import_fs20.default.promises.rm(venvPath, { recursive: true, force: true });
-      await ensureVenv({
-        pythonVersion,
-        venvPath,
-        uvPath: uv.getPath(),
-        uvCacheDir,
-        quiet: true
-      });
-      console.log(
-        `Running "install" command: \`${projectInstallCommand}\`...`
-      );
-      await (0, import_build_utils24.execCommand)(projectInstallCommand, {
-        env: pythonEnv,
-        cwd: workPath
-      });
-      assumeDepsInstalled = true;
-      hasCustomCommand = true;
-    } else {
-      const hasCustomScript = await runPyprojectScript(
-        workPath,
-        ["vercel-install", "now-install", "install"],
-        pythonEnv,
-        /* useUserVirtualEnv */
-        false
-      );
-      if (hasCustomScript) {
-        assumeDepsInstalled = true;
-        hasCustomCommand = true;
-      }
-    }
-    if (!assumeDepsInstalled) {
-      const lockCacheKey = service?.name ? `uv.lock.${service.name}` : "uv.lock";
-      const cachedLockPath = (0, import_path21.join)(uvCacheDir, lockCacheKey);
-      const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
-        workPath,
-        rootDir,
-        venvPath,
-        pythonPackage,
-        pythonVersion: pythonVersionString(pythonVersion),
-        uv,
-        requireBinaryWheels: false,
-        cachedLockPath
-      });
-      uvLockPath = lockPath;
-      uvProjectDir = projectDir;
-      projectName = pythonPackage?.manifest?.data?.project?.name;
-      await uv.sync({
-        venvPath,
-        projectDir,
-        frozen: lockFileProvidedByUser,
-        locked: !lockFileProvidedByUser,
-        pythonPlatform: target.uvPlatform
-      });
-      usedUvManagedInstall = true;
-      if (lockPath && import_fs20.default.existsSync(lockPath)) {
-        await import_fs20.default.promises.mkdir(uvCacheDir, { recursive: true });
-        await import_fs20.default.promises.copyFile(lockPath, cachedLockPath);
-      }
-    }
-  });
-  if ((0, import_build_utils24.isPythonFramework)(framework)) {
-    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
-    config?.buildCommand;
-    await builderSpan.child(import_build_utils24.BUILDER_COMPILE_STEP, {
-      buildCommand: projectBuildCommand || void 0
-    }).trace(async () => {
-      if (projectBuildCommand) {
-        console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils24.execCommand)(projectBuildCommand, {
-          env: pythonEnv,
-          cwd: workPath
-        });
-      } else {
-        await runPyprojectScript(
-          workPath,
-          ["vercel-build", "now-build", "build"],
-          pythonEnv
-        );
-      }
-    });
-  }
-  const hookResult = await runFrameworkHook(framework, {
-    pythonEnv,
+  return { pythonPackage, pythonVersion, uv, uvCacheDir, restoredCache };
+}
+async function runUvManagedInstall({
+  workPath,
+  rootDir,
+  venvPath,
+  pythonPackage,
+  pythonVersion,
+  uv,
+  uvCacheDir,
+  lockCacheKey,
+  pythonPlatform,
+  extraSyncParams
+}) {
+  const cachedLockPath = (0, import_path21.join)(uvCacheDir, lockCacheKey);
+  const result = await ensureUvProject({
     workPath,
+    rootDir,
     venvPath,
-    entrypoint,
-    detected,
-    pyprojectData: pythonPackage.manifest?.data
-  });
-  const resolved = isPyprojectEntrypoint ? detected?.entrypoint : hookResult?.entrypoint ?? detected?.entrypoint;
-  if (!resolved && detected?.error) {
-    throw detected?.error;
-  }
-  entrypoint = resolved?.entrypoint;
-  const isWorkersOnly = !entrypoint && isPyprojectEntrypoint && (subscriberDeclarations.length > 0 || workflows.length > 0);
-  if (!entrypoint && !isWorkersOnly) {
-    throw new import_build_utils24.NowBuildError({
-      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
-      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
-    });
-  }
-  const djangoStatic = hookResult?.djangoStatic ?? null;
-  const fastapiStatic = hookResult?.fastapiStatic ?? null;
-  const importSeeds = hookResult?.importSeeds ?? [];
-  const cdnOutputDir = djangoStatic?.cdnOutputDir ?? fastapiStatic?.cdnOutputDir ?? null;
-  const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
-  await installInjectedPackage({
-    name: "vercel-runtime",
-    requirement: `vercel-runtime==${VERCEL_RUNTIME_VERSION}`,
-    envOverride: baseEnv.VERCEL_RUNTIME_PYTHON,
-    allowLocalSource: true,
-    uv,
-    venvPath,
-    projectDir: (0, import_path21.join)(workPath, entryDirectory),
-    pipPlatformArgs
-  });
-  const queueAdapterBootstrap = await getQueueAdapterBootstrap({
     pythonPackage,
-    env: baseEnv,
-    legacyWorkersProject,
-    hasDeclaredSubscribers: await hasPyprojectSubscribers(workPath)
+    pythonVersion: pythonVersionString(pythonVersion),
+    uv,
+    requireBinaryWheels: false,
+    cachedLockPath
   });
-  const queueAdapterInjectedPackages = usedUvManagedInstall ? queueAdapterBootstrap.injectedPackages : [];
-  for (const injectedPackage of queueAdapterInjectedPackages) {
-    await installInjectedPackage({
-      ...injectedPackage,
-      uv,
+  const { projectDir, lockPath, lockFileProvidedByUser } = result;
+  if (extraSyncParams !== void 0) {
+    await uv.sync({
       venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      pipPlatformArgs
+      projectDir,
+      frozen: lockFileProvidedByUser,
+      locked: !lockFileProvidedByUser,
+      pythonPlatform,
+      ...extraSyncParams
     });
   }
-  const localSdkSourcePaths = await getLocalSdkSourcePaths({
-    pythonPackage,
-    env: baseEnv
-  });
-  if (localSdkSourcePaths.length > 0) {
-    (0, import_build_utils24.debug)(
-      `Installing vercel SDK override from ${baseEnv.VERCEL_SDK_PYTHON}: ` + localSdkSourcePaths.join(", ")
-    );
-    await uv.pip({
-      venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      args: [
-        "install",
-        "--link-mode",
-        "copy",
-        // Without --no-sources, uv resolves the checkout's workspace
-        // dependencies as editable .pth installs pointing at the (build
-        // only) checkout mount — invisible to bundling and dangling at
-        // runtime. Explicit paths stay real installs; the remaining
-        // workspace siblings resolve from PyPI.
-        "--no-sources",
-        ...pipPlatformArgs,
-        ...localSdkSourcePaths
-      ]
-    });
-  }
-  if (workflows.length > 0) {
-    workflowMode = await resolveWorkflowServingMode({
-      pythonPackage,
-      uv,
-      venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      uvLockPath
-    });
-    if (workflowMode === "workers" && workflows.length > 1) {
-      throw new import_build_utils24.NowBuildError({
-        code: "PYTHON_INVALID_WORKFLOW_CONFIG",
-        message: `"tool.vercel.workflows" declares multiple entrypoints, which requires ${QUEUE_WORKFLOW_SDK_REQUIREMENT} with a distinct namespace per Workflows registry; the installed SDK serves every workflow on the shared __wkf_* topic`
-      });
-    }
-  }
-  const shouldInstallVercelWorkers = legacyWorkersProject || workflows.length > 0 && workflowMode === "workers";
-  if (shouldInstallVercelWorkers) {
-    await installInjectedPackage({
-      name: "vercel-workers",
-      requirement: `vercel-workers==${VERCEL_WORKERS_VERSION}`,
-      envOverride: baseEnv.VERCEL_WORKERS_PYTHON,
-      allowLocalSource: true,
-      uv,
-      venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      pipPlatformArgs
-    });
-  }
-  const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
-  if (quirksResult.buildEnv) {
-    Object.assign(pythonEnv, quirksResult.buildEnv);
-  }
-  const queueIntegrations = queueAdapterBootstrap.integrations;
-  const writeGeneratedQueueHandler = async (outputPath, declaration) => {
-    const generatedPath = getGeneratedQueueHandlerPath(outputPath);
-    await import_fs20.default.promises.mkdir((0, import_path21.dirname)((0, import_path21.join)(workPath, generatedPath)), {
-      recursive: true
-    });
-    await import_fs20.default.promises.writeFile(
-      (0, import_path21.join)(workPath, generatedPath),
-      createQueueHandlerModule(declaration, queueIntegrations)
-    );
-  };
-  if (subscriberDeclarations.length > 0 && !legacyWorkersProject) {
-    subscribers = await resolveQueueSubscribers({
-      declarations: subscriberDeclarations,
-      uv,
-      venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      integrations: queueIntegrations
-    });
-    if (workflowMode === "queue") {
-      for (const subscriber of subscribers) {
-        if (!subscriber.topicPatterns) {
-          subscriber.subscriptions = subscriber.subscriptions.filter(
-            (subscription) => !isWorkflowQueueTopic(subscription.topic)
-          );
-        }
-      }
-    }
-    for (const subscriber of subscribers) {
-      await writeGeneratedQueueHandler(
-        getSubscriberOutputPath(subscriber.name),
-        subscriber
-      );
-    }
-  }
-  const workflowQueueSubscriptions = /* @__PURE__ */ new Map();
-  if (workflows.length > 0 && workflowMode === "queue") {
-    const resolved2 = await resolveQueueSubscribers({
-      declarations: workflows.map((workflow) => ({
-        name: workflow.name,
-        entrypoint: workflow.entrypoint,
-        moduleName: workflow.moduleName,
-        variableName: workflow.variableName
-      })),
-      uv,
-      venvPath,
-      projectDir: (0, import_path21.join)(workPath, entryDirectory),
-      kind: "workflow",
-      integrations: queueIntegrations
-    });
-    for (let i = 0; i < resolved2.length; i++) {
-      for (let j = i + 1; j < resolved2.length; j++) {
-        const overlaps = resolved2[i].subscriptions.some(
-          (left) => resolved2[j].subscriptions.some(
-            (right) => queueTopicPatternsOverlap(left.topic, right.topic)
-          )
-        );
-        if (overlaps) {
-          throw new import_build_utils24.NowBuildError({
-            code: "PYTHON_INVALID_WORKFLOW_CONFIG",
-            message: `workflow entrypoints "${resolved2[i].moduleName}:${resolved2[i].variableName}" and "${resolved2[j].moduleName}:${resolved2[j].variableName}" subscribe to overlapping queue topics; construct each vercel.workflow.Workflows registry with a distinct namespace`
-          });
-        }
-      }
-    }
-    for (const workflow of resolved2) {
-      workflowQueueSubscriptions.set(workflow.name, workflow.subscriptions);
-      await writeGeneratedQueueHandler(
-        getWorkflowOutputPath(workflow.name),
-        workflow
-      );
-    }
-  }
-  const preDeployCommand = config?.preDeployCommand;
-  if (registerPreDeploy && typeof preDeployCommand === "string") {
-    const capturedEnv = { ...pythonEnv };
-    const capturedCwd = workPath;
-    registerPreDeploy(async () => {
-      await builderSpan.child(import_build_utils24.BUILDER_PRE_DEPLOY_STEP, {
-        preDeployCommand
-      }).trace(async () => {
-        console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
-        await (0, import_build_utils24.execCommand)(preDeployCommand, {
-          env: capturedEnv,
-          cwd: capturedCwd
-        });
-      });
-    });
+  if (lockPath && import_fs20.default.existsSync(lockPath)) {
+    await import_fs20.default.promises.mkdir(uvCacheDir, { recursive: true });
+    await import_fs20.default.promises.copyFile(lockPath, cachedLockPath);
   }
+  return result;
+}
+async function packFunctionBundle({
+  builderSpan,
+  workPath,
+  uvLockPath,
+  uvProjectDir,
+  projectName,
+  pythonVersion,
+  hasCustomCommand,
+  alwaysBundlePackages,
+  initialFiles,
+  additionalExcludes,
+  compileAllEnabled,
+  compileEnv,
+  venvPath,
+  entrypoint,
+  importClosureContext,
+  largeFunctionLabel
+}) {
   const vendorDir = resolveVendorDir();
-  let crons;
-  let runtimeTrampoline;
-  if (entrypoint) {
-    (0, import_build_utils24.debug)("Entrypoint is", entrypoint);
-    const moduleName = entrypointToModule(entrypoint);
-    if (handlerFunction) {
-      const entrypointPath = (0, import_path21.join)(workPath, entrypoint);
-      const source = await import_fs20.default.promises.readFile(entrypointPath, "utf-8");
-      const found = await (0, import_python_analysis12.containsTopLevelCallable)(source, handlerFunction);
-      if (!found) {
-        throw new import_build_utils24.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_utils24.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 compileAllEnabled = shouldCompileAll({
-    isDev: meta.isDev,
-    hasCustomCommand,
-    // 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/**",
     ".gitignore",
@@ -13861,71 +13477,13 @@ var build = async ({
     "**/yarn.lock",
     "**/package-lock.json"
   ];
-  const lambdaEnv = {};
-  lambdaEnv.PYTHONPATH = vendorDir;
-  lambdaEnv.PYTHONDONTWRITEBYTECODE = "1";
-  Object.assign(lambdaEnv, quirksResult.env);
-  if (shouldInstallVercelWorkers) {
-    lambdaEnv.VERCEL_HAS_WORKER_SERVICES = "1";
-  }
-  if (queueIntegrations.length > 0) {
-    lambdaEnv.VERCEL_QUEUE_INTEGRATIONS = queueIntegrations.map(
-      ({ module: module2, installer, servingActivator }) => `${module2}:${installer}` + (servingActivator ? `:${servingActivator}` : "")
-    ).join(",");
-  }
-  const apschedulerSubscribers = apschedulerSubscriberIdentities(subscribers);
-  if (apschedulerSubscribers.length > 0) {
-    lambdaEnv.VERCEL_APSCHEDULER_SUBSCRIBERS = JSON.stringify(
-      apschedulerSubscribers
-    );
-    const previewConfig = await getApschedulerPreviewConfig(workPath);
-    if (previewConfig) {
-      lambdaEnv.VERCEL_APSCHEDULER_PREVIEW_IDLE_TIMEOUT_SECONDS = String(
-        previewConfig.idleTimeoutSeconds
-      );
-    }
-  }
-  const functionConfig = getMatchingFunction(
-    config,
-    entrypoint
-  )?.functionConfig;
-  const includeFilesPatterns = [
-    ...normalizeGlobs(config?.includeFiles),
-    ...normalizeGlobs(functionConfig?.includeFiles)
-  ];
-  const excludeFilesPatterns = [
-    ...normalizeGlobs(config?.excludeFiles),
-    ...normalizeGlobs(functionConfig?.excludeFiles)
-  ];
-  const cdnBundle = getFastAPICdnBundle(
-    fastapiStatic?.collectedMounts ?? [],
-    workPath,
-    pythonPackage.manifest?.data?.tool?.vercel?.fastapi
-  );
-  const globOptions = {
+  const files = await (0, import_build_utils24.glob)("**", {
     cwd: workPath,
-    ignore: [
-      ...predefinedExcludes,
-      ...excludeFilesPatterns,
-      ...cdnBundle.excludePatterns
-    ]
-  };
-  const files = await (0, import_build_utils24.glob)("**", globOptions);
-  for (const pattern of includeFilesPatterns) {
-    Object.assign(files, await (0, import_build_utils24.glob)(pattern, workPath));
-  }
-  Object.assign(files, cdnBundle.directoryStubs);
+    ignore: [...predefinedExcludes, ...additionalExcludes ?? []]
+  });
+  Object.assign(files, initialFiles);
   const appPythonSourceFiles = Object.keys(files).filter((file) => file.endsWith(".py")).map((file) => (0, import_path21.join)(workPath, file)).sort();
-  if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils24.FileFsRef({
-      fsPath: (0, import_path21.join)(workPath, djangoStatic.manifestRelPath)
-    });
-  }
-  const handlerPyFilename = "vc__handler__python";
-  if (config.framework === "fasthtml") {
-    const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils24.FileBlob({ data: `"${SESSKEY}"` });
-  }
+  let pycachePrefix;
   await builderSpan.child("vc.builder.python.bundle").trace(async (bundleSpan) => {
     const installedDistributions = await InstalledPythonDistributions.load({
       venvPath,
@@ -13941,10 +13499,7 @@ var build = async ({
       projectName,
       pythonVersion,
       hasCustomCommand,
-      alwaysBundlePackages: [
-        ...quirksResult.alwaysBundlePackages ?? [],
-        ...shouldInstallVercelWorkers ? ["vercel-workers", "vercel_workers"] : []
-      ]
+      alwaysBundlePackages
     });
     const depAnalysis = await depExternalizer.analyze(files, {
       onSized: ({ totalSizeBytes, runtimeInstallEnabled }) => {
@@ -13958,11 +13513,11 @@ var build = async ({
     });
     const compileAllOptions = compileAllEnabled ? {
       pythonBin: getVenvPythonBin(venvPath),
-      env: pythonEnv
+      env: compileEnv
     } : null;
     const compileSources = async ({
       includePackages,
-      pycachePrefix
+      pycachePrefix: pycachePrefixArg
     }) => {
       if (!compileAllOptions)
         return void 0;
@@ -13973,7 +13528,7 @@ var build = async ({
         const result = await runCompileAll({
           ...compileAllOptions,
           sourceFiles: [...appPythonSourceFiles, ...vendorSourceFiles],
-          pycachePrefix
+          pycachePrefix: pycachePrefixArg
         });
         timings = result.timings;
         compileSpan.setAttributes({
@@ -13998,13 +13553,8 @@ var build = async ({
               getImportClosureOptions({
                 workPath,
                 entrypoint,
-                frameworkSeeds: importSeeds,
-                extraPythonPath: hookResult?.extraPythonPath,
-                subscriberDeclarations,
-                subscribers,
-                workflows,
-                workflowMode,
-                sitePackageDirs
+                sitePackageDirs,
+                ...importClosureContext
               })
             ),
             IMPORT_CLOSURE_TIMEOUT_MS,
@@ -14158,7 +13708,7 @@ var build = async ({
           timings
         });
         if (bytesAdded > 0) {
-          lambdaEnv.PYTHONPYCACHEPREFIX = RUNTIME_PYCACHE_PREFIX;
+          pycachePrefix = RUNTIME_PYCACHE_PREFIX;
         }
       } catch (err) {
         console.log(
@@ -14168,7 +13718,7 @@ var build = async ({
       }
     };
     const announceLargeFunction = () => console.log(
-      `Function "${entrypoint ?? rawEntrypoint}" exceeds the standard size limit; enabling large functions (beta).`
+      `Function "${largeFunctionLabel}" exceeds the standard size limit; enabling large functions (beta).`
     );
     let packingMode;
     let runtimeToolingBytes = 0;
@@ -14235,6 +13785,730 @@ var build = async ({
       "python.bundle.packingMode": packingMode
     });
   });
+  return { pycachePrefix, vendorDir, files };
+}
+async function buildProxyMiddleware({
+  workPath,
+  repoRootPath,
+  files: originalFiles,
+  entrypoint,
+  config,
+  meta,
+  builderSpan
+}) {
+  const target = getTargetPlatform(meta.isDev ?? false);
+  (0, import_build_utils24.debug)(`workPath: ${workPath}`);
+  workPath = await downloadFilesInWorkPath({
+    workPath,
+    files: originalFiles,
+    entrypoint,
+    meta
+  });
+  const proxyHandlerFunction = config.handlerFunction;
+  if (typeof proxyHandlerFunction !== "string" || !proxyHandlerFunction) {
+    throw new Error(
+      'Python proxy build requires "config.handlerFunction" to be set'
+    );
+  }
+  const proxySource = await import_fs20.default.promises.readFile(
+    (0, import_path21.join)(workPath, entrypoint),
+    "utf-8"
+  );
+  if (!await (0, import_python_analysis12.containsTopLevelCallable)(proxySource, proxyHandlerFunction)) {
+    throw new import_build_utils24.NowBuildError({
+      code: "PYTHON_HANDLER_NOT_FOUND",
+      message: `Handler function "${proxyHandlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+    });
+  }
+  const rootDir = repoRootPath ?? workPath;
+  const venvPath = (0, import_path21.join)(workPath, ".vercel", "python", "vercel.proxy", ".venv");
+  const { pythonPackage, pythonVersion, uv, uvCacheDir, restoredCache } = await setupPythonToolchain({
+    builderSpan,
+    workPath,
+    entrypointDir: (0, import_path21.join)(workPath, (0, import_path21.dirname)(entrypoint)),
+    rootDir,
+    venvPath,
+    meta
+  });
+  const { projectDir, lockPath: uvLockPath } = await builderSpan.child(import_build_utils24.BUILDER_INSTALLER_STEP, {
+    runtime: "python",
+    "python.cache.restored": restoredCache
+  }).trace(
+    () => runUvManagedInstall({
+      workPath,
+      rootDir,
+      venvPath,
+      pythonPackage,
+      pythonVersion,
+      uv,
+      uvCacheDir,
+      lockCacheKey: "uv.lock",
+      pythonPlatform: target.uvPlatform,
+      // Install only the proxy's dependency group into the proxy venv;
+      // the project itself is neither built nor installed.
+      // If the group is absent the proxy has no extra deps — skip sync.
+      extraSyncParams: "vercel.proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
+    })
+  );
+  const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
+  await installInjectedPackage({
+    name: "vercel-runtime",
+    requirement: `vercel-runtime==${VERCEL_RUNTIME_VERSION}`,
+    envOverride: process.env.VERCEL_RUNTIME_PYTHON,
+    allowLocalSource: true,
+    uv,
+    venvPath,
+    projectDir,
+    pipPlatformArgs
+  });
+  const projectName = pythonPackage?.manifest?.data?.project?.name;
+  const compileAllEnabled = shouldCompileAll({
+    isDev: meta.isDev ?? false,
+    hasCustomCommand: false
+  });
+  const pythonEnv = createVenvEnv(venvPath, process.env, uvCacheDir);
+  const functionConfig = getMatchingFunction(
+    config,
+    entrypoint
+  )?.functionConfig;
+  const includeFilesPatterns = [
+    ...normalizeGlobs(config?.includeFiles),
+    ...normalizeGlobs(functionConfig?.includeFiles)
+  ];
+  const excludeFilesPatterns = [
+    ...normalizeGlobs(config?.excludeFiles),
+    ...normalizeGlobs(functionConfig?.excludeFiles)
+  ];
+  const initialFiles = {};
+  for (const pattern of includeFilesPatterns) {
+    Object.assign(initialFiles, await (0, import_build_utils24.glob)(pattern, workPath));
+  }
+  const { pycachePrefix, vendorDir, files } = await packFunctionBundle({
+    builderSpan,
+    workPath,
+    uvLockPath,
+    uvProjectDir: projectDir,
+    projectName,
+    pythonVersion,
+    hasCustomCommand: false,
+    alwaysBundlePackages: [],
+    initialFiles,
+    additionalExcludes: excludeFilesPatterns,
+    compileAllEnabled,
+    compileEnv: pythonEnv,
+    venvPath,
+    entrypoint,
+    importClosureContext: {
+      frameworkSeeds: [],
+      extraPythonPath: void 0,
+      subscriberDeclarations: [],
+      subscribers: [],
+      workflows: [],
+      workflowMode: "workers"
+    },
+    largeFunctionLabel: entrypoint
+  });
+  const moduleName = entrypointToModule(entrypoint);
+  const variableName = proxyHandlerFunction;
+  const handlerPyFilename = "vc__handler__python";
+  const runtimeTrampoline = createRuntimeTrampoline({
+    moduleName,
+    entrypoint,
+    vendorDir,
+    variableName,
+    extraEnv: []
+  });
+  files[`${handlerPyFilename}.py`] = new import_build_utils24.FileBlob({ data: runtimeTrampoline });
+  const lambdaOptions = await getPythonLambdaOptions({ config, entrypoint });
+  const output = new import_build_utils24.Lambda({
+    files,
+    handler: `${handlerPyFilename}.vc_handler`,
+    runtime: pythonVersion.runtime,
+    ...lambdaOptions,
+    architecture: target.architecture,
+    environment: {
+      PYTHONPATH: vendorDir,
+      PYTHONDONTWRITEBYTECODE: "1",
+      ...pycachePrefix ? { PYTHONPYCACHEPREFIX: pycachePrefix } : {}
+    },
+    supportsResponseStreaming: true
+  });
+  const matcher = (0, import_build_utils25.resolveMiddlewareMatcher)(
+    config.middlewareMatcher,
+    void 0,
+    entrypoint
+  );
+  const src = (0, import_build_utils25.getRegExpFromMatchers)(matcher);
+  const middlewareRawSrc = !matcher ? [] : Array.isArray(matcher) ? [...matcher] : [matcher];
+  return {
+    resultVersion: 3,
+    result: {
+      output,
+      routes: [
+        {
+          src,
+          middlewareRawSrc,
+          middlewarePath: entrypoint.replace(/\.py$/i, ""),
+          continue: true,
+          override: true
+        }
+      ]
+    }
+  };
+}
+var build = async ({
+  workPath,
+  repoRootPath,
+  files: originalFiles,
+  entrypoint: rawEntrypoint,
+  meta = {},
+  config,
+  span: parentSpan,
+  service,
+  registerPreDeploy
+}) => {
+  let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
+  const builderSpan = parentSpan ?? new import_build_utils24.Span({ name: "vc.builder" });
+  if (config?.middleware === true && entrypoint) {
+    return buildProxyMiddleware({
+      workPath,
+      repoRootPath,
+      files: originalFiles,
+      entrypoint,
+      config,
+      meta,
+      builderSpan
+    });
+  }
+  const isPyprojectEntrypoint = entrypoint !== void 0 && (0, import_path21.basename)(entrypoint) === "pyproject.toml";
+  if (isPyprojectEntrypoint && entrypoint !== "pyproject.toml") {
+    throw new import_build_utils24.NowBuildError({
+      code: "PYTHON_INVALID_PYPROJECT_ENTRYPOINT",
+      message: `A "pyproject.toml" entrypoint must sit at the service root. Set the service "root" to "${(0, import_path21.dirname)(entrypoint)}" and use entrypoint "pyproject.toml".`
+    });
+  }
+  const framework = config?.framework;
+  let subscriberDeclarations = [];
+  let subscribers = [];
+  let workflows = [];
+  let legacyWorkersProject = false;
+  let workflowMode = "workers";
+  let spawnEnv;
+  let projectInstallCommand;
+  let hasCustomCommand = false;
+  const target = getTargetPlatform(meta.isDev ?? false);
+  (0, import_build_utils24.debug)(`workPath: ${workPath}`);
+  workPath = await downloadFilesInWorkPath({
+    workPath,
+    files: originalFiles,
+    entrypoint,
+    meta
+  });
+  legacyWorkersProject = await isLegacyWorkersProject(workPath);
+  if (isPyprojectEntrypoint || !service && (0, import_build_utils24.isPythonFramework)(framework)) {
+    subscriberDeclarations = await getPyprojectSubscribers(workPath, {
+      legacySchema: legacyWorkersProject
+    });
+    workflows = await getPyprojectWorkflows(workPath);
+  }
+  try {
+    if (meta.isDev) {
+      const setupCfg = (0, import_path21.join)(workPath, "setup.cfg");
+      await writeFile(setupCfg, "[install]\nprefix=\n");
+    }
+  } catch (err) {
+    console.log('Failed to create "setup.cfg" file');
+    throw err;
+  }
+  let detected;
+  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
+  if (isPyprojectEntrypoint) {
+    const declared = await getVercelToolsEntrypoint(workPath, repoRootPath);
+    if (declared) {
+      detected = { entrypoint: declared };
+    } else if (subscriberDeclarations.length === 0 && workflows.length === 0) {
+      throw new import_build_utils24.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_utils24.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_path21.dirname)(entrypoint) : ".");
+  const entrypointAbsDir = (0, import_path21.join)(workPath, entryDirectory);
+  const rootDir = repoRootPath ?? workPath;
+  const venvPath = service?.name ? (0, import_path21.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path21.join)(workPath, ".vercel", "python", ".venv");
+  const { pythonPackage, pythonVersion, uv, uvCacheDir, restoredCache } = await setupPythonToolchain({
+    builderSpan,
+    workPath,
+    entrypointDir: entrypointAbsDir,
+    rootDir,
+    venvPath,
+    meta
+  });
+  if ((0, import_build_utils24.isPythonFramework)(framework)) {
+    const {
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      packageJsonDevEngines,
+      turboSupportsCorepackHome
+    } = await (0, import_build_utils24.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils24.getEnvForPackageManager)({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      packageJsonDevEngines,
+      env: process.env,
+      turboSupportsCorepackHome,
+      projectCreatedAt: config?.projectSettings?.createdAt
+    });
+    const installCommand = config?.projectSettings?.installCommand;
+    if (typeof installCommand === "string") {
+      const trimmed = installCommand.trim();
+      if (trimmed) {
+        projectInstallCommand = trimmed;
+      } else {
+        console.log('Skipping "install" command...');
+      }
+    }
+  }
+  const baseEnv = spawnEnv || process.env;
+  const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
+  pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
+  let assumeDepsInstalled = false;
+  let uvLockPath = null;
+  let uvProjectDir = null;
+  let projectName;
+  let usedUvManagedInstall = false;
+  await builderSpan.child(import_build_utils24.BUILDER_INSTALLER_STEP, {
+    installCommand: projectInstallCommand || void 0,
+    runtime: "python",
+    "python.cache.restored": restoredCache
+  }).trace(async () => {
+    if (projectInstallCommand) {
+      await import_fs20.default.promises.rm(venvPath, { recursive: true, force: true });
+      await ensureVenv({
+        pythonVersion,
+        venvPath,
+        uvPath: uv.getPath(),
+        uvCacheDir,
+        quiet: true
+      });
+      console.log(
+        `Running "install" command: \`${projectInstallCommand}\`...`
+      );
+      await (0, import_build_utils24.execCommand)(projectInstallCommand, {
+        env: pythonEnv,
+        cwd: workPath
+      });
+      assumeDepsInstalled = true;
+      hasCustomCommand = true;
+    } else {
+      const hasCustomScript = await runPyprojectScript(
+        workPath,
+        ["vercel-install", "now-install", "install"],
+        pythonEnv,
+        /* useUserVirtualEnv */
+        false
+      );
+      if (hasCustomScript) {
+        assumeDepsInstalled = true;
+        hasCustomCommand = true;
+      }
+    }
+    if (!assumeDepsInstalled) {
+      const { projectDir, lockPath } = await runUvManagedInstall({
+        workPath,
+        rootDir,
+        venvPath,
+        pythonPackage,
+        pythonVersion,
+        uv,
+        uvCacheDir,
+        lockCacheKey: service?.name ? `uv.lock.${service.name}` : "uv.lock",
+        pythonPlatform: target.uvPlatform,
+        extraSyncParams: {}
+      });
+      uvLockPath = lockPath;
+      uvProjectDir = projectDir;
+      projectName = pythonPackage?.manifest?.data?.project?.name;
+      usedUvManagedInstall = true;
+    }
+  });
+  if ((0, import_build_utils24.isPythonFramework)(framework)) {
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    await builderSpan.child(import_build_utils24.BUILDER_COMPILE_STEP, {
+      buildCommand: projectBuildCommand || void 0
+    }).trace(async () => {
+      if (projectBuildCommand) {
+        console.log(`Running "${projectBuildCommand}"`);
+        await (0, import_build_utils24.execCommand)(projectBuildCommand, {
+          env: pythonEnv,
+          cwd: workPath
+        });
+      } else {
+        await runPyprojectScript(
+          workPath,
+          ["vercel-build", "now-build", "build"],
+          pythonEnv
+        );
+      }
+    });
+  }
+  const hookResult = await runFrameworkHook(framework, {
+    pythonEnv,
+    workPath,
+    venvPath,
+    entrypoint,
+    detected,
+    pyprojectData: pythonPackage.manifest?.data
+  });
+  const resolved = isPyprojectEntrypoint ? detected?.entrypoint : hookResult?.entrypoint ?? detected?.entrypoint;
+  if (!resolved && detected?.error) {
+    throw detected?.error;
+  }
+  entrypoint = resolved?.entrypoint;
+  const isWorkersOnly = !entrypoint && isPyprojectEntrypoint && (subscriberDeclarations.length > 0 || workflows.length > 0);
+  if (!entrypoint && !isWorkersOnly) {
+    throw new import_build_utils24.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
+  }
+  const djangoStatic = hookResult?.djangoStatic ?? null;
+  const fastapiStatic = hookResult?.fastapiStatic ?? null;
+  const importSeeds = hookResult?.importSeeds ?? [];
+  const cdnOutputDir = djangoStatic?.cdnOutputDir ?? fastapiStatic?.cdnOutputDir ?? null;
+  const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
+  await installInjectedPackage({
+    name: "vercel-runtime",
+    requirement: `vercel-runtime==${VERCEL_RUNTIME_VERSION}`,
+    envOverride: baseEnv.VERCEL_RUNTIME_PYTHON,
+    allowLocalSource: true,
+    uv,
+    venvPath,
+    projectDir: (0, import_path21.join)(workPath, entryDirectory),
+    pipPlatformArgs
+  });
+  const queueAdapterBootstrap = await getQueueAdapterBootstrap({
+    pythonPackage,
+    env: baseEnv,
+    legacyWorkersProject,
+    hasDeclaredSubscribers: await hasPyprojectSubscribers(workPath)
+  });
+  const queueAdapterInjectedPackages = usedUvManagedInstall ? queueAdapterBootstrap.injectedPackages : [];
+  for (const injectedPackage of queueAdapterInjectedPackages) {
+    await installInjectedPackage({
+      ...injectedPackage,
+      uv,
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      pipPlatformArgs
+    });
+  }
+  const localSdkSourcePaths = await getLocalSdkSourcePaths({
+    pythonPackage,
+    env: baseEnv
+  });
+  if (localSdkSourcePaths.length > 0) {
+    (0, import_build_utils24.debug)(
+      `Installing vercel SDK override from ${baseEnv.VERCEL_SDK_PYTHON}: ` + localSdkSourcePaths.join(", ")
+    );
+    await uv.pip({
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      args: [
+        "install",
+        "--link-mode",
+        "copy",
+        // Without --no-sources, uv resolves the checkout's workspace
+        // dependencies as editable .pth installs pointing at the (build
+        // only) checkout mount — invisible to bundling and dangling at
+        // runtime. Explicit paths stay real installs; the remaining
+        // workspace siblings resolve from PyPI.
+        "--no-sources",
+        ...pipPlatformArgs,
+        ...localSdkSourcePaths
+      ]
+    });
+  }
+  if (workflows.length > 0) {
+    workflowMode = await resolveWorkflowServingMode({
+      pythonPackage,
+      uv,
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      uvLockPath
+    });
+    if (workflowMode === "workers" && workflows.length > 1) {
+      throw new import_build_utils24.NowBuildError({
+        code: "PYTHON_INVALID_WORKFLOW_CONFIG",
+        message: `"tool.vercel.workflows" declares multiple entrypoints, which requires ${QUEUE_WORKFLOW_SDK_REQUIREMENT} with a distinct namespace per Workflows registry; the installed SDK serves every workflow on the shared __wkf_* topic`
+      });
+    }
+  }
+  const shouldInstallVercelWorkers = legacyWorkersProject || workflows.length > 0 && workflowMode === "workers";
+  if (shouldInstallVercelWorkers) {
+    await installInjectedPackage({
+      name: "vercel-workers",
+      requirement: `vercel-workers==${VERCEL_WORKERS_VERSION}`,
+      envOverride: baseEnv.VERCEL_WORKERS_PYTHON,
+      allowLocalSource: true,
+      uv,
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      pipPlatformArgs
+    });
+  }
+  const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
+  if (quirksResult.buildEnv) {
+    Object.assign(pythonEnv, quirksResult.buildEnv);
+  }
+  const queueIntegrations = queueAdapterBootstrap.integrations;
+  const writeGeneratedQueueHandler = async (outputPath, declaration) => {
+    const generatedPath = getGeneratedQueueHandlerPath(outputPath);
+    await import_fs20.default.promises.mkdir((0, import_path21.dirname)((0, import_path21.join)(workPath, generatedPath)), {
+      recursive: true
+    });
+    await import_fs20.default.promises.writeFile(
+      (0, import_path21.join)(workPath, generatedPath),
+      createQueueHandlerModule(declaration, queueIntegrations)
+    );
+  };
+  if (subscriberDeclarations.length > 0 && !legacyWorkersProject) {
+    subscribers = await resolveQueueSubscribers({
+      declarations: subscriberDeclarations,
+      uv,
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      integrations: queueIntegrations
+    });
+    if (workflowMode === "queue") {
+      for (const subscriber of subscribers) {
+        if (!subscriber.topicPatterns) {
+          subscriber.subscriptions = subscriber.subscriptions.filter(
+            (subscription) => !isWorkflowQueueTopic(subscription.topic)
+          );
+        }
+      }
+    }
+    for (const subscriber of subscribers) {
+      await writeGeneratedQueueHandler(
+        getSubscriberOutputPath(subscriber.name),
+        subscriber
+      );
+    }
+  }
+  const workflowQueueSubscriptions = /* @__PURE__ */ new Map();
+  if (workflows.length > 0 && workflowMode === "queue") {
+    const resolved2 = await resolveQueueSubscribers({
+      declarations: workflows.map((workflow) => ({
+        name: workflow.name,
+        entrypoint: workflow.entrypoint,
+        moduleName: workflow.moduleName,
+        variableName: workflow.variableName
+      })),
+      uv,
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      kind: "workflow",
+      integrations: queueIntegrations
+    });
+    for (let i = 0; i < resolved2.length; i++) {
+      for (let j = i + 1; j < resolved2.length; j++) {
+        const overlaps = resolved2[i].subscriptions.some(
+          (left) => resolved2[j].subscriptions.some(
+            (right) => queueTopicPatternsOverlap(left.topic, right.topic)
+          )
+        );
+        if (overlaps) {
+          throw new import_build_utils24.NowBuildError({
+            code: "PYTHON_INVALID_WORKFLOW_CONFIG",
+            message: `workflow entrypoints "${resolved2[i].moduleName}:${resolved2[i].variableName}" and "${resolved2[j].moduleName}:${resolved2[j].variableName}" subscribe to overlapping queue topics; construct each vercel.workflow.Workflows registry with a distinct namespace`
+          });
+        }
+      }
+    }
+    for (const workflow of resolved2) {
+      workflowQueueSubscriptions.set(workflow.name, workflow.subscriptions);
+      await writeGeneratedQueueHandler(
+        getWorkflowOutputPath(workflow.name),
+        workflow
+      );
+    }
+  }
+  const preDeployCommand = config?.preDeployCommand;
+  if (registerPreDeploy && typeof preDeployCommand === "string") {
+    const capturedEnv = { ...pythonEnv };
+    const capturedCwd = workPath;
+    registerPreDeploy(async () => {
+      await builderSpan.child(import_build_utils24.BUILDER_PRE_DEPLOY_STEP, {
+        preDeployCommand
+      }).trace(async () => {
+        console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
+        await (0, import_build_utils24.execCommand)(preDeployCommand, {
+          env: capturedEnv,
+          cwd: capturedCwd
+        });
+      });
+    });
+  }
+  const vendorDir = resolveVendorDir();
+  let crons;
+  let runtimeTrampoline;
+  if (entrypoint) {
+    (0, import_build_utils24.debug)("Entrypoint is", entrypoint);
+    const moduleName = entrypointToModule(entrypoint);
+    if (handlerFunction) {
+      const entrypointPath = (0, import_path21.join)(workPath, entrypoint);
+      const source = await import_fs20.default.promises.readFile(entrypointPath, "utf-8");
+      const found = await (0, import_python_analysis12.containsTopLevelCallable)(source, handlerFunction);
+      if (!found) {
+        throw new import_build_utils24.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_utils24.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 compileAllEnabled = shouldCompileAll({
+    isDev: meta.isDev,
+    hasCustomCommand,
+    // 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 lambdaEnv = {};
+  lambdaEnv.PYTHONPATH = vendorDir;
+  lambdaEnv.PYTHONDONTWRITEBYTECODE = "1";
+  Object.assign(lambdaEnv, quirksResult.env);
+  if (shouldInstallVercelWorkers) {
+    lambdaEnv.VERCEL_HAS_WORKER_SERVICES = "1";
+  }
+  if (queueIntegrations.length > 0) {
+    lambdaEnv.VERCEL_QUEUE_INTEGRATIONS = queueIntegrations.map(
+      ({ module: module2, installer, servingActivator }) => `${module2}:${installer}` + (servingActivator ? `:${servingActivator}` : "")
+    ).join(",");
+  }
+  const apschedulerSubscribers = apschedulerSubscriberIdentities(subscribers);
+  if (apschedulerSubscribers.length > 0) {
+    lambdaEnv.VERCEL_APSCHEDULER_SUBSCRIBERS = JSON.stringify(
+      apschedulerSubscribers
+    );
+    const previewConfig = await getApschedulerPreviewConfig(workPath);
+    if (previewConfig) {
+      lambdaEnv.VERCEL_APSCHEDULER_PREVIEW_IDLE_TIMEOUT_SECONDS = String(
+        previewConfig.idleTimeoutSeconds
+      );
+    }
+  }
+  const functionConfig = getMatchingFunction(
+    config,
+    entrypoint
+  )?.functionConfig;
+  const includeFilesPatterns = [
+    ...normalizeGlobs(config?.includeFiles),
+    ...normalizeGlobs(functionConfig?.includeFiles)
+  ];
+  const excludeFilesPatterns = [
+    ...normalizeGlobs(config?.excludeFiles),
+    ...normalizeGlobs(functionConfig?.excludeFiles)
+  ];
+  const cdnBundle = getFastAPICdnBundle(
+    fastapiStatic?.collectedMounts ?? [],
+    workPath,
+    pythonPackage.manifest?.data?.tool?.vercel?.fastapi
+  );
+  const initialFiles = {};
+  for (const pattern of includeFilesPatterns) {
+    Object.assign(initialFiles, await (0, import_build_utils24.glob)(pattern, workPath));
+  }
+  Object.assign(initialFiles, cdnBundle.directoryStubs);
+  if (djangoStatic?.manifestRelPath) {
+    initialFiles[djangoStatic.manifestRelPath] = new import_build_utils24.FileFsRef({
+      fsPath: (0, import_path21.join)(workPath, djangoStatic.manifestRelPath)
+    });
+  }
+  const handlerPyFilename = "vc__handler__python";
+  if (config.framework === "fasthtml") {
+    const { SESSKEY = "" } = process.env;
+    initialFiles[".sesskey"] = new import_build_utils24.FileBlob({ data: `"${SESSKEY}"` });
+  }
+  const { pycachePrefix, files } = await packFunctionBundle({
+    builderSpan,
+    workPath,
+    uvLockPath,
+    uvProjectDir,
+    projectName,
+    pythonVersion,
+    hasCustomCommand,
+    alwaysBundlePackages: [
+      ...quirksResult.alwaysBundlePackages ?? [],
+      ...shouldInstallVercelWorkers ? ["vercel-workers", "vercel_workers"] : []
+    ],
+    initialFiles,
+    additionalExcludes: [...excludeFilesPatterns, ...cdnBundle.excludePatterns],
+    compileAllEnabled,
+    compileEnv: pythonEnv,
+    venvPath,
+    entrypoint,
+    importClosureContext: {
+      frameworkSeeds: importSeeds,
+      extraPythonPath: hookResult?.extraPythonPath,
+      subscriberDeclarations,
+      subscribers,
+      workflows,
+      workflowMode
+    },
+    largeFunctionLabel: entrypoint ?? rawEntrypoint
+  });
+  if (pycachePrefix) {
+    lambdaEnv.PYTHONPYCACHEPREFIX = pycachePrefix;
+  }
   let output;
   if (entrypoint && runtimeTrampoline) {
     const webFiles = {