@vercel/python 6.55.2 → 6.55.3

package/dist/index.js

@@ -7962,18 +7962,18 @@ function moduleColonFuncToCronPath(serviceName, moduleFunction) {
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs12 = require("fs");
-var import_path12 = require("path");
-var import_build_utils14 = require("@vercel/build-utils");
+var import_fs13 = require("fs");
+var import_path13 = require("path");
+var import_build_utils15 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 var import_python_analysis8 = require("@vercel/python-analysis");
 
 // src/subscribers.ts
-var import_path11 = require("path");
-var import_fs11 = __toESM(require("fs"));
+var import_path12 = require("path");
+var import_fs12 = __toESM(require("fs"));
 var import_execa6 = __toESM(require_execa());
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 
 // src/module-entrypoint.ts
 var import_path10 = require("path");
@@ -8018,6 +8018,94 @@ async function resolveExistingEntrypoint(workPath, filePath) {
   return null;
 }
 
+// src/workflows.ts
+var import_path11 = require("path");
+var import_fs11 = __toESM(require("fs"));
+var import_build_utils13 = require("@vercel/build-utils");
+var WORKFLOW_OUTPUT_DIR = "_py_workflows";
+var WORKFLOW_TOPIC_PATTERN = "__wkf_*";
+var WORKFLOW_DEV_TOPIC_PATTERN = "__*wkf_*";
+var WORKFLOW_QUEUE_TOPIC_RE = /^__(?:[a-z][a-z0-9]*_)?wkf_/;
+function isWorkflowQueueTopic(topic) {
+  return WORKFLOW_QUEUE_TOPIC_RE.test(topic);
+}
+var WORKFLOW_FIELD_NAMES = /* @__PURE__ */ new Set(["entrypoint"]);
+function getWorkflowOutputPath(workflowName) {
+  return `${WORKFLOW_OUTPUT_DIR}/${safePathSegment(workflowName)}`;
+}
+function getWorkflowConsumerName(workflowName) {
+  return (0, import_build_utils13.sanitizeConsumerName)(getWorkflowOutputPath(workflowName));
+}
+async function getPyprojectWorkflows(workPath) {
+  const pyprojectPath = (0, import_path11.join)(workPath, "pyproject.toml");
+  if (!import_fs11.default.existsSync(pyprojectPath)) {
+    return [];
+  }
+  const pyproject = await (0, import_build_utils13.readConfigFile)(pyprojectPath);
+  const workflows = pyproject?.tool?.vercel?.workflows;
+  if (!workflows) {
+    return [];
+  }
+  if (!Array.isArray(workflows)) {
+    throw workflowError('"tool.vercel.workflows" must be an array');
+  }
+  const parsedWorkflows = await Promise.all(
+    workflows.map((config, index) => parseWorkflow(workPath, index, config))
+  );
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const workflow of parsedWorkflows) {
+    if (seenNames.has(workflow.name)) {
+      throw workflowError(
+        `workflow "${workflow.name}" is declared more than once`
+      );
+    }
+    seenNames.add(workflow.name);
+  }
+  return parsedWorkflows;
+}
+async function parseWorkflow(workPath, index, config) {
+  const label = `workflow #${index + 1}`;
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw workflowError(`${label} must be an object`);
+  }
+  for (const key of Object.keys(config)) {
+    if (!WORKFLOW_FIELD_NAMES.has(key)) {
+      throw workflowError(`${label} has unrecognized field "${key}"`);
+    }
+  }
+  if (typeof config.entrypoint !== "string") {
+    throw workflowError(`${label} must define string field "entrypoint"`);
+  }
+  const entrypoint = parseModuleEntrypoint(config.entrypoint);
+  if (!entrypoint) {
+    throw workflowError(
+      `${label} has invalid entrypoint "${config.entrypoint}". Use "module:object"`
+    );
+  }
+  const name = getModuleEntrypointName(entrypoint);
+  const existingEntrypoint = await resolveExistingEntrypoint(
+    workPath,
+    entrypoint.filePath
+  );
+  if (!existingEntrypoint) {
+    throw workflowError(
+      `workflow "${name}" has entrypoint "${config.entrypoint}" but file "${entrypoint.filePath}" does not exist`
+    );
+  }
+  return {
+    name,
+    entrypoint: existingEntrypoint,
+    moduleName: entrypoint.moduleName,
+    variableName: entrypoint.variableName
+  };
+}
+function workflowError(message) {
+  return new import_build_utils13.NowBuildError({
+    code: "PYTHON_INVALID_WORKFLOW_CONFIG",
+    message
+  });
+}
+
 // src/subscribers.ts
 var SUBSCRIBER_OUTPUT_DIR = "_py_subscribers";
 var TRIGGER_NUMBER_FIELDS = [
@@ -8082,7 +8170,7 @@ function getSubscriberOutputPath(subscriberName) {
   return `${SUBSCRIBER_OUTPUT_DIR}/${safePathSegment(subscriberName)}`;
 }
 function getSubscriberConsumerName(subscriberName) {
-  return (0, import_build_utils13.sanitizeConsumerName)(getSubscriberOutputPath(subscriberName));
+  return (0, import_build_utils14.sanitizeConsumerName)(getSubscriberOutputPath(subscriberName));
 }
 function getGeneratedQueueHandlerPath(outputPath) {
   return `_vc_queue_handlers/${outputPath.replace(/[^A-Za-z0-9_]+/g, "_")}.py`;
@@ -8091,11 +8179,11 @@ function generatedPythonPathToModule(filePath) {
   return filePath.replace(/\.py$/, "").split(/[\\/]+/).join(".");
 }
 async function getPyprojectSubscribers(workPath, { legacySchema = false } = {}) {
-  const pyprojectPath = (0, import_path11.join)(workPath, "pyproject.toml");
-  if (!import_fs11.default.existsSync(pyprojectPath)) {
+  const pyprojectPath = (0, import_path12.join)(workPath, "pyproject.toml");
+  if (!import_fs12.default.existsSync(pyprojectPath)) {
     return [];
   }
-  const pyproject = await (0, import_build_utils13.readConfigFile)(pyprojectPath);
+  const pyproject = await (0, import_build_utils14.readConfigFile)(pyprojectPath);
   const subscribers = pyproject?.tool?.vercel?.subscribers;
   if (!subscribers) {
     return [];
@@ -8152,8 +8240,15 @@ async function resolveQueueSubscribers({
         )}]${hint}`
       );
     }
-    const subscriptions = filterQueueSubscriptions(declaration, introspected);
+    const subscriptions = kind === "workflow" ? introspected.filter(
+      (subscription) => isWorkflowQueueTopic(subscription.topic)
+    ) : filterQueueSubscriptions(declaration, introspected);
     if (subscriptions.length === 0) {
+      if (kind === "workflow") {
+        throw subscriberError(
+          `workflow "${declaration.name}" registered no workflow queue subscriptions${hint}`
+        );
+      }
       const declared = declaration.topicPatterns?.join(", ") ?? "*";
       throw subscriberError(
         `${kind} "${declaration.name}" declared topics [${declared}] but no introspected queue subscriptions matched${hint}`
@@ -8410,7 +8505,7 @@ async function introspectQueueSubscriptions({
     });
     return parseIntrospectedSubscriptions(kind, declaration.name, stdout);
   } catch (err) {
-    if (err instanceof import_build_utils13.NowBuildError) {
+    if (err instanceof import_build_utils14.NowBuildError) {
       throw err;
     }
     const message = err instanceof Error ? err.message : String(err);
@@ -8459,7 +8554,7 @@ async function introspectDevQueueSubscriptions({
       };
     });
   } catch (err) {
-    (0, import_build_utils13.debug)(
+    (0, import_build_utils14.debug)(
       `Failed to introspect dev queue subscriptions for module "${moduleName}": ${err instanceof Error ? err.message : String(err)}`
     );
     return void 0;
@@ -8526,7 +8621,7 @@ function getQueueWildcardPrefix(pattern) {
   return void 0;
 }
 function subscriberError(message) {
-  return new import_build_utils13.NowBuildError({
+  return new import_build_utils14.NowBuildError({
     code: "PYTHON_INVALID_SUBSCRIBER_CONFIG",
     message
   });
@@ -8631,17 +8726,17 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils14.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils15.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path12.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs12.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path12.join)(syncDir, "pyproject.toml");
+    const syncDir = (0, import_path13.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs13.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path13.join)(syncDir, "pyproject.toml");
     const content = (0, import_python_analysis8.stringifyManifest)(manifest.data);
-    (0, import_fs12.writeFileSync)(tempPyproject, content, "utf8");
+    (0, import_fs13.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils14.debug)(
+    (0, import_build_utils15.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -8674,7 +8769,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils14.NowBuildError({
+    throw new import_build_utils15.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -8689,14 +8784,14 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path12.dirname)(manifestPath);
+  const projectDir = (0, import_path13.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils14.NowBuildError({
+        throw new import_build_utils15.NowBuildError({
           code: "PYTHON_DEPENDENCY_SYNC_FAILED",
           message: "uv is required to install dependencies from uv.lock.",
           link: "https://docs.astral.sh/uv/getting-started/installation/",
@@ -8718,11 +8813,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils14.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils15.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve4, reject) => {
-    (0, import_build_utils14.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils15.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -8761,7 +8856,7 @@ var COMPLETED_INSTALLS = /* @__PURE__ */ new Set();
 function hasInstalledDistribution(targetDir, packageName) {
   const prefix = `${packageName.replace("-", "_")}-`;
   try {
-    return (0, import_fs12.readdirSync)(targetDir).some(
+    return (0, import_fs13.readdirSync)(targetDir).some(
       (entry) => entry.startsWith(prefix) && entry.endsWith(".dist-info")
     );
   } catch {
@@ -8769,7 +8864,7 @@ function hasInstalledDistribution(targetDir, packageName) {
   }
 }
 async function installInjectedDevPackage(pkg, opts) {
-  const targetDir = (0, import_path12.join)(opts.workPath, ".vercel", "python");
+  const targetDir = (0, import_path13.join)(opts.workPath, ".vercel", "python");
   const source = pkg.envOverride || pkg.pinnedVersion || pkg.requirement;
   const key = `${targetDir}:${pkg.name}:${source}`;
   if (COMPLETED_INSTALLS.has(key) && hasInstalledDistribution(targetDir, pkg.name)) {
@@ -8783,23 +8878,23 @@ async function installInjectedDevPackage(pkg, opts) {
 }
 async function doInstallInjectedDevPackage(pkg, opts) {
   const { targetDir, workPath, uvPath, pythonBin, env, onStdout, onStderr } = opts;
-  (0, import_fs12.mkdirSync)(targetDir, { recursive: true });
-  const localDir = (0, import_path12.join)(__dirname, "..", "..", "..", "python", pkg.name);
-  const isLocalDev = (0, import_fs12.existsSync)((0, import_path12.join)(localDir, "pyproject.toml"));
+  (0, import_fs13.mkdirSync)(targetDir, { recursive: true });
+  const localDir = (0, import_path13.join)(__dirname, "..", "..", "..", "python", pkg.name);
+  const isLocalDev = (0, import_fs13.existsSync)((0, import_path13.join)(localDir, "pyproject.toml"));
   const requirement = pkg.pinnedVersion ? `${pkg.name}==${pkg.pinnedVersion}` : pkg.requirement ?? pkg.name;
   const dep = pkg.envOverride || (isLocalDev ? localDir : requirement);
   if (!isLocalDev && !pkg.envOverride && pkg.pinnedVersion) {
     const distInfoName = pkg.name.replace("-", "_");
-    const distInfo = (0, import_path12.join)(
+    const distInfo = (0, import_path13.join)(
       targetDir,
       `${distInfoName}-${pkg.pinnedVersion}.dist-info`
     );
-    if ((0, import_fs12.existsSync)(distInfo)) {
-      (0, import_build_utils14.debug)(`${pkg.name} ${pkg.pinnedVersion} already installed, skipping`);
+    if ((0, import_fs13.existsSync)(distInfo)) {
+      (0, import_build_utils15.debug)(`${pkg.name} ${pkg.pinnedVersion} already installed, skipping`);
       return;
     }
   }
-  (0, import_build_utils14.debug)(
+  (0, import_build_utils15.debug)(
     `Installing ${pkg.name} into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${dep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -8821,14 +8916,14 @@ async function doInstallInjectedDevPackage(pkg, opts) {
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils14.debug)(data.toString());
+        (0, import_build_utils15.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils14.debug)(data.toString());
+        (0, import_build_utils15.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -8858,12 +8953,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils14.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils15.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils14.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils15.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -8871,7 +8966,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils14.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils15.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -8888,46 +8983,46 @@ function installGlobalCleanupHandlers() {
 }
 function createDevShim(workPath, entry, modulePath, serviceName, framework, variableName) {
   try {
-    const vercelPythonDir = serviceName ? (0, import_path12.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path12.join)(workPath, ".vercel", "python");
-    (0, import_fs12.mkdirSync)(vercelPythonDir, { recursive: true });
+    const vercelPythonDir = serviceName ? (0, import_path13.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path13.join)(workPath, ".vercel", "python");
+    (0, import_fs13.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs12.existsSync)((0, import_path12.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path12.basename)(workPath);
+    if ((0, import_fs13.existsSync)((0, import_path13.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path13.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path12.dirname)(workPath);
+      extraPythonPath = (0, import_path13.dirname)(workPath);
     }
-    const entryAbs = (0, import_path12.join)(workPath, entry);
-    const shimPath = (0, import_path12.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path12.join)(
+    const entryAbs = (0, import_path13.join)(workPath, entry);
+    const shimPath = (0, import_path13.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path13.join)(
       __dirname,
       "..",
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs12.readFileSync)(templatePath, "utf8");
+    const template = (0, import_fs13.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework).replace(/__VC_DEV_VARIABLE_NAME__/g, variableName);
-    (0, import_fs12.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils14.debug)(`Prepared Python dev shim at ${shimPath}`);
+    (0, import_fs13.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils15.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils14.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils15.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
-  const venvPath = (0, import_path12.join)(workPath, ".venv");
+  const venvPath = (0, import_path13.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_utils14.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils15.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
   await dedupePendingOperation(
@@ -8940,11 +9035,11 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
       quiet: true
     })
   );
-  (0, import_build_utils14.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils15.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path12.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path13.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -9007,7 +9102,7 @@ var startDevServer = async (opts) => {
         filePath: entrypoint,
         // Schedule-triggered services create their own "app" wrapper dynamically.
         // Other services use handlerFunction as the entrypoint variable name.
-        varName: service && (0, import_build_utils14.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
+        varName: service && (0, import_build_utils15.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
       } : void 0,
       service,
       opts.repoRootPath
@@ -9029,7 +9124,7 @@ var startDevServer = async (opts) => {
     if (detected?.error) {
       throw detected.error;
     }
-    throw new import_build_utils14.NowBuildError({
+    throw new import_build_utils15.NowBuildError({
       code: isPyprojectEntrypoint ? "PYTHON_PYPROJECT_NOTHING_TO_BUILD" : "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: isPyprojectEntrypoint ? 'Entrypoint "pyproject.toml" does not declare a web app. Set "tool.vercel.entrypoint" in pyproject.toml.' : "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
@@ -9061,7 +9156,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils14.NowBuildError({
+      throw new import_build_utils15.NowBuildError({
         code: "PYTHON_EXTERNAL_VENV_DETECTED",
         message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
 Run ${white}deactivate${reset} and try again.`
@@ -9078,11 +9173,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils14.debug)(
+      (0, import_build_utils15.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils14.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils15.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -9091,9 +9186,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils14.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils15.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils14.debug)("No virtualenv found");
+        (0, import_build_utils15.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -9169,7 +9264,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         );
       }
     } catch (err) {
-      (0, import_build_utils14.debug)(
+      (0, import_build_utils15.debug)(
         `Skipping conditional dev package injection: ${err instanceof Error ? err.message : String(err)}`
       );
     }
@@ -9183,7 +9278,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         devOpts
       );
     }
-    const queueSidecarKind = config?.pythonQueueSidecar === "subscriber" || config?.pythonQueueSidecar === "workflow" ? config.pythonQueueSidecar : service && (0, import_build_utils14.isQueueBackedService)(service) ? (0, import_build_utils14.isWorkflowTriggeredService)(service) ? "workflow" : "subscriber" : void 0;
+    const queueSidecarKind = config?.pythonQueueSidecar === "subscriber" || config?.pythonQueueSidecar === "workflow" ? config.pythonQueueSidecar : service && (0, import_build_utils15.isQueueBackedService)(service) ? (0, import_build_utils15.isWorkflowTriggeredService)(service) ? "workflow" : "subscriber" : void 0;
     let queueSubscriptions;
     if (queueSidecarKind) {
       let useQueueServing = !legacyProject;
@@ -9197,14 +9292,14 @@ If you are using a virtual environment, activate it before running "vercel dev",
       }
       if (useQueueServing) {
         env.VERCEL_DEV_QUEUE_SERVING = "1";
-        const runtimeDir = (0, import_path12.join)(workPath, ".vercel", "python");
+        const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
         queueSubscriptions = await introspectDevQueueSubscriptions({
           moduleName: modulePath,
           pythonBin: spawnCommand,
           cwd: workPath,
           env: {
             ...env,
-            PYTHONPATH: [runtimeDir, env.PYTHONPATH].filter(Boolean).join(import_path12.delimiter)
+            PYTHONPATH: [runtimeDir, env.PYTHONPATH].filter(Boolean).join(import_path13.delimiter)
           },
           integrations: queueIntegrations
         });
@@ -9235,7 +9330,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
     if (entry) {
-      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path12.join)(workPath, entry);
+      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path13.join)(workPath, entry);
     }
     const devShim = createDevShim(
       workPath,
@@ -9246,8 +9341,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
       variableName ?? ""
     );
     if (devShim) {
-      const shimDir = devShim.shimDir || (0, import_path12.join)(workPath, ".vercel", "python");
-      const runtimeDir = (0, import_path12.join)(workPath, ".vercel", "python");
+      const shimDir = devShim.shimDir || (0, import_path13.join)(workPath, ".vercel", "python");
+      const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
       const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
@@ -9259,12 +9354,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path12.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path13.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils14.debug)(
+    (0, import_build_utils15.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -9318,7 +9413,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils17 = require("@vercel/build-utils");
+var import_build_utils18 = require("@vercel/build-utils");
 var import_python_analysis10 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
@@ -9332,9 +9427,9 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs13 = __toESM(require("fs"));
-var import_path13 = require("path");
-var import_build_utils15 = require("@vercel/build-utils");
+var import_fs14 = __toESM(require("fs"));
+var import_path14 = require("path");
+var import_build_utils16 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -9344,9 +9439,9 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path13.join)(workPath, name);
+    const candidate = (0, import_path14.join)(workPath, name);
     try {
-      await import_fs13.default.promises.access(candidate);
+      await import_fs14.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -9361,32 +9456,32 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path13.join)(
+      const schemaPath = (0, import_path14.join)(
         sitePackages,
         "litellm",
         "proxy",
         "schema.prisma"
       );
       try {
-        await import_fs13.default.promises.access(schemaPath);
-        (0, import_build_utils15.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        await import_fs14.default.promises.access(schemaPath);
+        (0, import_build_utils16.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils15.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils16.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
     }
     if (!process.env.CONFIG_FILE_PATH) {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
-        (0, import_build_utils15.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path13.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path13.join)(LAMBDA_ROOT, configName);
+        (0, import_build_utils16.debug)(`LiteLLM quirk: found config at ${configName}`);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path14.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path14.join)(LAMBDA_ROOT, configName);
       }
     } else {
-      (0, import_build_utils15.debug)(
+      (0, import_build_utils16.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -9395,10 +9490,10 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs14 = __toESM(require("fs"));
-var import_path14 = require("path");
+var import_fs15 = __toESM(require("fs"));
+var import_path15 = require("path");
 var import_execa7 = __toESM(require_execa());
-var import_build_utils16 = require("@vercel/build-utils");
+var import_build_utils17 = require("@vercel/build-utils");
 var import_python_analysis9 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
@@ -9436,22 +9531,22 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path14.isAbsolute)(envPath) ? envPath : (0, import_path14.join)(workPath, envPath);
+    const resolved = (0, import_path15.isAbsolute)(envPath) ? envPath : (0, import_path15.join)(workPath, envPath);
     try {
-      await import_fs14.default.promises.access(resolved);
+      await import_fs15.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils16.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils17.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
   const candidates = [
-    (0, import_path14.join)(workPath, "schema.prisma"),
-    (0, import_path14.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path15.join)(workPath, "schema.prisma"),
+    (0, import_path15.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs14.default.promises.access(candidate);
+      await import_fs15.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -9462,32 +9557,32 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs14.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs15.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path14.join)(dir, entry.name);
+    const full = (0, import_path15.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path14.relative)(base, full));
+      result.push((0, import_path15.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path14.join)(cacheDir, "node_modules"),
-    (0, import_path14.join)(cacheDir, "package.json"),
-    (0, import_path14.join)(cacheDir, "package-lock.json"),
+    (0, import_path15.join)(cacheDir, "node_modules"),
+    (0, import_path15.join)(cacheDir, "package.json"),
+    (0, import_path15.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
     try {
-      await import_fs14.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs15.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -9511,7 +9606,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path14.join)(
+    const runtimeCacheDir = (0, import_path15.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -9521,7 +9616,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs14.default.promises.access((0, import_path14.join)(dir, "prisma"));
+        await import_fs15.default.promises.access((0, import_path15.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -9533,19 +9628,19 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path14.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs14.default.promises.mkdir(cacheDir, { recursive: true });
+    const cacheDir = (0, import_path15.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs15.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path14.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path14.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs14.default.promises.writeFile(
+    const generatedDir = (0, import_path15.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path15.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs15.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils16.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils17.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa7.default)(
         pythonPath,
@@ -9557,11 +9652,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils16.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils17.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils16.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils17.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "PRISMA_GENERATE_FAILED",
         message: `Prisma engine download failed during \`prisma generate\`. Check that your prisma version is compatible with this Python version.
 ` + execErrorMessage(err)
@@ -9569,47 +9664,47 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path14.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path15.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs14.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs15.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path14.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path14.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path15.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path15.join)(cacheDir, runtimeName);
         try {
-          await import_fs14.default.promises.access(destPath);
-          (0, import_build_utils16.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          await import_fs15.default.promises.access(destPath);
+          (0, import_build_utils17.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils16.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs14.default.promises.copyFile(srcPath, destPath);
+          (0, import_build_utils17.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          await import_fs15.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not read Prisma engine directory "${nodeModulesDir}". This may indicate an incompatible prisma version.
 ` + (err instanceof Error ? err.message : String(err))
       });
     }
     if (!engineCopied) {
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
     }
-    const shimPath = (0, import_path14.join)(cacheDir, "openssl");
-    await import_fs14.default.promises.writeFile(
+    const shimPath = (0, import_path15.join)(cacheDir, "openssl");
+    await import_fs15.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs14.default.promises.chmod(shimPath, 493);
+    await import_fs15.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs14.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs15.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -9622,14 +9717,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils16.debug)(
+          (0, import_build_utils17.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils16.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils17.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa7.default)(
             pythonPath,
@@ -9641,11 +9736,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils16.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils17.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils16.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils17.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils16.NowBuildError({
+          throw new import_build_utils17.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -9656,12 +9751,12 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path14.join)(sitePackages, "prisma"),
+        (0, import_path15.join)(sitePackages, "prisma"),
         sitePackages
       );
       const count = await (0, import_python_analysis9.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils16.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils17.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -9755,13 +9850,13 @@ async function runQuirks(ctx) {
       (0, import_python_analysis10.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils17.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils18.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils17.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils18.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -9782,12 +9877,12 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs15 = __toESM(require("fs"));
-var import_path15 = require("path");
+var import_fs16 = __toESM(require("fs"));
+var import_path16 = require("path");
 var import_execa8 = __toESM(require_execa());
-var import_build_utils18 = require("@vercel/build-utils");
-var scriptPath2 = (0, import_path15.join)(__dirname, "..", "templates", "vc_django_settings.py");
-var script2 = import_fs15.default.readFileSync(scriptPath2, "utf-8");
+var import_build_utils19 = require("@vercel/build-utils");
+var scriptPath2 = (0, import_path16.join)(__dirname, "..", "templates", "vc_django_settings.py");
+var script2 = import_fs16.default.readFileSync(scriptPath2, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   const { stdout } = await (0, import_execa8.default)("python", ["-c", script2], {
     env,
@@ -9815,10 +9910,10 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
   const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
   const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
   const staticSourceDirs = [
-    ...installedApps.map((app) => (0, import_path15.join)(djangoPath, ...app.split("."), "static")),
+    ...installedApps.map((app) => (0, import_path16.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_fs15.default.existsSync(d));
+  ].filter((d) => import_fs16.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
@@ -9829,7 +9924,7 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
     });
     return {
       staticSourceDirs,
-      staticRoot: staticRoot ? (0, import_path15.resolve)(djangoPath, staticRoot) : null,
+      staticRoot: staticRoot ? (0, import_path16.resolve)(djangoPath, staticRoot) : null,
       cdnOutputDir: null,
       manifestRelPath: null
     };
@@ -9841,9 +9936,9 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
     return null;
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
-  const staticOutputDir = (0, import_path15.join)(outputStaticDir, staticUrlPath);
-  await import_fs15.default.promises.mkdir(staticOutputDir, { recursive: true });
-  const shimPath = (0, import_path15.join)(djangoPath, "_vercel_collectstatic_settings.py");
+  const staticOutputDir = (0, import_path16.join)(outputStaticDir, staticUrlPath);
+  await import_fs16.default.promises.mkdir(staticOutputDir, { recursive: true });
+  const shimPath = (0, import_path16.join)(djangoPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
     `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
@@ -9851,7 +9946,7 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs15.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs16.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
     await (0, import_execa8.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
@@ -9862,7 +9957,7 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
       cwd: djangoPath
     });
   } finally {
-    await import_fs15.default.promises.unlink(shimPath).catch(() => {
+    await import_fs16.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -9871,38 +9966,38 @@ async function runDjangoCollectStatic(venvPath, workPath, djangoPath, env, outpu
   ];
   let manifestRelPath = null;
   if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
-    const manifestSrc = (0, import_path15.join)(staticOutputDir, "staticfiles.json");
-    const resolvedStaticRoot = (0, import_path15.resolve)(djangoPath, staticRoot);
-    const manifestDest = (0, import_path15.join)(resolvedStaticRoot, "staticfiles.json");
-    await import_fs15.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs15.default.promises.copyFile(manifestSrc, manifestDest);
-    manifestRelPath = (0, import_path15.relative)(workPath, manifestDest);
-    (0, import_build_utils18.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    const manifestSrc = (0, import_path16.join)(staticOutputDir, "staticfiles.json");
+    const resolvedStaticRoot = (0, import_path16.resolve)(djangoPath, staticRoot);
+    const manifestDest = (0, import_path16.join)(resolvedStaticRoot, "staticfiles.json");
+    await import_fs16.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs16.default.promises.copyFile(manifestSrc, manifestDest);
+    manifestRelPath = (0, import_path16.relative)(workPath, manifestDest);
+    (0, import_build_utils19.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
-    staticRoot: staticRoot ? (0, import_path15.resolve)(djangoPath, staticRoot) : null,
+    staticRoot: staticRoot ? (0, import_path16.resolve)(djangoPath, staticRoot) : null,
     cdnOutputDir: outputStaticDir,
     manifestRelPath
   };
 }
 
 // src/fastapi.ts
-var import_fs16 = __toESM(require("fs"));
-var import_path16 = require("path");
+var import_fs17 = __toESM(require("fs"));
+var import_path17 = require("path");
 var import_execa9 = __toESM(require_execa());
-var import_build_utils19 = require("@vercel/build-utils");
-var scriptPath3 = (0, import_path16.join)(__dirname, "..", "templates", "vc_fastapi_static.py");
+var import_build_utils20 = require("@vercel/build-utils");
+var scriptPath3 = (0, import_path17.join)(__dirname, "..", "templates", "vc_fastapi_static.py");
 var _STATIC_FILE_COLLECTION_ERROR_MESSAGE = "Warning: FastAPI static file collection failed. Static files will not be served from the CDN.";
 async function getFastAPIStaticMounts(venvPath, entrypointAbs, variableName, env, workPath) {
   const pythonPath = getVenvPythonBin(venvPath);
-  const outputPath = (0, import_path16.join)(
+  const outputPath = (0, import_path17.join)(
     workPath,
     ".vercel",
     "python",
     "vc_fastapi_static_output.json"
   );
-  await import_fs16.default.promises.mkdir((0, import_path16.join)(workPath, ".vercel", "python"), {
+  await import_fs17.default.promises.mkdir((0, import_path17.join)(workPath, ".vercel", "python"), {
     recursive: true
   });
   try {
@@ -9912,27 +10007,27 @@ async function getFastAPIStaticMounts(venvPath, entrypointAbs, variableName, env
       { env, cwd: workPath }
     );
     if (stderr) {
-      (0, import_build_utils19.debug)(`FastAPI shim stderr:
+      (0, import_build_utils20.debug)(`FastAPI shim stderr:
 ${stderr}`);
     }
   } catch (err) {
     console.error(_STATIC_FILE_COLLECTION_ERROR_MESSAGE);
-    (0, import_build_utils19.debug)(
+    (0, import_build_utils20.debug)(
       `FastAPI: could not discover static mounts: ${err?.stderr ?? err?.message ?? err}`
     );
     return [];
   }
   try {
-    const raw = await import_fs16.default.promises.readFile(outputPath, "utf8");
+    const raw = await import_fs17.default.promises.readFile(outputPath, "utf8");
     const parsed = JSON.parse(raw);
-    (0, import_build_utils19.debug)(`FastAPI: discovered mounts: ${JSON.stringify(parsed)}`);
+    (0, import_build_utils20.debug)(`FastAPI: discovered mounts: ${JSON.stringify(parsed)}`);
     return parsed;
   } catch {
     console.error(_STATIC_FILE_COLLECTION_ERROR_MESSAGE);
-    (0, import_build_utils19.debug)(`FastAPI: could not read shim output file: ${outputPath}`);
+    (0, import_build_utils20.debug)(`FastAPI: could not read shim output file: ${outputPath}`);
     return [];
   } finally {
-    await import_fs16.default.promises.rm(outputPath, { force: true });
+    await import_fs17.default.promises.rm(outputPath, { force: true });
   }
 }
 async function runFastAPICollectStatic(venvPath, workPath, env, outputStaticDir, entrypointAbs, variableName) {
@@ -9944,18 +10039,18 @@ async function runFastAPICollectStatic(venvPath, workPath, env, outputStaticDir,
     workPath
   );
   if (mounts.length === 0) {
-    (0, import_build_utils19.debug)("FastAPI: no StaticFiles mounts found, skipping");
+    (0, import_build_utils20.debug)("FastAPI: no StaticFiles mounts found, skipping");
     return null;
   }
-  (0, import_build_utils19.debug)(
+  (0, import_build_utils20.debug)(
     `Found ${mounts.length} FastAPI static mount(s): ${mounts.map((m) => m.urlPath).join(", ")}`
   );
   for (const mount of mounts) {
     const urlSubPath = mount.urlPath.replace(/^\/|\/$/g, "");
-    const dest = (0, import_path16.join)(outputStaticDir, urlSubPath);
-    await import_fs16.default.promises.mkdir(dest, { recursive: true });
-    await import_fs16.default.promises.cp(mount.directory, dest, { recursive: true });
-    (0, import_build_utils19.debug)(`copied ${mount.directory} -> ${dest}`);
+    const dest = (0, import_path17.join)(outputStaticDir, urlSubPath);
+    await import_fs17.default.promises.mkdir(dest, { recursive: true });
+    await import_fs17.default.promises.cp(mount.directory, dest, { recursive: true });
+    (0, import_build_utils20.debug)(`copied ${mount.directory} -> ${dest}`);
   }
   return {
     collectedMounts: mounts.map((m) => m.urlPath),
@@ -10011,10 +10106,10 @@ function fillBytecodeWithinCapacity(files, rankedItems, capacity) {
 
 // src/compileall.ts
 var import_execa10 = __toESM(require_execa());
-var import_build_utils20 = require("@vercel/build-utils");
-var import_fs17 = __toESM(require("fs"));
+var import_build_utils21 = require("@vercel/build-utils");
+var import_fs18 = __toESM(require("fs"));
 var import_os3 = require("os");
-var import_path17 = require("path");
+var import_path18 = require("path");
 var COMPILEALL_TIMEOUT_MS = 5 * 60 * 1e3;
 var PYCACHE_PREFIX_DIR = "_vc_pycache";
 var RUNTIME_PYCACHE_PREFIX = `/var/task/${PYCACHE_PREFIX_DIR}`;
@@ -10050,13 +10145,13 @@ async function runCompileAll({
   }
   let tempDir;
   try {
-    tempDir = await import_fs17.default.promises.mkdtemp(
-      (0, import_path17.join)((0, import_os3.tmpdir)(), "vercel-python-compileall-")
+    tempDir = await import_fs18.default.promises.mkdtemp(
+      (0, import_path18.join)((0, import_os3.tmpdir)(), "vercel-python-compileall-")
     );
-    const listPath = (0, import_path17.join)(tempDir, "pysources.json");
-    await import_fs17.default.promises.writeFile(listPath, JSON.stringify(uniqueSourceFiles));
-    const timingsPath = (0, import_path17.join)(tempDir, "timings.json");
-    const scriptPath4 = (0, import_path17.join)(__dirname, "..", "templates", "vc_compileall.py");
+    const listPath = (0, import_path18.join)(tempDir, "pysources.json");
+    await import_fs18.default.promises.writeFile(listPath, JSON.stringify(uniqueSourceFiles));
+    const timingsPath = (0, import_path18.join)(tempDir, "timings.json");
+    const scriptPath4 = (0, import_path18.join)(__dirname, "..", "templates", "vc_compileall.py");
     const baseEnv = env || process.env;
     const subprocessEnv = pycachePrefix ? { ...baseEnv, PYTHONPYCACHEPREFIX: pycachePrefix } : baseEnv;
     await (0, import_execa10.default)(pythonBin, [scriptPath4, listPath, timingsPath], {
@@ -10065,21 +10160,21 @@ async function runCompileAll({
     });
     let timings;
     try {
-      const raw = await import_fs17.default.promises.readFile(timingsPath, "utf8");
+      const raw = await import_fs18.default.promises.readFile(timingsPath, "utf8");
       timings = new Map(Object.entries(JSON.parse(raw)));
     } catch (err) {
-      (0, import_build_utils20.debug)(`compileall timings unavailable: ${String(err)}`);
+      (0, import_build_utils21.debug)(`compileall timings unavailable: ${String(err)}`);
     }
     return { success: true, timings };
   } catch (err) {
-    (0, import_build_utils20.debug)(`compileall error details: ${JSON.stringify(err)}`);
+    (0, import_build_utils21.debug)(`compileall error details: ${JSON.stringify(err)}`);
     return { success: false };
   } finally {
     if (tempDir) {
       try {
-        await import_fs17.default.promises.rm(tempDir, { recursive: true, force: true });
+        await import_fs18.default.promises.rm(tempDir, { recursive: true, force: true });
       } catch (err) {
-        (0, import_build_utils20.debug)(`compileall temporary file cleanup error: ${String(err)}`);
+        (0, import_build_utils21.debug)(`compileall temporary file cleanup error: ${String(err)}`);
       }
     }
   }
@@ -10116,7 +10211,7 @@ function deriveStagedPycFsPath(stagingDir, srcAbsPath, pythonMajor, pythonMinor)
   );
   if (!rel)
     return null;
-  return (0, import_path17.join)(stagingDir, rel.replaceAll("/", import_path17.sep));
+  return (0, import_path18.join)(stagingDir, rel.replaceAll("/", import_path18.sep));
 }
 function derivePrefixPycBundlePath(runtimeAbsPath, pythonMajor, pythonMinor) {
   const rel = derivePrefixPycRelPath(
@@ -10140,7 +10235,7 @@ async function collectAppPrefixBytecodeFiles({
   for (const bundlePath of Object.keys(appFiles)) {
     if (!bundlePath.endsWith(".py"))
       continue;
-    const sourceAbsPath = (0, import_path17.join)(workPath, bundlePath.replaceAll("/", import_path17.sep));
+    const sourceAbsPath = (0, import_path18.join)(workPath, bundlePath.replaceAll("/", import_path18.sep));
     const stagedFsPath = deriveStagedPycFsPath(
       stagingDir,
       sourceAbsPath,
@@ -10164,7 +10259,7 @@ async function collectAppPrefixBytecodeFiles({
   const results = await Promise.all(
     pending.map(async ({ bundlePath, srcFsPath, moduleKey, sourceAbsPath }) => {
       try {
-        const stats = await import_fs17.default.promises.stat(srcFsPath);
+        const stats = await import_fs18.default.promises.stat(srcFsPath);
         return {
           bundlePath,
           srcFsPath,
@@ -10184,7 +10279,7 @@ async function collectAppPrefixBytecodeFiles({
   for (const result of results) {
     if (!result)
       continue;
-    const file = new import_build_utils20.FileFsRef({
+    const file = new import_build_utils21.FileFsRef({
       fsPath: result.srcFsPath,
       size: result.size
     });
@@ -10214,15 +10309,15 @@ async function collectAppBytecodeFiles({
       continue;
     pending.push({
       bundlePath: pycRel,
-      srcFsPath: (0, import_path17.join)(workPath, pycRel.replaceAll("/", import_path17.sep)),
+      srcFsPath: (0, import_path18.join)(workPath, pycRel.replaceAll("/", import_path18.sep)),
       moduleKey: bundlePath,
-      sourceAbsPath: (0, import_path17.join)(workPath, bundlePath.replaceAll("/", import_path17.sep))
+      sourceAbsPath: (0, import_path18.join)(workPath, bundlePath.replaceAll("/", import_path18.sep))
     });
   }
   const results = await Promise.all(
     pending.map(async ({ bundlePath, srcFsPath, moduleKey, sourceAbsPath }) => {
       try {
-        const stats = await import_fs17.default.promises.stat(srcFsPath);
+        const stats = await import_fs18.default.promises.stat(srcFsPath);
         return {
           bundlePath,
           srcFsPath,
@@ -10242,7 +10337,7 @@ async function collectAppBytecodeFiles({
   for (const result of results) {
     if (!result)
       continue;
-    const file = new import_build_utils20.FileFsRef({
+    const file = new import_build_utils21.FileFsRef({
       fsPath: result.srcFsPath,
       size: result.size
     });
@@ -10261,9 +10356,9 @@ async function collectAppBytecodeFiles({
 }
 
 // src/installed-distributions.ts
-var import_fs18 = __toESM(require("fs"));
-var import_path18 = require("path");
-var import_build_utils21 = require("@vercel/build-utils");
+var import_fs19 = __toESM(require("fs"));
+var import_path19 = require("path");
+var import_build_utils22 = require("@vercel/build-utils");
 var import_python_analysis11 = require("@vercel/python-analysis");
 var STRIP_BASENAMES = /* @__PURE__ */ new Set([
   "py.typed",
@@ -10272,7 +10367,7 @@ var STRIP_BASENAMES = /* @__PURE__ */ new Set([
   "direct_url.json"
 ]);
 function shouldStripVendorFile(filePath) {
-  const segments = filePath.split(import_path18.sep);
+  const segments = filePath.split(import_path19.sep);
   if (segments.includes("__pycache__"))
     return true;
   const name = segments[segments.length - 1] ?? "";
@@ -10296,19 +10391,19 @@ function getDistributionFileGroups({
     const dirDistributions = distributions.get(dir);
     if (!dirDistributions)
       continue;
-    const sitePackagesDir = (0, import_path18.resolve)(dir);
+    const sitePackagesDir = (0, import_path19.resolve)(dir);
     for (const [name, distribution] of dirDistributions) {
       const packageName = (0, import_python_analysis11.normalizePackageName)(name);
       if (includeSet && !includeSet.has(packageName))
         continue;
       const files = [];
       for (const record of distribution.files) {
-        const absolutePath = (0, import_path18.resolve)(
+        const absolutePath = (0, import_path19.resolve)(
           sitePackagesDir,
-          record.path.replaceAll("/", import_path18.sep)
+          record.path.replaceAll("/", import_path19.sep)
         );
-        const relativePath = (0, import_path18.relative)(sitePackagesDir, absolutePath);
-        if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${import_path18.sep}`) || (0, import_path18.isAbsolute)(relativePath)) {
+        const relativePath = (0, import_path19.relative)(sitePackagesDir, absolutePath);
+        if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${import_path19.sep}`) || (0, import_path19.isAbsolute)(relativePath)) {
           continue;
         }
         files.push({ absolutePath, relativePath, record });
@@ -10328,7 +10423,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
     const distributions = /* @__PURE__ */ new Map();
     for (const dir of sitePackageDirs) {
       try {
-        await import_fs18.default.promises.access(dir);
+        await import_fs19.default.promises.access(dir);
       } catch {
         continue;
       }
@@ -10369,7 +10464,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
         if (shouldStripVendorFile(relativePath))
           continue;
         pending.push({
-          bundlePath: (0, import_path18.join)(vendorDirName, relativePath).replace(/\\/g, "/"),
+          bundlePath: (0, import_path19.join)(vendorDirName, relativePath).replace(/\\/g, "/"),
           srcFsPath: absolutePath,
           recordSize: record.size != null ? Number(record.size) : void 0
         });
@@ -10379,10 +10474,10 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
       pending.map(async ({ bundlePath, srcFsPath, recordSize }) => {
         try {
           if (recordSize === void 0) {
-            const stats = await import_fs18.default.promises.stat(srcFsPath);
+            const stats = await import_fs19.default.promises.stat(srcFsPath);
             return { bundlePath, srcFsPath, size: stats.size };
           }
-          await import_fs18.default.promises.access(srcFsPath);
+          await import_fs19.default.promises.access(srcFsPath);
           return { bundlePath, srcFsPath, size: recordSize };
         } catch {
           return null;
@@ -10393,12 +10488,12 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
     for (const result of results) {
       if (!result)
         continue;
-      vendorFiles[result.bundlePath] = new import_build_utils21.FileFsRef({
+      vendorFiles[result.bundlePath] = new import_build_utils22.FileFsRef({
         fsPath: result.srcFsPath,
         size: result.size
       });
     }
-    (0, import_build_utils21.debug)(
+    (0, import_build_utils22.debug)(
       `Mirrored ${Object.keys(vendorFiles).length} files` + (includePackages ? ` from ${includePackages.length} packages` : "")
     );
     return vendorFiles;
@@ -10419,7 +10514,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
           knownSize += Number(record.size);
         } else {
           statPromises.push(
-            import_fs18.default.promises.stat(absolutePath).then((stats) => stats.size).catch(() => 0)
+            import_fs19.default.promises.stat(absolutePath).then((stats) => stats.size).catch(() => 0)
           );
         }
       }
@@ -10462,7 +10557,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
     });
     for (const { packageName, sitePackagesDir, files } of distributionGroups) {
       for (const { relativePath } of files) {
-        const moduleKey = relativePath.replaceAll(import_path18.sep, "/");
+        const moduleKey = relativePath.replaceAll(import_path19.sep, "/");
         const pycRelativePath = derivePycPath(
           moduleKey,
           this.pythonMajor,
@@ -10470,18 +10565,18 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
         );
         if (!pycRelativePath)
           continue;
-        const pycFilePath = pycRelativePath.replaceAll("/", import_path18.sep);
+        const pycFilePath = pycRelativePath.replaceAll("/", import_path19.sep);
         pending.push({
-          bundlePath: (0, import_path18.join)(vendorDirName, pycFilePath).replace(/\\/g, "/"),
-          srcFsPath: (0, import_path18.join)(sitePackagesDir, pycFilePath),
+          bundlePath: (0, import_path19.join)(vendorDirName, pycFilePath).replace(/\\/g, "/"),
+          srcFsPath: (0, import_path19.join)(sitePackagesDir, pycFilePath),
           packageName,
           moduleKey,
-          sourceAbsPath: (0, import_path18.join)(sitePackagesDir, relativePath)
+          sourceAbsPath: (0, import_path19.join)(sitePackagesDir, relativePath)
         });
       }
     }
     const result = await this.collectExistingBytecode(pending);
-    (0, import_build_utils21.debug)(
+    (0, import_build_utils22.debug)(
       `Collected ${Object.keys(result.files).length} bytecode files (${(result.totalSize / (1024 * 1024)).toFixed(2)} MB)` + (includePackages ? ` from ${includePackages.length} packages` : "")
     );
     return result;
@@ -10504,7 +10599,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
       for (const { absolutePath, relativePath } of files) {
         if (!relativePath.endsWith(".py"))
           continue;
-        const recordPath = relativePath.replaceAll(import_path18.sep, "/");
+        const recordPath = relativePath.replaceAll(import_path19.sep, "/");
         const srcFsPath = deriveStagedPycFsPath(
           stagingDir,
           absolutePath,
@@ -10528,7 +10623,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
       }
     }
     const result = await this.collectExistingBytecode(pending);
-    (0, import_build_utils21.debug)(
+    (0, import_build_utils22.debug)(
       `Collected ${Object.keys(result.files).length} prefix bytecode files (${(result.totalSize / (1024 * 1024)).toFixed(2)} MB) for runtime root ${runtimeRoot}` + (includePackages ? ` from ${includePackages.length} packages` : "")
     );
     return result;
@@ -10544,7 +10639,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
           sourceAbsPath
         }) => {
           try {
-            const stats = await import_fs18.default.promises.stat(srcFsPath);
+            const stats = await import_fs19.default.promises.stat(srcFsPath);
             return {
               bundlePath,
               srcFsPath,
@@ -10566,7 +10661,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
     for (const result of results) {
       if (!result)
         continue;
-      const file = new import_build_utils21.FileFsRef({
+      const file = new import_build_utils22.FileFsRef({
         fsPath: result.srcFsPath,
         size: result.size
       });
@@ -10588,84 +10683,6 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
   }
 };
 
-// src/workflows.ts
-var import_path19 = require("path");
-var import_fs19 = __toESM(require("fs"));
-var import_build_utils22 = require("@vercel/build-utils");
-var WORKFLOW_OUTPUT_DIR = "_py_workflows";
-var WORKFLOW_TOPIC_PATTERN = "__wkf_*";
-var WORKFLOW_FIELD_NAMES = /* @__PURE__ */ new Set(["entrypoint"]);
-function getWorkflowOutputPath(workflowName) {
-  return `${WORKFLOW_OUTPUT_DIR}/${safePathSegment(workflowName)}`;
-}
-function getWorkflowConsumerName(workflowName) {
-  return (0, import_build_utils22.sanitizeConsumerName)(getWorkflowOutputPath(workflowName));
-}
-async function getPyprojectWorkflows(workPath) {
-  const pyprojectPath = (0, import_path19.join)(workPath, "pyproject.toml");
-  if (!import_fs19.default.existsSync(pyprojectPath)) {
-    return [];
-  }
-  const pyproject = await (0, import_build_utils22.readConfigFile)(pyprojectPath);
-  const workflows = pyproject?.tool?.vercel?.workflows;
-  if (!workflows) {
-    return [];
-  }
-  if (!Array.isArray(workflows)) {
-    throw workflowError('"tool.vercel.workflows" must be an array');
-  }
-  if (workflows.length > 1) {
-    throw workflowError(
-      '"tool.vercel.workflows" must declare a single entrypoint that registers every workflow'
-    );
-  }
-  return Promise.all(
-    workflows.map((config, index) => parseWorkflow(workPath, index, config))
-  );
-}
-async function parseWorkflow(workPath, index, config) {
-  const label = `workflow #${index + 1}`;
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    throw workflowError(`${label} must be an object`);
-  }
-  for (const key of Object.keys(config)) {
-    if (!WORKFLOW_FIELD_NAMES.has(key)) {
-      throw workflowError(`${label} has unrecognized field "${key}"`);
-    }
-  }
-  if (typeof config.entrypoint !== "string") {
-    throw workflowError(`${label} must define string field "entrypoint"`);
-  }
-  const entrypoint = parseModuleEntrypoint(config.entrypoint);
-  if (!entrypoint) {
-    throw workflowError(
-      `${label} has invalid entrypoint "${config.entrypoint}". Use "module:object"`
-    );
-  }
-  const name = getModuleEntrypointName(entrypoint);
-  const existingEntrypoint = await resolveExistingEntrypoint(
-    workPath,
-    entrypoint.filePath
-  );
-  if (!existingEntrypoint) {
-    throw workflowError(
-      `workflow "${name}" has entrypoint "${config.entrypoint}" but file "${entrypoint.filePath}" does not exist`
-    );
-  }
-  return {
-    name,
-    entrypoint: existingEntrypoint,
-    moduleName: entrypoint.moduleName,
-    variableName: entrypoint.variableName
-  };
-}
-function workflowError(message) {
-  return new import_build_utils22.NowBuildError({
-    code: "PYTHON_INVALID_WORKFLOW_CONFIG",
-    message
-  });
-}
-
 // src/import-closure.ts
 var import_path20 = require("path");
 var import_build_utils23 = require("@vercel/build-utils");
@@ -10799,7 +10816,7 @@ async function getDevSidecars({
             pythonQueueSidecar: "workflow"
           }
         },
-        topics: [{ topic: WORKFLOW_TOPIC_PATTERN }]
+        topics: [{ topic: WORKFLOW_DEV_TOPIC_PATTERN }]
       })
     )
   ];
@@ -11424,6 +11441,12 @@ var build = async ({
       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 vercel>=${MIN_QUEUE_WORKFLOW_SDK_VERSION} 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) {
@@ -11465,7 +11488,7 @@ var build = async ({
       for (const subscriber of subscribers) {
         if (!subscriber.topicPatterns) {
           subscriber.subscriptions = subscriber.subscriptions.filter(
-            (subscription) => !subscription.topic.startsWith("__wkf_")
+            (subscription) => !isWorkflowQueueTopic(subscription.topic)
           );
         }
       }
@@ -11484,8 +11507,7 @@ var build = async ({
         name: workflow.name,
         entrypoint: workflow.entrypoint,
         moduleName: workflow.moduleName,
-        variableName: workflow.variableName,
-        topicPatterns: [WORKFLOW_TOPIC_PATTERN]
+        variableName: workflow.variableName
       })),
       uv,
       venvPath,
@@ -11493,6 +11515,21 @@ var build = async ({
       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(