@vercel/python 6.0.2 → 6.0.4

package/dist/index.js

@@ -2751,7 +2751,7 @@ module.exports = __toCommonJS(src_exports);
 var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path5 = require("path");
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
@@ -3004,7 +3004,12 @@ async function exportRequirementsFromUv(projectDir, uvPath, options = {}) {
   if (!uvPath) {
     throw new Error("uv is not available to export requirements");
   }
-  const args = ["export"];
+  const args = [
+    "export",
+    "--no-default-groups",
+    "--no-emit-workspace",
+    "--no-editable"
+  ];
   if (locked) {
     args.push("--frozen");
   }
@@ -3066,7 +3071,7 @@ async function exportRequirementsFromPipfile({
 }
 
 // src/index.ts
-var import_build_utils7 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/version.ts
 var import_build_utils2 = require("@vercel/build-utils");
@@ -3199,7 +3204,7 @@ function isInstalled2({ pipPath, pythonPath }) {
 var import_child_process = require("child_process");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
 var import_fs2 = __toESM(require("fs"));
@@ -3329,6 +3334,8 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
 // src/utils.ts
 var import_fs3 = __toESM(require("fs"));
 var import_path3 = require("path");
+var import_execa2 = __toESM(require_execa());
+var import_build_utils5 = require("@vercel/build-utils");
 var isInVirtualEnv = () => {
   return process.env.VIRTUAL_ENV;
 };
@@ -3349,6 +3356,51 @@ function useVirtualEnv(workPath, env, systemPython) {
   }
   return { pythonCmd };
 }
+async function runPyprojectScript(workPath, scriptNames, env) {
+  const pyprojectPath = (0, import_path3.join)(workPath, "pyproject.toml");
+  if (!import_fs3.default.existsSync(pyprojectPath))
+    return false;
+  let pyproject = null;
+  try {
+    pyproject = await (0, import_build_utils5.readConfigFile)(pyprojectPath);
+  } catch {
+    console.error("Failed to parse pyproject.toml");
+    return false;
+  }
+  const scripts = pyproject?.tool?.vercel?.scripts || {};
+  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
+  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
+  if (!scriptToRun)
+    return false;
+  const systemPython = process.platform === "win32" ? "python" : "python3";
+  const finalEnv = { ...process.env, ...env };
+  const { pythonCmd } = useVirtualEnv(workPath, finalEnv, systemPython);
+  const uvPath = await getUvBinaryOrInstall(pythonCmd);
+  const scriptCommand = scripts[scriptToRun];
+  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
+    const uvDir = (0, import_path3.dirname)(uvPath);
+    finalEnv.PATH = `${uvDir}${import_path3.delimiter}${finalEnv.PATH || ""}`;
+    if (/^\s*uv(\s|$)/i.test(scriptCommand)) {
+      console.log(`Executing: ${scriptCommand}`);
+      await (0, import_build_utils5.execCommand)(scriptCommand, {
+        cwd: workPath,
+        env: finalEnv
+      });
+      return true;
+    }
+    const args = process.platform === "win32" ? ["run", "cmd", "/d", "/s", "/c", scriptCommand] : ["run", "sh", "-lc", scriptCommand];
+    console.log(
+      `Executing: ${uvPath} ${args.map((a) => /\s/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a).join(" ")}`
+    );
+    await (0, import_execa2.default)(uvPath, args, {
+      cwd: workPath,
+      stdio: "inherit",
+      env: finalEnv
+    });
+    return true;
+  }
+  return false;
+}
 
 // src/start-dev-server.ts
 function silenceNodeWarnings() {
@@ -3393,12 +3445,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils6.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -3406,7 +3458,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils6.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -3432,10 +3484,10 @@ function createDevAsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils5.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils5.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3448,10 +3500,10 @@ function createDevWsgiShim(workPath, modulePath) {
     const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
     (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils5.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_build_utils6.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils5.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils6.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
     return null;
   }
 }
@@ -3471,7 +3523,7 @@ var startDevServer = async (opts) => {
   );
   if (!entry) {
     const searched = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils5.NowBuildError({
+    throw new import_build_utils6.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searched} or add an 'app' script in pyproject.toml.`,
       link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
@@ -3521,7 +3573,7 @@ var startDevServer = async (opts) => {
       let pythonCmd = systemPython;
       const venv = isInVirtualEnv();
       if (venv) {
-        (0, import_build_utils5.debug)(`Running in virtualenv at ${venv}`);
+        (0, import_build_utils6.debug)(`Running in virtualenv at ${venv}`);
       } else {
         const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
           workPath,
@@ -3530,9 +3582,9 @@ var startDevServer = async (opts) => {
         );
         pythonCmd = venvPythonCmd;
         if (venvRoot) {
-          (0, import_build_utils5.debug)(`Using virtualenv at ${venvRoot}`);
+          (0, import_build_utils6.debug)(`Using virtualenv at ${venvRoot}`);
         } else {
-          (0, import_build_utils5.debug)("No virtualenv found");
+          (0, import_build_utils6.debug)("No virtualenv found");
           try {
             const yellow = "\x1B[33m";
             const reset = "\x1B[0m";
@@ -3555,7 +3607,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils5.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting ASGI dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3633,7 +3685,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
         }
         const moduleToRun = devShimModule || modulePath;
         const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils5.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
+        (0, import_build_utils6.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
         const child = (0, import_child_process.spawn)(pythonCmd, argv, {
           cwd: workPath,
           env,
@@ -3743,13 +3795,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils6.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils6.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   if (meta.isDev) {
     const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
     const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
-    await (0, import_build_utils6.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils6.glob)("**", destCache);
+    await (0, import_build_utils7.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils7.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -3777,7 +3829,50 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+  if (framework === "fastapi" || framework === "flask") {
+    const {
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      turboSupportsCorepackHome
+    } = await (0, import_build_utils7.scanParentDirs)(workPath, true);
+    const spawnEnv = (0, import_build_utils7.getEnvForPackageManager)({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      env: process.env,
+      turboSupportsCorepackHome,
+      projectCreatedAt: config?.projectSettings?.createdAt
+    });
+    const installCommand = config?.projectSettings?.installCommand;
+    if (typeof installCommand === "string") {
+      if (installCommand.trim()) {
+        console.log(`Running "install" command: \`${installCommand}\`...`);
+        await (0, import_build_utils7.execCommand)(installCommand, {
+          env: spawnEnv,
+          cwd: workPath
+        });
+      } else {
+        console.log('Skipping "install" command...');
+      }
+    }
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    if (projectBuildCommand) {
+      console.log(`Running "${projectBuildCommand}"`);
+      await (0, import_build_utils7.execCommand)(projectBuildCommand, {
+        env: spawnEnv,
+        cwd: workPath
+      });
+    } else {
+      await runPyprojectScript(
+        workPath,
+        ["vercel-build", "now-build", "build"],
+        spawnEnv
+      );
+    }
+  }
+  let fsFiles = await (0, import_build_utils7.glob)("**", workPath);
   if ((framework === "fastapi" || framework === "flask") && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
@@ -3785,13 +3880,13 @@ var build = async ({
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils6.debug)(
+      (0, import_build_utils7.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils6.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Define a valid application entrypoint in one of the following locations: ${searchedList} or add an 'app' script in pyproject.toml.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -3820,20 +3915,20 @@ var build = async ({
   if (pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils7.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils8.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils6.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
     }
     const VERSION_REGEX = /\b\d+\.\d+\b/;
     const exact = requiresPython?.trim().match(VERSION_REGEX)?.[0];
     if (exact) {
       declaredPythonVersion = { version: exact, source: "pyproject.toml" };
-      (0, import_build_utils6.debug)(
+      (0, import_build_utils7.debug)(
         `Found Python version ${exact} in pyproject.toml (requires-python: "${requiresPython}")`
       );
     } else if (requiresPython) {
-      (0, import_build_utils6.debug)(
+      (0, import_build_utils7.debug)(
         `Could not parse Python version from pyproject.toml requires-python: "${requiresPython}"`
       );
     }
@@ -3843,7 +3938,7 @@ var build = async ({
       const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils6.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -3851,14 +3946,14 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils6.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils7.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+  fsFiles = await (0, import_build_utils7.glob)("**", workPath);
   const requirementsTxt = (0, import_path5.join)(entryDirectory, "requirements.txt");
   const vendorBaseDir = (0, import_path5.join)(
     workPath,
@@ -3903,7 +3998,7 @@ var build = async ({
         `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    (0, import_build_utils6.debug)("Failed to install uv", err);
+    (0, import_build_utils7.debug)("Failed to install uv", err);
   }
   await installRequirement({
     pythonPath: pythonVersion.pythonPath,
@@ -3915,9 +4010,21 @@ var build = async ({
     targetDir: vendorBaseDir,
     meta
   });
+  if (framework !== "flask") {
+    await installRequirement({
+      pythonPath: pythonVersion.pythonPath,
+      pipPath: pythonVersion.pipPath,
+      uvPath,
+      dependency: "uvicorn",
+      version: "0.38.0",
+      workPath,
+      targetDir: vendorBaseDir,
+      meta
+    });
+  }
   let installedFromProjectFiles = false;
   if (uvLockDir) {
-    (0, import_build_utils6.debug)('Found "uv.lock"');
+    (0, import_build_utils7.debug)('Found "uv.lock"');
     if (pyprojectDir) {
       const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
         locked: true
@@ -3933,10 +4040,10 @@ var build = async ({
       });
       installedFromProjectFiles = true;
     } else {
-      (0, import_build_utils6.debug)('Skipping uv export because "pyproject.toml" was not found');
+      (0, import_build_utils7.debug)('Skipping uv export because "pyproject.toml" was not found');
     }
   } else if (pyprojectDir) {
-    (0, import_build_utils6.debug)('Found "pyproject.toml"');
+    (0, import_build_utils7.debug)('Found "pyproject.toml"');
     if (hasReqLocal || hasReqGlobal) {
       console.log(
         "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
@@ -3956,9 +4063,9 @@ var build = async ({
     });
     installedFromProjectFiles = true;
   } else if (pipfileLockDir || pipfileDir) {
-    (0, import_build_utils6.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
+    (0, import_build_utils7.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
     if (hasReqLocal || hasReqGlobal) {
-      (0, import_build_utils6.debug)('Skipping Pipfile export because "requirements.txt" exists');
+      (0, import_build_utils7.debug)('Skipping Pipfile export because "requirements.txt" exists');
     } else {
       const exportedReq = await exportRequirementsFromPipfile({
         pythonPath: pythonVersion.pythonPath,
@@ -3980,7 +4087,7 @@ var build = async ({
     }
   }
   if (!installedFromProjectFiles && fsFiles[requirementsTxt]) {
-    (0, import_build_utils6.debug)('Found local "requirements.txt"');
+    (0, import_build_utils7.debug)('Found local "requirements.txt"');
     const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -3992,7 +4099,7 @@ var build = async ({
       meta
     });
   } else if (!installedFromProjectFiles && fsFiles["requirements.txt"]) {
-    (0, import_build_utils6.debug)('Found global "requirements.txt"');
+    (0, import_build_utils7.debug)('Found global "requirements.txt"');
     const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
     await installRequirementsFile({
       pythonPath: pythonVersion.pythonPath,
@@ -4006,12 +4113,12 @@ var build = async ({
   }
   const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils6.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils7.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils6.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils7.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
@@ -4026,7 +4133,10 @@ var build = async ({
     "**/__pycache__/**",
     "**/.mypy_cache/**",
     "**/.ruff_cache/**",
-    "**/public/**"
+    "**/public/**",
+    "**/pnpm-lock.yaml",
+    "**/yarn.lock",
+    "**/package-lock.json"
   ];
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
@@ -4034,11 +4144,11 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils6.glob)("**", globOptions);
+  const files = await (0, import_build_utils7.glob)("**", globOptions);
   try {
     const cachedVendorAbs = (0, import_path5.join)(vendorBaseDir, resolveVendorDir());
     if (import_fs5.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils6.glob)("**", cachedVendorAbs, resolveVendorDir());
+      const vendorFiles = await (0, import_build_utils7.glob)("**", cachedVendorAbs, resolveVendorDir());
       for (const [p, f] of Object.entries(vendorFiles)) {
         files[p] = f;
       }
@@ -4048,12 +4158,12 @@ var build = async ({
     throw err;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils6.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils7.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils6.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils7.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils6.Lambda({
+  const output = new import_build_utils7.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -21,7 +21,7 @@
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
     "@types/which": "3.0.0",
-    "@vercel/build-utils": "13.0.0",
+    "@vercel/build-utils": "13.0.1",
     "cross-env": "7.0.3",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",

package/vc_init.py

@@ -210,12 +210,17 @@ if 'VERCEL_IPC_PATH' in os.environ:
 
 
 # Import relative path https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
-user_mod_path = os.path.join(_here, "__VC_HANDLER_ENTRYPOINT")  # absolute
-__vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", user_mod_path)
-__vc_module = util.module_from_spec(__vc_spec)
-sys.modules["__VC_HANDLER_MODULE_NAME"] = __vc_module
-__vc_spec.loader.exec_module(__vc_module)
-__vc_variables = dir(__vc_module)
+try:
+    user_mod_path = os.path.join(_here, "__VC_HANDLER_ENTRYPOINT")  # absolute
+    __vc_spec = util.spec_from_file_location("__VC_HANDLER_MODULE_NAME", user_mod_path)
+    __vc_module = util.module_from_spec(__vc_spec)
+    sys.modules["__VC_HANDLER_MODULE_NAME"] = __vc_module
+    __vc_spec.loader.exec_module(__vc_module)
+    __vc_variables = dir(__vc_module)
+except Exception:
+    _stderr(f'Error importing __VC_HANDLER_ENTRYPOINT:')
+    _stderr(traceback.format_exc())
+    exit(1)
 
 _use_legacy_asyncio = sys.version_info < (3, 10)
 
@@ -231,6 +236,95 @@ def format_headers(headers, decode=False):
     return keyToList
 
 
+class ASGIMiddleware:
+    """
+    ASGI middleware that preserves Vercel IPC semantics for request lifecycle:
+    - Handles /_vercel/ping
+    - Extracts x-vercel-internal-* headers and removes them from downstream app
+    - Sets request context into `storage` for logging/metrics
+    - Emits handler-started and end IPC messages
+    """
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope.get('type') != 'http':
+            # Non-HTTP traffic is forwarded verbatim
+            await self.app(scope, receive, send)
+            return
+
+        if scope.get('path') == '/_vercel/ping':
+            await send({
+                'type': 'http.response.start',
+                'status': 200,
+                'headers': [],
+            })
+            await send({
+                'type': 'http.response.body',
+                'body': b'',
+                'more_body': False,
+            })
+            return
+
+        # Extract internal headers and set per-request context
+        headers_list = scope.get('headers', []) or []
+        new_headers = []
+        invocation_id = "0"
+        request_id = 0
+
+        def _b2s(b: bytes) -> str:
+            try:
+                return b.decode()
+            except Exception:
+                return ''
+
+        for k, v in headers_list:
+            key = _b2s(k).lower()
+            val = _b2s(v)
+            if key == 'x-vercel-internal-invocation-id':
+                invocation_id = val
+                continue
+            if key == 'x-vercel-internal-request-id':
+                request_id = int(val) if val.isdigit() else 0
+                continue
+            if key in ('x-vercel-internal-span-id', 'x-vercel-internal-trace-id'):
+                continue
+            new_headers.append((k, v))
+
+        new_scope = dict(scope)
+        new_scope['headers'] = new_headers
+
+        # Announce handler start and set context for logging/metrics
+        send_message({
+            "type": "handler-started",
+            "payload": {
+                "handlerStartedAt": int(time.time() * 1000),
+                "context": {
+                    "invocationId": invocation_id,
+                    "requestId": request_id,
+                }
+            }
+        })
+
+        token = storage.set({
+            "invocationId": invocation_id,
+            "requestId": request_id,
+        })
+
+        try:
+            await self.app(new_scope, receive, send)
+        finally:
+            storage.reset(token)
+            send_message({
+                "type": "end",
+                "payload": {
+                    "context": {
+                        "invocationId": invocation_id,
+                        "requestId": request_id,
+                    }
+                }
+            })
+
 if 'VERCEL_IPC_PATH' in os.environ:
     start_time = time.time()
 
@@ -424,80 +518,53 @@ if 'VERCEL_IPC_PATH' in os.environ:
                         if hasattr(response, 'close'):
                             response.close()
         else:
-            from urllib.parse import urlparse
-            from io import BytesIO
-            import asyncio
-
-            app = __vc_module.app
-
-            class Handler(BaseHandler):
-                def handle_request(self):
-                    # Prepare ASGI scope
-                    url = urlparse(self.path)
-                    headers_encoded = []
-                    for k, v in self.headers.items():
-                        # Cope with repeated headers in the encoding.
-                        if isinstance(v, list):
-                            headers_encoded.append([k.lower().encode(), [i.encode() for i in v]])
-                        else:
-                            headers_encoded.append([k.lower().encode(), v.encode()])
-                    scope = {
-                        'server': (self.headers.get('host', 'lambda'), self.headers.get('x-forwarded-port', 80)),
-                        'client': (self.headers.get(
-                            'x-forwarded-for', self.headers.get(
-                                'x-real-ip')), 0),
-                        'scheme': self.headers.get('x-forwarded-proto', 'http'),
-                        'root_path': '',
-                        'query_string': url.query.encode(),
-                        'headers': headers_encoded,
-                        'type': 'http',
-                        'http_version': '1.1',
-                        'method': self.command,
-                        'path': url.path,
-                        'raw_path': url.path.encode(),
-                    }
+            # ASGI: Run with Uvicorn so we get proper lifespan and protocol handling
+            try:
+                import uvicorn
+            except Exception:
+                _stderr('Uvicorn is required to run ASGI apps. Please ensure it is installed.')
+                exit(1)
+
+            # Prefer a callable app.asgi when available; some frameworks expose a boolean here
+            user_app_candidate = getattr(__vc_module.app, 'asgi', None)
+            user_app = user_app_candidate if callable(user_app_candidate) else __vc_module.app
+            asgi_app = ASGIMiddleware(user_app)
+
+            # Pre-bind a socket to obtain an ephemeral port for IPC announcement
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.bind(('127.0.0.1', 0))
+            sock.listen(2048)
+            http_port = sock.getsockname()[1]
+
+            config = uvicorn.Config(
+                app=asgi_app,
+                fd=sock.fileno(),
+                lifespan='auto',
+                access_log=False,
+                log_config=None,
+                log_level='warning',
+            )
+            server = uvicorn.Server(config)
 
-                    if 'content-length' in self.headers:
-                        content_length = int(self.headers['content-length'])
-                        body = self.rfile.read(content_length)
-                    else:
-                        body = b''
+            send_message({
+                "type": "server-started",
+                "payload": {
+                    "initDuration": int((time.time() - start_time) * 1000),
+                    "httpPort": http_port,
+                }
+            })
 
-                    if _use_legacy_asyncio:
-                        loop = asyncio.new_event_loop()
-                        app_queue = asyncio.Queue(loop=loop)
-                    else:
-                        app_queue = asyncio.Queue()
-                    app_queue.put_nowait({'type': 'http.request', 'body': body, 'more_body': False})
-
-                    # Prepare ASGI receive function
-                    async def receive():
-                        message = await app_queue.get()
-                        return message
-
-                    # Prepare ASGI send function
-                    response_started = False
-                    async def send(event):
-                        nonlocal response_started
-                        if event['type'] == 'http.response.start':
-                            self.send_response(event['status'])
-                            if 'headers' in event:
-                                for name, value in event['headers']:
-                                    self.send_header(name.decode(), value.decode())
-                            self.end_headers()
-                            response_started = True
-                        elif event['type'] == 'http.response.body':
-                            self.wfile.write(event['body'])
-                            if not event.get('more_body', False):
-                                self.wfile.flush()
+            # Mark IPC as ready and flush any buffered init logs
+            _ipc_ready = True
+            for m in _init_log_buf:
+                send_message(m)
+            _init_log_buf.clear()
 
-                    # Run the ASGI application
-                    asgi_instance = app(scope, receive, send)
-                    if _use_legacy_asyncio:
-                        asgi_task = loop.create_task(asgi_instance)
-                        loop.run_until_complete(asgi_task)
-                    else:
-                        asyncio.run(asgi_instance)
+            # Run the server (blocking)
+            server.run()
+            # If the server ever returns, exit
+            sys.exit(0)
 
     if 'Handler' in locals():
         server = ThreadingHTTPServer(('127.0.0.1', 0), Handler)

package/vc_init_dev_asgi.py

@@ -39,8 +39,9 @@ if _app is None:
         f"Missing 'app' in module '{USER_MODULE}'. Define `app = ...` (ASGI app)."
     )
 
-# Sanic compatibility: prefer `app.asgi` when available
-USER_ASGI_APP = getattr(_app, 'asgi', _app)
+# Prefer a callable app.asgi when available; some frameworks expose a boolean here
+_CAND = getattr(_app, 'asgi', None)
+USER_ASGI_APP = _CAND if callable(_CAND) else _app
 
 PUBLIC_DIR = 'public'