@vercel/python 6.21.0 → 6.22.1

package/dist/index.js

@@ -2862,7 +2862,6 @@ __export(src_exports, {
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
-  prepareCache: () => prepareCache,
   runFrameworkHook: () => runFrameworkHook,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
@@ -2873,7 +2872,7 @@ var import_fs10 = __toESM(require("fs"));
 var import_path12 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.6.0";
+var VERCEL_RUNTIME_VERSION = "0.7.0";
 var VERCEL_WORKERS_VERSION = "0.0.12";
 
 // src/index.ts
@@ -2904,19 +2903,14 @@ var import_build_utils = require("@vercel/build-utils");
 var UV_VERSION = "0.9.22";
 var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
-var UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
 var isWin = process.platform === "win32";
 var uvExec = isWin ? "uv.exe" : "uv";
 function findUvInPath() {
   return import_which.default.sync("uv", { nothrow: true });
 }
-function getUvCacheDir(workPath) {
-  return (0, import_path.join)(workPath, ...UV_CACHE_DIR_SUBPATH);
-}
 var UvRunner = class {
-  constructor(uvPath, uvCacheDir) {
+  constructor(uvPath) {
     this.uvPath = uvPath;
-    this.uvCacheDir = uvCacheDir;
   }
   getPath() {
     return this.uvPath;
@@ -2993,7 +2987,7 @@ var UvRunner = class {
     try {
       await (0, import_execa.default)(this.uvPath, args, {
         cwd: projectDir,
-        env: getProtectedUvEnv(process.env, this.uvCacheDir)
+        env: getProtectedUvEnv(process.env)
       });
     } catch (err) {
       const error = new Error(
@@ -3058,7 +3052,7 @@ var UvRunner = class {
     const binDir = isWin ? (0, import_path.join)(venvPath, "Scripts") : (0, import_path.join)(venvPath, "bin");
     const existingPath = process.env.PATH || "";
     return {
-      ...getProtectedUvEnv(process.env, this.uvCacheDir),
+      ...getProtectedUvEnv(process.env),
       VIRTUAL_ENV: venvPath,
       PATH: existingPath ? `${binDir}${import_path2.delimiter}${existingPath}` : binDir
     };
@@ -3165,15 +3159,11 @@ async function getUvBinaryOrInstall(pythonPath) {
 function filterUnsafeUvPipArgs(args) {
   return args.filter((arg) => arg !== "--no-warn-script-location");
 }
-function getProtectedUvEnv(baseEnv = process.env, uvCacheDir) {
-  const env = {
+function getProtectedUvEnv(baseEnv = process.env) {
+  return {
     ...baseEnv,
     UV_PYTHON_DOWNLOADS: UV_PYTHON_DOWNLOADS_MODE
   };
-  if (uvCacheDir) {
-    env.UV_CACHE_DIR = uvCacheDir;
-  }
-  return env;
 }
 var UV_BUNDLE_DIR = "_uv";
 async function getUvBinaryForBundling(pythonPath) {
@@ -3212,9 +3202,9 @@ function useVirtualEnv(workPath, env, systemPython) {
   }
   return { pythonCmd };
 }
-function createVenvEnv(venvPath, baseEnv = process.env, uvCacheDir) {
+function createVenvEnv(venvPath, baseEnv = process.env) {
   const env = {
-    ...getProtectedUvEnv(baseEnv, uvCacheDir),
+    ...getProtectedUvEnv(baseEnv),
     VIRTUAL_ENV: venvPath
   };
   const binDir = getVenvBinDir(venvPath);
@@ -3226,7 +3216,6 @@ async function ensureVenv({
   pythonPath,
   venvPath,
   uvPath,
-  uvCacheDir,
   quiet
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
@@ -3240,9 +3229,7 @@ async function ensureVenv({
     console.log(`Creating virtual environment at "${venvPath}"...`);
   }
   if (uvPath) {
-    await (0, import_execa2.default)(uvPath, ["venv", venvPath], {
-      env: getProtectedUvEnv(process.env, uvCacheDir)
-    });
+    await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
   } else {
     await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
   }
@@ -3749,7 +3736,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     try {
       await (0, import_execa3.default)(uvPath, uvArgs, {
         cwd: workPath,
-        env: getProtectedUvEnv(process.env, getUvCacheDir(workPath))
+        env: getProtectedUvEnv()
       });
       return;
     } catch (err) {
@@ -4568,6 +4555,77 @@ async function runSync({
     });
   });
 }
+async function installVercelRuntime({
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  const targetDir = (0, import_path8.join)(workPath, ".vercel", "python");
+  (0, import_fs6.mkdirSync)(targetDir, { recursive: true });
+  const localRuntimeDir = (0, import_path8.join)(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "python",
+    "vercel-runtime"
+  );
+  const isLocalDev = (0, import_fs6.existsSync)((0, import_path8.join)(localRuntimeDir, "pyproject.toml"));
+  const runtimeDep = env.VERCEL_RUNTIME_PYTHON || (isLocalDev ? localRuntimeDir : `vercel-runtime==${VERCEL_RUNTIME_VERSION}`);
+  if (!isLocalDev && !env.VERCEL_RUNTIME_PYTHON) {
+    const distInfo = (0, import_path8.join)(
+      targetDir,
+      `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
+    );
+    if ((0, import_fs6.existsSync)(distInfo)) {
+      (0, import_build_utils8.debug)(
+        `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
+      );
+      return;
+    }
+  }
+  (0, import_build_utils8.debug)(
+    `Installing vercel-runtime into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${runtimeDep})`
+  );
+  const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
+  const spawnArgs = [...pip.prefix, "--target", targetDir, runtimeDep];
+  await new Promise((resolve2, reject) => {
+    const child = (0, import_child_process2.spawn)(pip.cmd, spawnArgs, {
+      cwd: workPath,
+      env: getProtectedUvEnv(env),
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      if (onStdout) {
+        onStdout(data);
+      } else {
+        (0, import_build_utils8.debug)(data.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (onStderr) {
+        onStderr(data);
+      } else {
+        (0, import_build_utils8.debug)(data.toString());
+      }
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(
+          new Error(
+            `Installing vercel-runtime failed with code ${code}, signal ${signal}`
+          )
+        );
+      }
+    });
+  });
+}
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var restoreWarnings = null;
@@ -4645,12 +4703,7 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path8.join)(workPath, ".venv");
-  await ensureVenv({
-    pythonPath: systemPython,
-    venvPath,
-    uvPath,
-    quiet: true
-  });
+  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
   (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
@@ -4809,6 +4862,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
         onStderr
       });
     }
+    await installVercelRuntime({
+      workPath,
+      uvPath,
+      pythonBin: spawnCommand,
+      env
+    });
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
     const devShim = createDevShim(workPath, entry, modulePath);
@@ -5507,12 +5566,10 @@ var build = async ({
   }
   fsFiles = await (0, import_build_utils13.glob)("**", workPath);
   const venvPath = (0, import_path12.join)(workPath, ".vercel", "python", ".venv");
-  const uvCacheDir = getUvCacheDir(workPath);
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
-      venvPath,
-      uvCacheDir
+      venvPath
     });
   });
   if ((0, import_build_utils13.isPythonFramework)(framework)) {
@@ -5541,14 +5598,14 @@ var build = async ({
     }
   }
   const baseEnv = spawnEnv || process.env;
-  const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
+  const pythonEnv = createVenvEnv(venvPath, baseEnv);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
   let uv;
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
     console.log(`Using uv at "${uvPath}"`);
-    uv = new UvRunner(uvPath, uvCacheDir);
+    uv = new UvRunner(uvPath);
   } catch (err) {
     console.log("Failed to install or locate uv");
     throw new Error(
@@ -5805,41 +5862,6 @@ from vercel_runtime.vc_init import vc_handler
   });
   return { output };
 };
-async function readBuildOutputV3Config(workPath) {
-  try {
-    const configPath = (0, import_path12.join)(workPath, ".vercel", "output", "config.json");
-    return JSON.parse(await import_fs10.default.promises.readFile(configPath, "utf8"));
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-  }
-  return void 0;
-}
-var prepareCache = async ({
-  repoRootPath,
-  workPath
-}) => {
-  const cacheFiles = {};
-  const root = repoRootPath || workPath;
-  const ignore = ["**/*.pyc", "**/__pycache__/**"];
-  const configV3 = await readBuildOutputV3Config(workPath);
-  if (configV3?.cache && Array.isArray(configV3.cache)) {
-    for (const cacheGlob of configV3.cache) {
-      Object.assign(cacheFiles, await (0, import_build_utils13.glob)(cacheGlob, workPath));
-    }
-    return cacheFiles;
-  }
-  Object.assign(
-    cacheFiles,
-    await (0, import_build_utils13.glob)("**/.vercel/python/.venv/**", { cwd: root, ignore })
-  );
-  Object.assign(
-    cacheFiles,
-    await (0, import_build_utils13.glob)("**/.vercel/python/cache/uv/**", { cwd: root, ignore })
-  );
-  return cacheFiles;
-};
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
   if ((0, import_build_utils13.isPythonFramework)(framework)) {
@@ -5877,7 +5899,6 @@ function hasProp(obj, key) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
-  prepareCache,
   runFrameworkHook,
   shouldServe,
   startDevServer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.21.0",
+  "version": "6.22.1",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -15,7 +15,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.9.0"
+    "@vercel/python-analysis": "0.9.1"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -35,9 +35,9 @@
     "which": "3.0.0",
     "get-port": "5.1.1",
     "is-port-reachable": "3.1.0",
-    "@vercel/build-utils": "13.7.0",
+    "@vercel/build-utils": "13.8.0",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/python-runtime": "0.6.0"
+    "@vercel/python-runtime": "0.7.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/templates/vc_init_dev.py

@@ -1,596 +1,15 @@
-# Auto-generated template used by vercel dev (Python, ASGI/WSGI)
-# Serves static files from PUBLIC_DIR before delegating to the user app.
+# Auto-generated trampoline used by vercel dev (Python, ASGI/WSGI)
 
-import sys
 import os
-import inspect
-import logging
-import logging.config
-from os import path as _p
-from importlib import util as _importlib_util
-import mimetypes
 
-
-# Simple ANSI coloring. Respect NO_COLOR environment variable.
-_NO_COLOR = "NO_COLOR" in os.environ
-_RESET = "\x1b[0m"
-_YELLOW = "\x1b[33m"
-_GREEN = "\x1b[32m"
-_RED = "\x1b[31m"
-
-
-def _color(text: str, code: str) -> str:
-    if _NO_COLOR:
-        return text
-    return f"{code}{text}{_RESET}"
-
-
-# Configure logging to output DEBUG-WARNING to the stdout
-# and ERROR-CRITICAL to the stderr.
-
-
-# We need a custom filter for the stdout stream
-# so it won't print anything higher than WARNING.
-class _MaxLevelFilter(logging.Filter):
-    def __init__(self, max_level):
-        super().__init__()
-        self.max_level = max_level
-
-    def filter(self, record):
-        return record.levelno <= self.max_level
-
-
-def _build_log_config(loggers, _filter_ref=None) -> dict:
-    if _filter_ref is None:
-        _filter_ref = "vc_init_dev._MaxLevelFilter"
-
-    return {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "filters": {
-            "max_warning": {
-                "()": _filter_ref,
-                "max_level": logging.WARNING,
-            }
-        },
-        "handlers": {
-            "stdout": {
-                "class": "logging.StreamHandler",
-                "stream": "ext://sys.stdout",
-                "filters": ["max_warning"],
-            },
-            "stderr": {
-                "class": "logging.StreamHandler",
-                "stream": "ext://sys.stderr",
-                "level": "ERROR",
-            },
-        },
-        "loggers": loggers,
-        "root": {
-            "handlers": ["stdout", "stderr"],
-            "level": "INFO",
-        },
-    }
-
-
-def _setup_server_log_routing(logger_name=None):
-    loggers = {}
-
-    if logger_name:
-        loggers[logger_name] = {
-            "handlers": ["stdout", "stderr"],
-            "level": "INFO",
-            "propagate": False,
-        }
-
-    logging.config.dictConfig(
-        _build_log_config(
-            loggers=loggers,
-            _filter_ref=_MaxLevelFilter,
-        ),
-    )
-
-
-def _build_uvicorn_log_config(default_fmt=None, access_fmt=None) -> dict:
-    try:
-        from uvicorn.config import LOGGING_CONFIG  # type: ignore
-
-        uvicorn_fmts = LOGGING_CONFIG["formatters"]
-    except ImportError:
-        uvicorn_fmts = {
-            "default": {
-                "()": "uvicorn.logging.DefaultFormatter",
-                "fmt": "%(levelprefix)s %(message)s",
-                "use_colors": None,
-            },
-            "access": {
-                "()": "uvicorn.logging.AccessFormatter",
-                "fmt": '%(levelprefix)s %(client_addr)s - "%(request_line)s" %(status_code)s',
-            },
-        }
-
-    cfg = _build_log_config(
-        loggers={
-            "uvicorn": {
-                "handlers": ["stdout", "stderr"],
-                "level": "INFO",
-                "propagate": False,
-            },
-            "uvicorn.error": {"level": "INFO"},
-            "uvicorn.access": {
-                "handlers": ["access"],
-                "level": "INFO",
-                "propagate": False,
-            },
-        },
-    )
-
-    if default_fmt is None:
-        default_fmt = {**uvicorn_fmts["default"], "use_colors": not _NO_COLOR}
-
-    if access_fmt is None:
-        access_fmt = {**uvicorn_fmts["access"], "use_colors": not _NO_COLOR}
-
-    cfg["formatters"] = {"default": default_fmt, "access": access_fmt}
-    cfg["handlers"]["stdout"]["formatter"] = "default"
-    cfg["handlers"]["stderr"]["formatter"] = "default"
-    cfg["handlers"]["access"] = {
-        "class": "logging.StreamHandler",
-        "stream": "ext://sys.stdout",
-        "formatter": "access",
+os.environ.update(
+    {
+        "VERCEL_DEV_MODULE_NAME": "__VC_DEV_MODULE_NAME__",
+        "VERCEL_DEV_ENTRY_ABS": "__VC_DEV_ENTRY_ABS__",
     }
-
-    return cfg
-
-
-def _build_hypercorn_log_config():
-    return _build_log_config(
-        loggers={
-            "hypercorn.error": {
-                "handlers": ["stdout", "stderr"],
-                "level": "INFO",
-                "propagate": False,
-            },
-            "hypercorn.access": {
-                "handlers": ["stdout"],
-                "level": "INFO",
-                "propagate": False,
-            },
-        },
-    )
-
-
-def _patch_fastapi_cli_log_config():
-    try:
-        import fastapi_cli.utils.cli as _fcli  # type: ignore
-        import fastapi_cli.cli as _fcli_cli  # type: ignore
-
-        _orig_get_config = _fcli.get_uvicorn_log_config  # to ensure it's there
-        _fcli_cli.get_uvicorn_log_config  # to ensure it's there
-    except (ImportError, AttributeError):
-        return
-
-    def _get_routed_config():
-        orig = _orig_get_config()
-        return _build_uvicorn_log_config(
-            default_fmt={
-                "()": "fastapi_cli.utils.cli.CustomFormatter",
-                "fmt": orig["formatters"]["default"].get(
-                    "fmt", "%(levelprefix)s %(message)s"
-                ),
-                "use_colors": orig["formatters"]["default"].get("use_colors"),
-            },
-            access_fmt={
-                "()": "fastapi_cli.utils.cli.CustomFormatter",
-                "fmt": orig["formatters"]["access"].get(
-                    "fmt",
-                    "%(levelprefix)s %(client_addr)s - '%(request_line)s' %(status_code)s",
-                ),
-            },
-        )
-
-    _fcli.get_uvicorn_log_config = _get_routed_config
-    # we need to patch the local binding as well
-    _fcli_cli.get_uvicorn_log_config = _get_routed_config
-
-
-def _normalize_service_route_prefix(raw_prefix):
-    if not raw_prefix:
-        return ""
-
-    prefix = raw_prefix.strip()
-    if not prefix:
-        return ""
-
-    if not prefix.startswith("/"):
-        prefix = f"/{prefix}"
-
-    return "" if prefix == "/" else prefix.rstrip("/")
-
-
-def _is_service_route_prefix_strip_enabled():
-    raw = os.environ.get("VERCEL_SERVICE_ROUTE_PREFIX_STRIP")
-    if not raw:
-        return False
-    return raw.lower() in ("1", "true")
-
-
-_SERVICE_ROUTE_PREFIX = (
-    _normalize_service_route_prefix(os.environ.get("VERCEL_SERVICE_ROUTE_PREFIX"))
-    if _is_service_route_prefix_strip_enabled()
-    else ""
 )
 
-
-def _strip_service_route_prefix(path_value):
-    if not path_value:
-        path_value = "/"
-    elif not path_value.startswith("/"):
-        path_value = f"/{path_value}"
-
-    prefix = _SERVICE_ROUTE_PREFIX
-    if not prefix:
-        return path_value, ""
-
-    if path_value == prefix:
-        return "/", prefix
-
-    if path_value.startswith(f"{prefix}/"):
-        stripped = path_value[len(prefix) :]
-        return stripped if stripped else "/", prefix
-
-    return path_value, ""
-
-
-# Pre-configure the root logger before user module import so that any log
-# calls emitted at import time are routed to stdout/stderr correctly.
-_setup_server_log_routing()
-
-
-# ASGI/WSGI app detection
-_MODULE_NAME = "__VC_DEV_MODULE_NAME__"
-_ENTRY_ABS = "__VC_DEV_ENTRY_ABS__"
-
-# Import user module by file path, matching vc_init.py's approach.
-# https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
-_spec = _importlib_util.spec_from_file_location(_MODULE_NAME, _ENTRY_ABS)
-if _spec is None or _spec.loader is None:
-    raise RuntimeError(
-        f"Could not load module spec for '{_MODULE_NAME}' at {_ENTRY_ABS}"
-    )
-_mod = _importlib_util.module_from_spec(_spec)
-sys.modules[_MODULE_NAME] = _mod
-_spec.loader.exec_module(_mod)
-
-_user_app_name = (
-    "app"
-    if hasattr(_mod, "app")
-    else "application"
-    if hasattr(_mod, "application")
-    else None
-)
-if _user_app_name is None:
-    raise RuntimeError(
-        f"Missing 'app' or 'application' in module '{_MODULE_NAME}'. "
-        f"Define `app = ...` or `application = ...` in your entrypoint."
-    )
-
-_user_app = getattr(_mod, _user_app_name, None)
-
-
-def _get_positional_param_count(obj):
-    try:
-        sig = inspect.signature(obj)
-        return sum(
-            1
-            for p in sig.parameters.values()
-            if p.default is inspect.Parameter.empty
-            and p.kind
-            in (
-                inspect.Parameter.POSITIONAL_ONLY,
-                inspect.Parameter.POSITIONAL_OR_KEYWORD,
-            )
-        )
-    except (ValueError, TypeError):
-        return None
-
-
-def _detect_app_type(app_obj):
-    # try .asgi attribute if it's available and is callable
-    asgi_attr = getattr(app_obj, "asgi", None)
-    if asgi_attr is not None and callable(asgi_attr):
-        return "asgi", asgi_attr
-
-    # For async detection, check the object itself first (works for plain
-    # functions/methods).
-    # For class instances iscoroutinefunction(obj) is False,
-    # so fall back to __call__.
-    is_async = inspect.iscoroutinefunction(app_obj)
-    if not is_async:
-        call_method = getattr(app_obj, "__call__", None)
-        if call_method is not None:
-            is_async = inspect.iscoroutinefunction(call_method)
-
-    # inspect.signature() already delegates to __call__ for class instances,
-    # and works directly on plain functions, so always inspect app_obj.
-    param_count = _get_positional_param_count(app_obj)
-
-    # ASGI (scope, receive, send)
-    if is_async and param_count == 3:
-        return "asgi", app_obj
-
-    # WSGI (environ, start_response)
-    if param_count == 2:
-        return "wsgi", app_obj
-
-    print(
-        _color(
-            f"Could not determine the application interface for '{_MODULE_NAME}:{_user_app_name}'\n"
-            f"Expected either:\n"
-            f"  - An ASGI app: async callable(scope, receive, send)\n"
-            f"  - A WSGI app: callable(environ, start_response)",
-            _RED,
-        ),
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-
-app_type, resolved_app = _detect_app_type(_user_app)
-
-if app_type == "asgi":
-    _asgi_app = resolved_app
-    _wsgi_app = None
-else:
-    _wsgi_app = resolved_app
-    _asgi_app = None
-
-PUBLIC_DIR = "public"
-
-# Prepare ASGI app
-
-# Optional StaticFiles import; tolerate missing deps
-StaticFiles = None
-try:
-    from fastapi.staticfiles import StaticFiles as _SF  # type: ignore
-
-    StaticFiles = _SF
-except Exception:
-    try:
-        from starlette.staticfiles import StaticFiles as _SF  # type: ignore
-
-        StaticFiles = _SF
-    except Exception:
-        StaticFiles = None
-
-# Prepare static files app (if starlette/fastapi installed)
-_static_app = None
-if StaticFiles is not None:
-    try:
-        try:
-            _static_app = StaticFiles(directory=PUBLIC_DIR, check_dir=False)
-        except TypeError:
-            _static_app = StaticFiles(directory=PUBLIC_DIR)
-    except Exception:
-        _static_app = None
-
-
-def _apply_service_route_prefix_to_scope(scope):
-    path_value, matched_prefix = _strip_service_route_prefix(scope.get("path", "/"))
-    if not matched_prefix:
-        return scope
-
-    updated_scope = dict(scope)
-    updated_scope["path"] = path_value
-
-    raw_path = scope.get("raw_path")
-    if isinstance(raw_path, (bytes, bytearray)):
-        try:
-            decoded = bytes(raw_path).decode("utf-8", "surrogateescape")
-            stripped_raw, _ = _strip_service_route_prefix(decoded)
-            updated_scope["raw_path"] = stripped_raw.encode("utf-8", "surrogateescape")
-        except Exception:
-            pass
-
-    existing_root = scope.get("root_path", "") or ""
-    if existing_root and existing_root != "/":
-        existing_root = existing_root.rstrip("/")
-    else:
-        existing_root = ""
-    updated_scope["root_path"] = f"{existing_root}{matched_prefix}"
-    return updated_scope
-
-
-async def asgi_app(scope, receive, send):
-    effective_scope = _apply_service_route_prefix_to_scope(scope)
-
-    if _static_app is not None and effective_scope.get("type") == "http":
-        req_path = effective_scope.get("path", "/") or "/"
-        safe = _p.normpath(req_path).lstrip("/")
-        full = _p.join(PUBLIC_DIR, safe)
-        try:
-            base = _p.realpath(PUBLIC_DIR)
-            target = _p.realpath(full)
-            if (target == base or target.startswith(base + _p.sep)) and _p.isfile(
-                target
-            ):
-                await _static_app(effective_scope, receive, send)
-                return
-        except Exception:
-            pass
-    await _asgi_app(effective_scope, receive, send)
-
-
-# Prepare WSGI
-
-
-def _is_safe_file(base_dir: str, target: str) -> bool:
-    try:
-        base = _p.realpath(base_dir)
-        tgt = _p.realpath(target)
-        return (tgt == base or tgt.startswith(base + os.sep)) and _p.isfile(tgt)
-    except Exception:
-        return False
-
-
-def _static_wsgi_app(environ, start_response):
-    # Only handle GET/HEAD requests for static assets
-    if environ.get("REQUEST_METHOD", "GET") not in ("GET", "HEAD"):
-        return _not_found(start_response)
-
-    req_path = environ.get("PATH_INFO", "/") or "/"
-    safe = _p.normpath(req_path).lstrip("/")
-    full = _p.join(PUBLIC_DIR, safe)
-    if not _is_safe_file(PUBLIC_DIR, full):
-        return _not_found(start_response)
-
-    ctype, _ = mimetypes.guess_type(full)
-    headers = [("Content-Type", ctype or "application/octet-stream")]
-    try:
-        # For HEAD requests, send headers only
-        if environ.get("REQUEST_METHOD") == "HEAD":
-            start_response("200 OK", headers)
-            return []
-        with open(full, "rb") as f:
-            data = f.read()
-        headers.append(("Content-Length", str(len(data))))
-        start_response("200 OK", headers)
-        return [data]
-    except Exception:
-        return _not_found(start_response)
-
-
-def _not_found(start_response):
-    start_response("404 Not Found", [("Content-Type", "text/plain; charset=utf-8")])
-    return [b"Not Found"]
-
-
-def wsgi_app(environ, start_response):
-    path_info, matched_prefix = _strip_service_route_prefix(
-        environ.get("PATH_INFO", "/") or "/"
-    )
-    environ["PATH_INFO"] = path_info
-    if matched_prefix:
-        script_name = environ.get("SCRIPT_NAME", "") or ""
-        if script_name and script_name != "/":
-            script_name = script_name.rstrip("/")
-        else:
-            script_name = ""
-        environ["SCRIPT_NAME"] = f"{script_name}{matched_prefix}"
-
-    # Try static first; if 404 then delegate to user app
-    captured_status = ""
-    captured_headers = tuple()
-    body_chunks = []
-
-    def capture_start_response(status, headers, exc_info=None):
-        nonlocal captured_status, captured_headers
-        captured_status = status
-        captured_headers = tuple(headers)
-
-        # Return a writer that buffers the body
-        def write(chunk: bytes):
-            body_chunks.append(chunk)
-
-        return write
-
-    result = _static_wsgi_app(environ, capture_start_response)
-    # If static handler produced 200, forward its response
-    if captured_status.startswith("200 "):
-        # Send headers and any chunks collected
-        writer = start_response(captured_status, list(captured_headers))
-        for chunk in body_chunks:
-            writer(chunk)
-        return result
-
-    # Otherwise, delegate to user's WSGI app
-    return _wsgi_app(environ, start_response)
-
-
-# Run dev server
+from vercel_runtime.dev import main  # noqa: E402
 
 if __name__ == "__main__":
-    # Development runner
-    #
-    # For WSGI: prefer Werkzeug, but fall back to stdlib wsgiref.
-    # For ASGI: prefer FastAPI CLI (dev command), then uvicorn, then hypercorn.
-    #
-    # The port is provided by the caller via the PORT environment variable.
-
-    host = "127.0.0.1"
-    _raw_port = os.environ.get("PORT")
-    if not _raw_port:
-        print(
-            _color("PORT environment variable is required.", _RED),
-            file=sys.stderr,
-        )
-        sys.exit(1)
-    port = int(_raw_port)
-
-    if app_type == "wsgi":
-        try:
-            from werkzeug.serving import run_simple  # type: ignore
-
-            _setup_server_log_routing("werkzeug")
-            run_simple(host, port, wsgi_app, use_reloader=True, threaded=True)
-        except Exception:
-            print(
-                _color(
-                    "Werkzeug not installed; falling back to wsgiref (no reloader).",
-                    _YELLOW,
-                ),
-                file=sys.stderr,
-            )
-            from wsgiref.simple_server import make_server
-
-            httpd = make_server(host, port, wsgi_app)
-            print(_color(f"Serving on http://{host}:{port}", _GREEN))
-            httpd.serve_forever()
-    else:
-        try:
-            from fastapi_cli.cli import dev as fastapi_dev  # type: ignore
-        except ImportError:
-            fastapi_dev = None
-
-        if fastapi_dev is not None:
-            _patch_fastapi_cli_log_config()
-            fastapi_dev(
-                entrypoint="vc_init_dev:asgi_app", host=host, port=port, reload=True
-            )
-            sys.exit(0)
-
-        try:
-            import uvicorn  # type: ignore
-
-            uvicorn.run(
-                "vc_init_dev:asgi_app",
-                host=host,
-                port=port,
-                use_colors=True,
-                reload=True,
-                log_config=_build_uvicorn_log_config(),
-            )
-        except Exception:
-            try:
-                import asyncio
-                from hypercorn.config import Config  # type: ignore
-                from hypercorn.asyncio import serve  # type: ignore
-
-                config = Config()
-                config.bind = [f"{host}:{port}"]
-                config.use_reloader = True
-                config.logconfig_dict = _build_hypercorn_log_config()
-
-                async def _run():
-                    await serve(asgi_app, config)
-
-                asyncio.run(_run())
-            except Exception:
-                print(
-                    _color(
-                        'No ASGI server found. Please install either "uvicorn" or "hypercorn" (e.g. "pip install uvicorn").',
-                        _RED,
-                    ),
-                    file=sys.stderr,
-                )
-                sys.exit(1)
+    main()