@vercel/python 6.55.2 → 6.56.0

package/dist/index.js

@@ -5032,12 +5032,29 @@ var import_fs20 = __toESM(require("fs"));
 var import_path21 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.18.0";
+var VERCEL_RUNTIME_VERSION = "0.19.0";
 var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/conditional-vendoring.ts
 var import_python_analysis = require("@vercel/python-analysis");
 var UPSTREAM_DEPENDENCY_ADAPTERS = /* @__PURE__ */ new Map([
+  [
+    "apscheduler",
+    {
+      bundled: "vercel-apscheduler-bundle",
+      unbundled: "vercel-apscheduler",
+      envOverride: "VERCEL_PYTHON_APSCHEDULER_DEPENDENCY",
+      preferUnbundledWhenPresent: ["vercel-queue"],
+      integration: {
+        module: "vercel.integrations.apscheduler",
+        installer: "install_vercel_apscheduler_integration",
+        // APScheduler jobs are declared while the subscriber module imports.
+        // Install first so the adapter can capture those definitions.
+        installBeforeImport: true,
+        subscriberProbe: "is_scheduler_subscriber"
+      }
+    }
+  ],
   [
     "celery",
     {
@@ -5069,31 +5086,26 @@ var UPSTREAM_DEPENDENCY_ADAPTERS = /* @__PURE__ */ new Map([
     }
   ]
 ]);
-async function getQueueIntegrations({
-  pythonPackage
+async function getQueueAdapterBootstrap({
+  pythonPackage,
+  env,
+  legacyWorkersProject,
+  hasDeclaredSubscribers
 }) {
-  const dependencies = await getDirectDependencyNames(pythonPackage);
-  if (!dependencies)
-    return [];
   const integrations = [];
-  for (const [upstream, adapter] of UPSTREAM_DEPENDENCY_ADAPTERS) {
-    if (dependencies.has(upstream)) {
-      integrations.push(adapter.integration);
-    }
+  const injectedPackages = [];
+  const bootstrap = { integrations, injectedPackages };
+  if (legacyWorkersProject || !hasDeclaredSubscribers) {
+    return bootstrap;
   }
-  return integrations;
-}
-async function getConditionalInjectedPackages({
-  pythonPackage,
-  env
-}) {
   const dependencies = await getDirectDependencyNames(pythonPackage);
-  if (!dependencies)
-    return [];
-  const injectedPackages = [];
+  if (!dependencies) {
+    return bootstrap;
+  }
   for (const [upstream, adapter] of UPSTREAM_DEPENDENCY_ADAPTERS) {
     if (!dependencies.has(upstream))
       continue;
+    integrations.push(adapter.integration);
     if (dependencies.has(adapter.bundled) || dependencies.has(adapter.unbundled)) {
       continue;
     }
@@ -5107,7 +5119,7 @@ async function getConditionalInjectedPackages({
       allowLocalSource: false
     });
   }
-  return injectedPackages;
+  return bootstrap;
 }
 async function getDirectDependencyNames(pythonPackage) {
   const dependencies = pythonPackage?.manifest?.data?.project?.dependencies;
@@ -7962,23 +7974,24 @@ 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");
 var import_fs10 = __toESM(require("fs"));
 var MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+var MODULE_RE = /^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*$/;
 function parseModuleEntrypoint(value) {
   const match = MODULE_ATTR_RE.exec(value);
   if (!match) {
@@ -7990,11 +8003,21 @@ function parseModuleEntrypoint(value) {
     filePath: `${match[1].replace(/\./g, "/")}.py`
   };
 }
+function parseBareModuleEntrypoint(value) {
+  if (!MODULE_RE.test(value)) {
+    return null;
+  }
+  return {
+    moduleName: value,
+    filePath: `${value.replace(/\./g, "/")}.py`
+  };
+}
 function getModuleEntrypointName({
   moduleName,
   variableName
 }) {
-  return `${moduleName.replace(/\./g, "-")}_${variableName}`;
+  const base = moduleName.replace(/\./g, "-");
+  return variableName === void 0 ? base : `${base}_${variableName}`;
 }
 function safePathSegment(value) {
   return [...value].map((char) => {
@@ -8018,8 +8041,97 @@ 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 SUBSCRIBER_ID_ENV = "VERCEL_PYTHON_SUBSCRIBER_ID";
 var TRIGGER_NUMBER_FIELDS = [
   {
     field: "max_attempts",
@@ -8078,11 +8190,18 @@ var LEGACY_SUBSCRIBER_FIELD_NAMES = /* @__PURE__ */ new Set([
   "topics",
   ...LEGACY_TRIGGER_NUMBER_FIELDS.map(({ field }) => field)
 ]);
+var APSCHEDULER_PREVIEW_FIELD_NAMES = /* @__PURE__ */ new Set(["enabled", "idle_timeout"]);
+var APSCHEDULER_DURATION_UNITS = {
+  s: 1,
+  m: 60,
+  h: 60 * 60,
+  d: 24 * 60 * 60
+};
 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`;
@@ -8090,12 +8209,21 @@ function getGeneratedQueueHandlerPath(outputPath) {
 function generatedPythonPathToModule(filePath) {
   return filePath.replace(/\.py$/, "").split(/[\\/]+/).join(".");
 }
+async function hasPyprojectSubscribers(workPath) {
+  const pyprojectPath = (0, import_path12.join)(workPath, "pyproject.toml");
+  if (!import_fs12.default.existsSync(pyprojectPath)) {
+    return false;
+  }
+  const pyproject = await (0, import_build_utils14.readConfigFile)(pyprojectPath);
+  const subscribers = pyproject?.tool?.vercel?.subscribers;
+  return Array.isArray(subscribers) && subscribers.length > 0;
+}
 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 [];
@@ -8119,6 +8247,63 @@ async function getPyprojectSubscribers(workPath, { legacySchema = false } = {})
   }
   return parsedSubscribers;
 }
+async function getApschedulerPreviewConfig(workPath) {
+  const pyprojectPath = (0, import_path12.join)(workPath, "pyproject.toml");
+  if (!import_fs12.default.existsSync(pyprojectPath)) {
+    return void 0;
+  }
+  const pyproject = await (0, import_build_utils14.readConfigFile)(pyprojectPath);
+  const apscheduler = pyproject?.tool?.vercel?.apscheduler;
+  if (apscheduler === void 0) {
+    return void 0;
+  }
+  if (!apscheduler || typeof apscheduler !== "object" || Array.isArray(apscheduler)) {
+    throw apschedulerError('"tool.vercel.apscheduler" must be a table');
+  }
+  const previews = apscheduler.previews;
+  if (previews === void 0) {
+    return void 0;
+  }
+  if (!previews || typeof previews !== "object" || Array.isArray(previews)) {
+    throw apschedulerError(
+      '"tool.vercel.apscheduler.previews" must be a table'
+    );
+  }
+  const rawPreviews = previews;
+  for (const key of Object.keys(rawPreviews)) {
+    if (!APSCHEDULER_PREVIEW_FIELD_NAMES.has(key)) {
+      throw apschedulerError(
+        `"tool.vercel.apscheduler.previews" has unrecognized field "${key}"`
+      );
+    }
+  }
+  if (rawPreviews.enabled !== void 0 && typeof rawPreviews.enabled !== "boolean") {
+    throw apschedulerError(
+      '"tool.vercel.apscheduler.previews.enabled" must be a boolean'
+    );
+  }
+  if (rawPreviews.enabled !== true) {
+    return void 0;
+  }
+  if (typeof rawPreviews.idle_timeout !== "string") {
+    throw apschedulerError(
+      '"tool.vercel.apscheduler.previews.idle_timeout" must be a duration such as "30m"'
+    );
+  }
+  const match = /^([1-9]\d*)([smhd])$/.exec(rawPreviews.idle_timeout);
+  if (!match) {
+    throw apschedulerError(
+      '"tool.vercel.apscheduler.previews.idle_timeout" must be a positive duration using s, m, h, or d (for example "30m")'
+    );
+  }
+  const idleTimeoutSeconds = Number(match[1]) * APSCHEDULER_DURATION_UNITS[match[2]];
+  if (!Number.isSafeInteger(idleTimeoutSeconds)) {
+    throw apschedulerError(
+      '"tool.vercel.apscheduler.previews.idle_timeout" is too large'
+    );
+  }
+  return { idleTimeoutSeconds };
+}
 async function resolveQueueSubscribers({
   declarations,
   uv,
@@ -8140,10 +8325,12 @@ async function resolveQueueSubscribers({
     const hint = kind === "workflow" ? "; ensure the entrypoint instantiates vercel.workflow.Workflows" : "";
     const unmatchedTopicPatterns = getUnmatchedQueueTopicPatterns(
       declaration,
-      introspected
+      introspected.subscriptions
     );
     if (unmatchedTopicPatterns.length > 0) {
-      const introspectedTopics = introspected.map(({ topic }) => topic);
+      const introspectedTopics = introspected.subscriptions.map(
+        ({ topic }) => topic
+      );
       throw subscriberError(
         `${kind} "${declaration.name}" declared topics [${unmatchedTopicPatterns.join(
           ", "
@@ -8152,14 +8339,21 @@ async function resolveQueueSubscribers({
         )}]${hint}`
       );
     }
-    const subscriptions = filterQueueSubscriptions(declaration, introspected);
+    const subscriptions = kind === "workflow" ? introspected.subscriptions.filter(
+      (subscription) => isWorkflowQueueTopic(subscription.topic)
+    ) : filterQueueSubscriptions(declaration, introspected.subscriptions);
     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}`
       );
     }
-    result.push({ ...declaration, subscriptions });
+    result.push({ ...declaration, subscriptions, owners: introspected.owners });
   }
   return result;
 }
@@ -8212,8 +8406,10 @@ function createIntegrationInstallLines(integrations, { serving, beforeImport })
 function createQueueHandlerModule(declaration, integrations) {
   return [
     "import importlib",
+    "import os",
     "import vercel.queue",
     "",
+    `os.environ[${JSON.stringify(SUBSCRIBER_ID_ENV)}] = ${JSON.stringify(declaration.name)}`,
     ...createIntegrationInstallLines(integrations, {
       serving: true,
       beforeImport: true
@@ -8227,14 +8423,22 @@ function createQueueHandlerModule(declaration, integrations) {
     ""
   ].join("\n");
 }
-async function parseSubscriberEntrypoint(workPath, label, entrypointValue) {
+async function parseSubscriberEntrypoint(workPath, label, entrypointValue, { requireVariable }) {
   if (typeof entrypointValue !== "string") {
     throw subscriberError(`${label} must define string field "entrypoint"`);
   }
-  const entrypoint = parseModuleEntrypoint(entrypointValue);
+  if (!requireVariable && /\.py$/i.test(entrypointValue)) {
+    const suggestion = parseBareModuleEntrypoint(
+      entrypointValue.slice(0, -3).replace(/[\\/]+/g, ".").replace(/(^|\.)__init__$/, "")
+    );
+    throw subscriberError(
+      `${label} has invalid entrypoint "${entrypointValue}". Use an import path, not a file path${suggestion ? `: "${suggestion.moduleName}"` : ""}`
+    );
+  }
+  const entrypoint = parseModuleEntrypoint(entrypointValue) ?? (requireVariable ? null : parseBareModuleEntrypoint(entrypointValue));
   if (!entrypoint) {
     throw subscriberError(
-      `${label} has invalid entrypoint "${entrypointValue}". Use "module:object"`
+      `${label} has invalid entrypoint "${entrypointValue}". Use ${requireVariable ? '"module:object"' : '"module:object" or a module path like "pkg.module"'}`
     );
   }
   const name = getModuleEntrypointName(entrypoint);
@@ -8247,11 +8451,12 @@ async function parseSubscriberEntrypoint(workPath, label, entrypointValue) {
       `subscriber "${name}" has entrypoint "${entrypointValue}" but file "${entrypoint.filePath}" does not exist`
     );
   }
+  const { variableName } = entrypoint;
   return {
     name,
     entrypoint: existingEntrypoint,
     moduleName: entrypoint.moduleName,
-    variableName: entrypoint.variableName
+    ...variableName === void 0 ? {} : { variableName }
   };
 }
 async function parseSubscriber(workPath, index, config) {
@@ -8267,7 +8472,8 @@ async function parseSubscriber(workPath, index, config) {
   const base = await parseSubscriberEntrypoint(
     workPath,
     label,
-    config.entrypoint
+    config.entrypoint,
+    { requireVariable: false }
   );
   return {
     ...base,
@@ -8287,7 +8493,8 @@ async function parseLegacySubscriber(workPath, index, config) {
   const base = await parseSubscriberEntrypoint(
     workPath,
     label,
-    config.entrypoint
+    config.entrypoint,
+    { requireVariable: true }
   );
   return {
     ...base,
@@ -8351,14 +8558,26 @@ function parseTopicPatterns(name, value) {
   }
   return value;
 }
-function createQueueIntrospectionScript(moduleName, integrations) {
+function createQueueIntrospectionScript(declaration, integrations) {
+  const { variableName } = declaration;
+  const probeLines = variableName === void 0 ? [] : integrations.filter((integration) => integration.subscriberProbe).flatMap(({ module: module2, subscriberProbe }) => [
+    "try:",
+    `    from ${module2} import ${subscriberProbe}`,
+    "except ImportError:",
+    "    pass",
+    "else:",
+    `    if ${subscriberProbe}(${JSON.stringify(declaration.moduleName)}, ${JSON.stringify(variableName)}):`,
+    `        owners.append(${JSON.stringify(module2)})`
+  ]);
   return [
-    "import importlib, json, sys",
+    "import importlib, json, os, sys",
+    `os.environ[${JSON.stringify(SUBSCRIBER_ID_ENV)}] = ${JSON.stringify(declaration.name)}`,
+    'os.environ["VERCEL_APSCHEDULER_DISCOVERY"] = "1"',
     ...createIntegrationInstallLines(integrations, {
       serving: false,
       beforeImport: true
     }),
-    `importlib.import_module(${JSON.stringify(moduleName)})`,
+    `importlib.import_module(${JSON.stringify(declaration.moduleName)})`,
     ...createIntegrationInstallLines(integrations, {
       serving: false,
       beforeImport: false
@@ -8375,7 +8594,9 @@ function createQueueIntrospectionScript(moduleName, integrations) {
     "    }.items() if v is not None}",
     "    for s in get_subscriptions()",
     "]",
-    "json.dump(subs, sys.stdout)"
+    "owners = []",
+    ...probeLines,
+    "json.dump({'subscriptions': subs, 'owners': owners}, sys.stdout)"
   ].join("\n");
 }
 async function introspectQueueSubscriptions({
@@ -8386,10 +8607,7 @@ async function introspectQueueSubscriptions({
   kind,
   integrations
 }) {
-  const script3 = createQueueIntrospectionScript(
-    declaration.moduleName,
-    integrations
-  );
+  const script3 = createQueueIntrospectionScript(declaration, integrations);
   try {
     const { stdout } = await uv.run({
       venvPath,
@@ -8410,7 +8628,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);
@@ -8421,6 +8639,8 @@ async function introspectQueueSubscriptions({
 }
 async function introspectDevQueueSubscriptions({
   moduleName,
+  subscriberName,
+  variableName,
   pythonBin,
   cwd,
   env,
@@ -8429,7 +8649,13 @@ async function introspectDevQueueSubscriptions({
   try {
     const { stdout } = await (0, import_execa6.default)(
       pythonBin,
-      ["-c", createQueueIntrospectionScript(moduleName, integrations)],
+      [
+        "-c",
+        createQueueIntrospectionScript(
+          { moduleName, name: subscriberName, variableName },
+          integrations
+        )
+      ],
       // Match the deployed-function environment (see
       // introspectQueueSubscriptions): SDKs may need VERCEL=1,
       // VERCEL_REGION, and VERCEL_DEPLOYMENT_ID to register subscriptions.
@@ -8443,12 +8669,12 @@ async function introspectDevQueueSubscriptions({
         }
       }
     );
-    const subscriptions = parseIntrospectedSubscriptions(
+    const introspected = parseIntrospectedSubscriptions(
       "subscriber",
       moduleName,
       stdout
     );
-    return subscriptions.map((subscription) => {
+    const subscriptions = introspected.subscriptions.map((subscription) => {
       const { retryAfterSeconds, initialDelaySeconds, maxDeliveries } = subscription.triggerDefaults;
       return {
         topic: subscription.topic,
@@ -8458,8 +8684,9 @@ async function introspectDevQueueSubscriptions({
         ...maxDeliveries === void 0 ? {} : { maxDeliveries }
       };
     });
+    return { subscriptions, owners: introspected.owners };
   } 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;
@@ -8474,14 +8701,28 @@ function parseIntrospectedSubscriptions(kind, subscriberName, stdout) {
       `${kind} "${subscriberName}" queue introspection did not return valid JSON`
     );
   }
-  if (!Array.isArray(parsed)) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw subscriberError(
-      `${kind} "${subscriberName}" queue introspection must return an array`
+      `${kind} "${subscriberName}" queue introspection must return an object`
     );
   }
-  return parsed.map(
-    (subscription, index) => parseIntrospectedSubscription(kind, subscriberName, index, subscription)
-  );
+  const { subscriptions, owners = [] } = parsed;
+  if (!Array.isArray(subscriptions)) {
+    throw subscriberError(
+      `${kind} "${subscriberName}" queue introspection must return a "subscriptions" array`
+    );
+  }
+  if (!Array.isArray(owners) || owners.some((o) => typeof o !== "string")) {
+    throw subscriberError(
+      `${kind} "${subscriberName}" queue introspection "owners" must be an array of strings`
+    );
+  }
+  return {
+    subscriptions: subscriptions.map(
+      (subscription, index) => parseIntrospectedSubscription(kind, subscriberName, index, subscription)
+    ),
+    owners
+  };
 }
 function parseIntrospectedSubscription(kind, subscriberName, index, value) {
   const label = `${kind} "${subscriberName}" introspected subscription #${index + 1}`;
@@ -8525,12 +8766,27 @@ function getQueueWildcardPrefix(pattern) {
   }
   return void 0;
 }
+var APSCHEDULER_INTEGRATION_MODULE = "vercel.integrations.apscheduler";
+function apschedulerSubscriberIdentities(subscribers) {
+  return subscribers.filter(
+    (subscriber) => subscriber.owners.includes(APSCHEDULER_INTEGRATION_MODULE)
+  ).map((subscriber) => ({
+    id: subscriber.name,
+    entrypoint: `${subscriber.moduleName}:${subscriber.variableName}`
+  }));
+}
 function subscriberError(message) {
-  return new import_build_utils13.NowBuildError({
+  return new import_build_utils14.NowBuildError({
     code: "PYTHON_INVALID_SUBSCRIBER_CONFIG",
     message
   });
 }
+function apschedulerError(message) {
+  return new import_build_utils14.NowBuildError({
+    code: "PYTHON_INVALID_APSCHEDULER_CONFIG",
+    message
+  });
+}
 
 // src/start-dev-server.ts
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
@@ -8631,17 +8887,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 +8930,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 +8945,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 +8974,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 +9017,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 +9025,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 +9039,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 +9077,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 +9114,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 +9127,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 +9144,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 +9196,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) => {
@@ -8992,6 +9248,7 @@ var startDevServer = async (opts) => {
   const isPyprojectEntrypoint = entrypoint === "pyproject.toml";
   let resolved;
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
+  const isPyQueueSidecar = config?.pythonQueueSidecar === "subscriber" || config?.pythonQueueSidecar === "workflow";
   let detected;
   if (isPyprojectEntrypoint) {
     const declaredEntrypoint = await getVercelToolsEntrypoint(
@@ -9007,7 +9264,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 ?? (isPyQueueSidecar ? "app" : void 0)
       } : void 0,
       service,
       opts.repoRootPath
@@ -9029,7 +9286,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 +9318,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 +9335,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 +9348,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";
@@ -9146,7 +9403,13 @@ If you are using a virtual environment, activate it before running "vercel dev",
         entrypointDir: workPath,
         rootDir: workPath
       });
-      queueIntegrations = legacyProject ? [] : await getQueueIntegrations({ pythonPackage });
+      const queueAdapterBootstrap = await getQueueAdapterBootstrap({
+        pythonPackage,
+        env,
+        legacyWorkersProject: legacyProject,
+        hasDeclaredSubscribers: await hasPyprojectSubscribers(workPath)
+      });
+      queueIntegrations = queueAdapterBootstrap.integrations;
       if (queueIntegrations.length > 0) {
         env.VERCEL_QUEUE_INTEGRATIONS = queueIntegrations.map(
           ({ module: module2, installer, servingActivator }) => `${module2}:${installer}` + (servingActivator ? `:${servingActivator}` : "")
@@ -9154,11 +9417,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
       } else {
         delete env.VERCEL_QUEUE_INTEGRATIONS;
       }
-      const conditionalInjectedPackages = legacyProject ? [] : await getConditionalInjectedPackages({
-        pythonPackage,
-        env
-      });
-      for (const injectedPackage of conditionalInjectedPackages) {
+      for (const injectedPackage of queueAdapterBootstrap.injectedPackages) {
         await installInjectedDevPackage(
           {
             name: injectedPackage.name,
@@ -9169,10 +9428,52 @@ 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)}`
       );
     }
+    const apschedulerSubscribers = [];
+    if (!legacyProject) {
+      const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
+      const declaredSubscribers = await getPyprojectSubscribers(workPath);
+      const introspectionEnv = {
+        ...env,
+        PYTHONPATH: [runtimeDir, env.PYTHONPATH].filter(Boolean).join(import_path13.delimiter)
+      };
+      delete introspectionEnv.VERCEL_APSCHEDULER_SUBSCRIBERS;
+      for (const declaration of declaredSubscribers) {
+        const introspected = await introspectDevQueueSubscriptions({
+          moduleName: declaration.moduleName,
+          subscriberName: declaration.name,
+          variableName: declaration.variableName || "app",
+          pythonBin: spawnCommand,
+          cwd: workPath,
+          env: introspectionEnv,
+          integrations: queueIntegrations
+        });
+        apschedulerSubscribers.push(
+          ...apschedulerSubscriberIdentities([
+            { ...declaration, owners: introspected?.owners ?? [] }
+          ])
+        );
+      }
+    }
+    if (apschedulerSubscribers.length > 0) {
+      env.VERCEL_APSCHEDULER_SUBSCRIBERS = JSON.stringify(
+        apschedulerSubscribers
+      );
+      const previewConfig = await getApschedulerPreviewConfig(workPath);
+      if (previewConfig) {
+        env.VERCEL_APSCHEDULER_PREVIEW_IDLE_TIMEOUT_SECONDS = String(
+          previewConfig.idleTimeoutSeconds
+        );
+      } else {
+        delete env.VERCEL_APSCHEDULER_PREVIEW_IDLE_TIMEOUT_SECONDS;
+      }
+    } else {
+      delete env.VERCEL_APSCHEDULER_SUBSCRIBERS;
+      delete env.VERCEL_APSCHEDULER_PREVIEW_IDLE_TIMEOUT_SECONDS;
+    }
     if (legacyProject) {
       await installInjectedDevPackage(
         {
@@ -9183,7 +9484,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,19 +9498,29 @@ 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");
-        queueSubscriptions = await introspectDevQueueSubscriptions({
+        const subscriberName = getModuleEntrypointName({
           moduleName: modulePath,
+          variableName: variableName || "app"
+        });
+        env.VERCEL_PYTHON_SUBSCRIBER_ID = subscriberName;
+        const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
+        const introspectionEnv = {
+          ...env,
+          PYTHONPATH: [runtimeDir, env.PYTHONPATH].filter(Boolean).join(import_path13.delimiter)
+        };
+        delete introspectionEnv.VERCEL_APSCHEDULER_SUBSCRIBERS;
+        queueSubscriptions = (await introspectDevQueueSubscriptions({
+          moduleName: modulePath,
+          subscriberName,
+          variableName: variableName || "app",
           pythonBin: spawnCommand,
           cwd: workPath,
-          env: {
-            ...env,
-            PYTHONPATH: [runtimeDir, env.PYTHONPATH].filter(Boolean).join(import_path12.delimiter)
-          },
+          env: introspectionEnv,
           integrations: queueIntegrations
-        });
+        }))?.subscriptions;
       } else {
         delete env.VERCEL_DEV_QUEUE_SERVING;
+        delete env.VERCEL_PYTHON_SUBSCRIBER_ID;
         await installInjectedDevPackage(
           {
             name: "vercel-workers",
@@ -9235,7 +9546,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 +9557,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 +9570,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 +9629,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 +9643,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 +9655,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 +9672,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 +9706,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 +9747,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 +9773,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 +9822,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 +9832,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 +9844,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 +9868,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 +9880,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 +9933,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 +9952,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 +9967,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 +10066,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 +10093,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 +10126,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 +10140,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 +10152,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 +10162,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 +10173,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 +10182,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 +10223,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 +10255,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 +10322,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 +10361,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 +10376,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 +10427,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 +10451,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 +10475,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 +10495,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 +10525,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 +10553,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 +10572,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 +10583,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 +10607,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 +10639,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 +10680,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 +10690,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 +10704,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 +10730,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 +10773,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 +10781,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 +10815,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 +10839,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 +10855,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 +10877,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 +10899,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");
@@ -10776,7 +11009,7 @@ async function getDevSidecars({
           use: build2.use,
           src: subscriber.entrypoint,
           config: {
-            handlerFunction: subscriber.variableName,
+            ...subscriber.variableName === void 0 ? {} : { handlerFunction: subscriber.variableName },
             pythonQueueSidecar: "subscriber"
           }
         },
@@ -10799,7 +11032,7 @@ async function getDevSidecars({
             pythonQueueSidecar: "workflow"
           }
         },
-        topics: [{ topic: WORKFLOW_TOPIC_PATTERN }]
+        topics: [{ topic: WORKFLOW_DEV_TOPIC_PATTERN }]
       })
     )
   ];
@@ -11403,11 +11636,14 @@ var build = async ({
     projectDir: (0, import_path21.join)(workPath, entryDirectory),
     pipPlatformArgs
   });
-  const conditionalInjectedPackages = usedUvManagedInstall && !legacyWorkersProject ? await getConditionalInjectedPackages({
+  const queueAdapterBootstrap = await getQueueAdapterBootstrap({
     pythonPackage,
-    env: baseEnv
-  }) : [];
-  for (const injectedPackage of conditionalInjectedPackages) {
+    env: baseEnv,
+    legacyWorkersProject,
+    hasDeclaredSubscribers: await hasPyprojectSubscribers(workPath)
+  });
+  const queueAdapterInjectedPackages = usedUvManagedInstall ? queueAdapterBootstrap.injectedPackages : [];
+  for (const injectedPackage of queueAdapterInjectedPackages) {
     await installInjectedPackage({
       ...injectedPackage,
       uv,
@@ -11424,6 +11660,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) {
@@ -11442,7 +11684,7 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  const queueIntegrations = legacyWorkersProject ? [] : await getQueueIntegrations({ pythonPackage });
+  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)), {
@@ -11465,7 +11707,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 +11726,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 +11734,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(
@@ -11598,6 +11854,18 @@ var build = async ({
       ({ 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 globOptions = {
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
@@ -11934,7 +12202,9 @@ var build = async ({
       runtime: pythonVersion.runtime,
       ...lambdaOptions,
       architecture: target.architecture,
-      environment: lambdaEnv,
+      environment: {
+        ...lambdaEnv
+      },
       supportsResponseStreaming: true
     });
   }
@@ -11972,7 +12242,12 @@ var build = async ({
       handler: `${handlerPyFilename}.vc_handler`,
       runtime: pythonVersion.runtime,
       architecture: target.architecture,
-      environment: lambdaEnv,
+      environment: {
+        ...lambdaEnv,
+        // The runtime activates publish-side integrations before importing the
+        // generated subscriber module, so the identity must already be present.
+        VERCEL_PYTHON_SUBSCRIBER_ID: subscriber.name
+      },
       experimentalTriggers,
       supportsResponseStreaming: true
     });
@@ -11984,6 +12259,11 @@ var build = async ({
       const consumer = getSubscriberConsumerName(declaration.name);
       const legacy = declaration.legacy;
       (0, import_assert.default)(legacy, "legacy subscriber declarations must carry legacy config");
+      const { variableName } = declaration;
+      (0, import_assert.default)(
+        variableName,
+        "legacy subscriber declarations must name an entrypoint object"
+      );
       const experimentalTriggers = legacy.topics.map((topic) => ({
         type: "queue/v2beta",
         topic,
@@ -11998,7 +12278,7 @@ var build = async ({
               moduleName: declaration.moduleName,
               entrypoint: declaration.entrypoint,
               vendorDir,
-              variableName: declaration.variableName
+              variableName
             })
           })
         },