@vercel/python 6.55.3 → 6.56.1

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;
@@ -5158,6 +5170,30 @@ async function hasExplicitVercelSdkDependency(pythonPackage) {
   );
   return names?.has("vercel") ?? false;
 }
+async function getLocalSdkSourcePaths({
+  pythonPackage,
+  env
+}) {
+  const sdkRoot = env.VERCEL_SDK_PYTHON;
+  if (!sdkRoot) {
+    return [];
+  }
+  const names = await getDeclaredDependencyNames(
+    pythonPackage?.manifest?.data?.project?.dependencies
+  );
+  const hasVercelPackage = [...names ?? []].some(
+    (name) => name === "vercel" || name.startsWith("vercel-")
+  );
+  if (!hasVercelPackage) {
+    return [];
+  }
+  const entries = await import_fs.default.promises.readdir((0, import_path.join)(sdkRoot, "src"), {
+    withFileTypes: true
+  });
+  return entries.filter(
+    (entry) => entry.isDirectory() && (entry.name === "vercel" || entry.name.startsWith("vercel-")) && (names?.has("vercel") || names?.has(entry.name))
+  ).map((entry) => entry.name).sort().map((name) => (0, import_path.join)(sdkRoot, "src", name));
+}
 async function getInstalledVercelSdkVersion({
   uv,
   venvPath,
@@ -7979,6 +8015,7 @@ var import_build_utils14 = require("@vercel/build-utils");
 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 +8027,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) => {
@@ -8108,6 +8155,7 @@ function workflowError(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",
@@ -8166,6 +8214,13 @@ 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)}`;
 }
@@ -8178,6 +8233,15 @@ 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_path12.join)(workPath, "pyproject.toml");
   if (!import_fs12.default.existsSync(pyprojectPath)) {
@@ -8207,6 +8271,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,
@@ -8228,10 +8349,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(
           ", "
@@ -8240,9 +8363,9 @@ async function resolveQueueSubscribers({
         )}]${hint}`
       );
     }
-    const subscriptions = kind === "workflow" ? introspected.filter(
+    const subscriptions = kind === "workflow" ? introspected.subscriptions.filter(
       (subscription) => isWorkflowQueueTopic(subscription.topic)
-    ) : filterQueueSubscriptions(declaration, introspected);
+    ) : filterQueueSubscriptions(declaration, introspected.subscriptions);
     if (subscriptions.length === 0) {
       if (kind === "workflow") {
         throw subscriberError(
@@ -8254,7 +8377,7 @@ async function resolveQueueSubscribers({
         `${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;
 }
@@ -8307,8 +8430,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
@@ -8322,14 +8447,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);
@@ -8342,11 +8475,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) {
@@ -8362,7 +8496,8 @@ async function parseSubscriber(workPath, index, config) {
   const base = await parseSubscriberEntrypoint(
     workPath,
     label,
-    config.entrypoint
+    config.entrypoint,
+    { requireVariable: false }
   );
   return {
     ...base,
@@ -8382,7 +8517,8 @@ async function parseLegacySubscriber(workPath, index, config) {
   const base = await parseSubscriberEntrypoint(
     workPath,
     label,
-    config.entrypoint
+    config.entrypoint,
+    { requireVariable: true }
   );
   return {
     ...base,
@@ -8446,14 +8582,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
@@ -8470,7 +8618,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({
@@ -8481,10 +8631,7 @@ async function introspectQueueSubscriptions({
   kind,
   integrations
 }) {
-  const script3 = createQueueIntrospectionScript(
-    declaration.moduleName,
-    integrations
-  );
+  const script3 = createQueueIntrospectionScript(declaration, integrations);
   try {
     const { stdout } = await uv.run({
       venvPath,
@@ -8516,6 +8663,8 @@ async function introspectQueueSubscriptions({
 }
 async function introspectDevQueueSubscriptions({
   moduleName,
+  subscriberName,
+  variableName,
   pythonBin,
   cwd,
   env,
@@ -8524,7 +8673,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.
@@ -8538,12 +8693,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,
@@ -8553,6 +8708,7 @@ async function introspectDevQueueSubscriptions({
         ...maxDeliveries === void 0 ? {} : { maxDeliveries }
       };
     });
+    return { subscriptions, owners: introspected.owners };
   } catch (err) {
     (0, import_build_utils14.debug)(
       `Failed to introspect dev queue subscriptions for module "${moduleName}": ${err instanceof Error ? err.message : String(err)}`
@@ -8569,14 +8725,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}`;
@@ -8620,12 +8790,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_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;
@@ -9087,6 +9272,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(
@@ -9102,7 +9288,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_utils15.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
@@ -9241,7 +9427,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}` : "")
@@ -9249,11 +9441,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,
@@ -9268,6 +9456,48 @@ If you are using a virtual environment, activate it before running "vercel dev",
         `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(
         {
@@ -9292,19 +9522,29 @@ If you are using a virtual environment, activate it before running "vercel dev",
       }
       if (useQueueServing) {
         env.VERCEL_DEV_QUEUE_SERVING = "1";
+        const subscriberName = getModuleEntrypointName({
+          moduleName: modulePath,
+          variableName: variableName || "app"
+        });
+        env.VERCEL_PYTHON_SUBSCRIBER_ID = subscriberName;
         const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
-        queueSubscriptions = await introspectDevQueueSubscriptions({
+        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_path13.delimiter)
-          },
+          env: introspectionEnv,
           integrations: queueIntegrations
-        });
+        }))?.subscriptions;
       } else {
         delete env.VERCEL_DEV_QUEUE_SERVING;
+        delete env.VERCEL_PYTHON_SUBSCRIBER_ID;
         await installInjectedDevPackage(
           {
             name: "vercel-workers",
@@ -10793,7 +11033,7 @@ async function getDevSidecars({
           use: build2.use,
           src: subscriber.entrypoint,
           config: {
-            handlerFunction: subscriber.variableName,
+            ...subscriber.variableName === void 0 ? {} : { handlerFunction: subscriber.variableName },
             pythonQueueSidecar: "subscriber"
           }
         },
@@ -11420,11 +11660,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,
@@ -11433,6 +11676,32 @@ var build = async ({
       pipPlatformArgs
     });
   }
+  const localSdkSourcePaths = await getLocalSdkSourcePaths({
+    pythonPackage,
+    env: baseEnv
+  });
+  if (localSdkSourcePaths.length > 0) {
+    (0, import_build_utils24.debug)(
+      `Installing vercel SDK override from ${baseEnv.VERCEL_SDK_PYTHON}: ` + localSdkSourcePaths.join(", ")
+    );
+    await uv.pip({
+      venvPath,
+      projectDir: (0, import_path21.join)(workPath, entryDirectory),
+      args: [
+        "install",
+        "--link-mode",
+        "copy",
+        // Without --no-sources, uv resolves the checkout's workspace
+        // dependencies as editable .pth installs pointing at the (build
+        // only) checkout mount — invisible to bundling and dangling at
+        // runtime. Explicit paths stay real installs; the remaining
+        // workspace siblings resolve from PyPI.
+        "--no-sources",
+        ...pipPlatformArgs,
+        ...localSdkSourcePaths
+      ]
+    });
+  }
   if (workflows.length > 0) {
     workflowMode = await resolveWorkflowServingMode({
       pythonPackage,
@@ -11465,7 +11734,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)), {
@@ -11635,6 +11904,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
@@ -11971,7 +12252,9 @@ var build = async ({
       runtime: pythonVersion.runtime,
       ...lambdaOptions,
       architecture: target.architecture,
-      environment: lambdaEnv,
+      environment: {
+        ...lambdaEnv
+      },
       supportsResponseStreaming: true
     });
   }
@@ -12009,7 +12292,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
     });
@@ -12021,6 +12309,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,
@@ -12035,7 +12328,7 @@ var build = async ({
               moduleName: declaration.moduleName,
               entrypoint: declaration.entrypoint,
               vendorDir,
-              variableName: declaration.variableName
+              variableName
             })
           })
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.55.3",
+  "version": "6.56.1",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -14,7 +14,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.13.1"
+    "@vercel/python-analysis": "0.13.2"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -33,20 +33,17 @@
     "pip-requirements-js": "1.0.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "vitest": "2.1.4",
+    "vitest": "4.1.10",
     "which": "3.0.0",
-    "@vercel/error-utils": "2.2.1",
-    "@vercel/build-utils": "14.0.2",
-    "@vercel/python-runtime": "0.18.0"
+    "@vercel/build-utils": "14.0.5",
+    "@vercel/python-runtime": "0.19.0",
+    "@vercel/error-utils": "2.2.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
     "type-check": "tsc --noEmit",
     "test": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 NODE_OPTIONS=--experimental-vm-modules vitest run --config ../../vitest.config.mts",
-    "test-unit": "vitest run --config ../../vitest.config.mts test/unit",
-    "test-e2e": "pnpm test test/integration-*",
-    "vitest-run": "vitest -c ../../vitest.config.mts",
-    "vitest-unit": "pnpm test test/unit",
-    "vitest-e2e": "glob --absolute 'test/integration-*'"
+    "test-unit": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 NODE_OPTIONS=--experimental-vm-modules vitest run --config ../../vitest.config.mts test/unit",
+    "test-e2e": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 NODE_OPTIONS=--experimental-vm-modules vitest run --config ../../vitest.config.mts test/integration-"
   }
 }