@vercel/rust 1.4.1 → 1.5.0

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,10 +30,374 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../internals/ipc-proxy/dist/dev-proxy.js
+var require_dev_proxy = __commonJS({
+  "../../internals/ipc-proxy/dist/dev-proxy.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var dev_proxy_exports = {};
+    __export2(dev_proxy_exports, {
+      createDevProxyServer: () => createDevProxyServer,
+      findFreePort: () => findFreePort,
+      normalizeServiceRoutePrefix: () => normalizeServiceRoutePrefix,
+      resolveServiceRoutePrefix: () => resolveServiceRoutePrefix,
+      rewriteRequestUrl: () => rewriteRequestUrl,
+      sanitizeHeaders: () => sanitizeHeaders,
+      startDevProxy: () => startDevProxy2,
+      stripServiceRoutePrefix: () => stripServiceRoutePrefix,
+      waitForPort: () => waitForPort
+    });
+    module2.exports = __toCommonJS2(dev_proxy_exports);
+    var import_node_http = require("http");
+    var import_node_net = require("net");
+    var PING_PATH = "/_vercel/ping";
+    var INTERNAL_HEADER_PREFIX = "x-vercel-internal-";
+    var LOCALHOST = "127.0.0.1";
+    var DEFAULT_READINESS_TIMEOUT = 5 * 6e4;
+    var READINESS_POLL_INTERVAL = 100;
+    var READINESS_DIAL_TIMEOUT = 1e3;
+    function normalizeServiceRoutePrefix(rawPrefix) {
+      if (!rawPrefix)
+        return "";
+      let prefix = rawPrefix.trim();
+      if (!prefix)
+        return "";
+      if (!prefix.startsWith("/")) {
+        prefix = `/${prefix}`;
+      }
+      if (prefix !== "/") {
+        prefix = prefix.replace(/\/+$/, "");
+        if (!prefix)
+          prefix = "/";
+      }
+      return prefix === "/" ? "" : prefix;
+    }
+    function resolveServiceRoutePrefix(env = process.env) {
+      const strip = (env.VERCEL_SERVICE_ROUTE_PREFIX_STRIP ?? "").trim().toLowerCase();
+      if (strip !== "1" && strip !== "true")
+        return "";
+      return normalizeServiceRoutePrefix(env.VERCEL_SERVICE_ROUTE_PREFIX);
+    }
+    function stripServiceRoutePrefix(pathValue, prefix) {
+      if (pathValue === "*")
+        return pathValue;
+      let normalized = pathValue;
+      if (!normalized) {
+        normalized = "/";
+      } else if (!normalized.startsWith("/")) {
+        normalized = `/${normalized}`;
+      }
+      if (!prefix)
+        return normalized;
+      if (normalized === prefix)
+        return "/";
+      if (normalized.startsWith(`${prefix}/`)) {
+        return normalized.slice(prefix.length) || "/";
+      }
+      return normalized;
+    }
+    function splitUrl(url) {
+      const queryIndex = url.indexOf("?");
+      if (queryIndex === -1)
+        return { pathname: url, search: "" };
+      return { pathname: url.slice(0, queryIndex), search: url.slice(queryIndex) };
+    }
+    function rewriteRequestUrl(url, prefix) {
+      const { pathname, search } = splitUrl(url || "/");
+      return `${stripServiceRoutePrefix(pathname, prefix)}${search}`;
+    }
+    function sanitizeHeaders(headers) {
+      const sanitized = {};
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase().startsWith(INTERNAL_HEADER_PREFIX))
+          continue;
+        sanitized[key] = value;
+      }
+      const forwardedHost = headers["x-forwarded-host"];
+      const host = Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost;
+      if (host) {
+        sanitized.host = host;
+      }
+      return sanitized;
+    }
+    function findFreePort() {
+      return new Promise((resolve, reject) => {
+        const server = (0, import_node_net.createServer)();
+        server.unref();
+        server.once("error", reject);
+        server.listen(0, LOCALHOST, () => {
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            server.close(() => reject(new Error("Failed to allocate a free port")));
+            return;
+          }
+          const { port } = address;
+          server.close(() => resolve(port));
+        });
+      });
+    }
+    function isPortReachable(port) {
+      return new Promise((resolve) => {
+        const socket = (0, import_node_net.createConnection)({ port, host: LOCALHOST });
+        const done = (reachable) => {
+          socket.removeAllListeners();
+          socket.destroy();
+          resolve(reachable);
+        };
+        socket.setTimeout(READINESS_DIAL_TIMEOUT);
+        socket.once("connect", () => done(true));
+        socket.once("timeout", () => done(false));
+        socket.once("error", () => done(false));
+      });
+    }
+    function sleep(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async function waitForPort(port, child, timeout, label = "Dev server") {
+      let exited;
+      let spawnError;
+      const onExit = (code, signal) => {
+        exited = { code, signal };
+      };
+      const onError = (err) => {
+        spawnError = err;
+      };
+      child.once("exit", onExit);
+      child.once("error", onError);
+      try {
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+          if (spawnError)
+            throw spawnError;
+          if (exited) {
+            throw new Error(
+              `${label} exited before it started listening (code: ${exited.code}, signal: ${exited.signal})`
+            );
+          }
+          if (await isPortReachable(port))
+            return;
+          await sleep(READINESS_POLL_INTERVAL);
+        }
+        throw new Error(`${label} did not start listening within ${timeout}ms`);
+      } finally {
+        child.removeListener("exit", onExit);
+        child.removeListener("error", onError);
+      }
+    }
+    function createDevProxyServer(options) {
+      const { targetPort } = options;
+      const routePrefix = normalizeServiceRoutePrefix(options.routePrefix);
+      const server = (0, import_node_http.createServer)((req, res) => {
+        const { pathname } = splitUrl(req.url || "/");
+        if (pathname === PING_PATH) {
+          res.writeHead(200, { "content-type": "text/plain" });
+          res.end("OK");
+          return;
+        }
+        const proxyReq = (0, import_node_http.request)(
+          {
+            host: LOCALHOST,
+            port: targetPort,
+            method: req.method,
+            path: rewriteRequestUrl(req.url || "/", routePrefix),
+            headers: sanitizeHeaders(req.headers)
+          },
+          (proxyRes) => {
+            res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.once("error", (err) => {
+          if (!res.headersSent) {
+            res.writeHead(502, { "content-type": "text/plain" });
+          }
+          res.end(`Dev proxy error: ${err.message}`);
+        });
+        res.once("close", () => {
+          if (!res.writableFinished)
+            proxyReq.destroy();
+        });
+        req.pipe(proxyReq);
+      });
+      server.on("upgrade", (req, clientSocket, head) => {
+        const headers = sanitizeHeaders(req.headers);
+        const path8 = rewriteRequestUrl(req.url || "/", routePrefix);
+        const upstream = (0, import_node_net.createConnection)(
+          { host: LOCALHOST, port: targetPort },
+          () => {
+            const lines = [`${req.method} ${path8} HTTP/${req.httpVersion}`];
+            for (const [key, value] of Object.entries(headers)) {
+              if (Array.isArray(value)) {
+                for (const entry of value)
+                  lines.push(`${key}: ${entry}`);
+              } else if (value !== void 0) {
+                lines.push(`${key}: ${value}`);
+              }
+            }
+            upstream.write(`${lines.join("\r\n")}\r
+\r
+`);
+            if (head?.length)
+              upstream.write(new Uint8Array(head));
+            upstream.pipe(clientSocket);
+            clientSocket.pipe(upstream);
+          }
+        );
+        const destroy = () => {
+          upstream.destroy();
+          clientSocket.destroy();
+        };
+        upstream.once("error", destroy);
+        clientSocket.once("error", destroy);
+      });
+      return server;
+    }
+    async function startDevProxy2(options) {
+      const {
+        spawnServer,
+        env = process.env,
+        readinessTimeout = DEFAULT_READINESS_TIMEOUT,
+        label = "Dev server"
+      } = options;
+      const internalPort = await findFreePort();
+      const child = spawnServer(internalPort);
+      let server;
+      const close = async () => {
+        if (server) {
+          await new Promise((resolve) => {
+            server?.close(() => resolve());
+            server?.closeAllConnections?.();
+          });
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+          child.kill("SIGTERM");
+        }
+      };
+      try {
+        await waitForPort(internalPort, child, readinessTimeout, label);
+        server = createDevProxyServer({
+          targetPort: internalPort,
+          routePrefix: resolveServiceRoutePrefix(env)
+        });
+        const listenPort = options.port ?? await findFreePort();
+        await new Promise((resolve, reject) => {
+          server?.once("error", reject);
+          server?.listen(listenPort, () => resolve());
+        });
+        if (!child.pid) {
+          throw new Error(`${label} started without a PID`);
+        }
+        return { port: listenPort, pid: child.pid, child, close };
+      } catch (err) {
+        await close();
+        throw err;
+      }
+    }
+  }
+});
+
+// ../../internals/ipc-proxy/dist/index.js
+var require_dist = __commonJS({
+  "../../internals/ipc-proxy/dist/index.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      createStandaloneLambda: () => createStandaloneLambda2,
+      getBootstrapDir: () => getBootstrapDir,
+      getProxyBinaryPath: () => getProxyBinaryPath
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_node_path8 = require("path");
+    var import_node_fs4 = require("fs");
+    var import_promises2 = require("fs/promises");
+    var import_build_utils12 = require("@vercel/build-utils");
+    __reExport(src_exports2, require_dev_proxy(), module2.exports);
+    function proxyBinaryName(architecture) {
+      return architecture === "arm64" ? "proxy-linux-arm64" : "proxy-linux-amd64";
+    }
+    function getProxyBinaryPath(architecture) {
+      const binPath = (0, import_node_path8.join)(__dirname, "..", "bin", proxyBinaryName(architecture));
+      if (!(0, import_node_fs4.existsSync)(binPath)) {
+        throw new Error(
+          `IPC proxy binary not found for architecture "${architecture}" at ${binPath}. Ensure @vercel-internals/ipc-proxy has been built and its prebuilt binaries copied alongside the consumer's dist output.`
+        );
+      }
+      return binPath;
+    }
+    function getBootstrapDir() {
+      return (0, import_node_path8.join)(__dirname, "..", "bootstrap");
+    }
+    async function createStandaloneLambda2(options) {
+      const {
+        userServerPath,
+        architecture,
+        lambdaOptions,
+        includedFiles,
+        runtimeLanguage,
+        supportsResponseStreaming = true
+      } = options;
+      const proxyPath = getProxyBinaryPath(architecture);
+      const [proxyData, userServerData] = await Promise.all([
+        (0, import_promises2.readFile)(proxyPath),
+        (0, import_promises2.readFile)(userServerPath)
+      ]);
+      return new import_build_utils12.Lambda({
+        ...lambdaOptions,
+        files: {
+          ...includedFiles,
+          executable: new import_build_utils12.FileBlob({ mode: 493, data: proxyData }),
+          "user-server": new import_build_utils12.FileBlob({ mode: 493, data: userServerData })
+        },
+        handler: "executable",
+        runtime: "executable",
+        supportsResponseStreaming,
+        architecture,
+        runtimeLanguage
+      });
+    }
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  detectEntrypoint: () => detectEntrypoint,
+  detectRustEntrypoint: () => detectRustEntrypoint,
   diagnostics: () => diagnostics,
   prepareCache: () => prepareCache,
   shouldServe: () => shouldServe,
@@ -38,9 +405,9 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_node_path4 = __toESM(require("path"));
-var import_build_utils7 = require("@vercel/build-utils");
-var import_execa4 = __toESM(require("execa"));
+var import_node_path7 = __toESM(require("path"));
+var import_build_utils11 = require("@vercel/build-utils");
+var import_execa5 = __toESM(require("execa"));
 
 // src/lib/rust-toolchain.ts
 var import_build_utils = require("@vercel/build-utils");
@@ -75,6 +442,7 @@ var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"));
 var import_smol_toml = require("smol-toml");
 var import_execa2 = __toESM(require("execa"));
+var import_build_utils2 = require("@vercel/build-utils");
 async function getCargoMetadata(options, filterPlatform) {
   const args = ["metadata", "--format-version", "1"];
   if (filterPlatform)
@@ -105,11 +473,208 @@ async function findCargoBuildConfiguration(workspace) {
   const config = (0, import_smol_toml.parse)(await (0, import_promises.readFile)(configPath, "utf8"));
   return config;
 }
+var VERCEL_RUNTIME_CRATE = "vercel_runtime";
+var CARGO_MANIFEST = "Cargo.toml";
+function normalizeCrateName(name) {
+  return name.trim().toLowerCase().replace(/-/g, "_");
+}
+function declaresVercelRuntime(deps) {
+  if (!deps)
+    return false;
+  for (const [name, spec] of Object.entries(deps)) {
+    if (spec && typeof spec === "object" && spec.optional === true) {
+      continue;
+    }
+    if (normalizeCrateName(name) === VERCEL_RUNTIME_CRATE)
+      return true;
+    if (spec && typeof spec === "object" && typeof spec.package === "string" && normalizeCrateName(spec.package) === VERCEL_RUNTIME_CRATE) {
+      return true;
+    }
+  }
+  return false;
+}
+function tomlDeclaresVercelRuntime(toml) {
+  return declaresVercelRuntime(toml.dependencies);
+}
+async function readCargoToml(manifestPath) {
+  try {
+    return (0, import_smol_toml.parse)(await (0, import_promises.readFile)(manifestPath, "utf8"));
+  } catch (err) {
+    (0, import_build_utils2.debug)(`Failed to parse ${manifestPath}: ${err}`);
+  }
+  return null;
+}
+async function hasVercelRuntimeDependency(workPath, entrypoint) {
+  const root = import_node_path.default.resolve(workPath);
+  const entryPath = import_node_path.default.resolve(workPath, entrypoint);
+  let dir = import_node_path.default.dirname(entryPath);
+  for (; ; ) {
+    const manifestPath = import_node_path.default.join(dir, CARGO_MANIFEST);
+    if ((0, import_node_fs.existsSync)(manifestPath)) {
+      const toml = await readCargoToml(manifestPath);
+      if (toml?.package) {
+        const declaresRuntime = tomlDeclaresVercelRuntime(toml);
+        if (declaresRuntime) {
+          (0, import_build_utils2.debug)(`Found \`${VERCEL_RUNTIME_CRATE}\` in ${manifestPath}`);
+        }
+        return declaresRuntime;
+      }
+    }
+    if (dir === root)
+      break;
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return false;
+}
+function findDefaultPackage(metadata) {
+  const defaultMembers = metadata.workspace_default_members;
+  if (defaultMembers?.length === 1) {
+    const member = metadata.packages.find((p) => p.id === defaultMembers[0]);
+    if (member)
+      return member;
+  }
+  const root = metadata.packages.find((p) => p.id === metadata.resolve?.root);
+  if (root)
+    return root;
+  if (metadata.workspace_root) {
+    const manifestPath = import_node_path.default.join(metadata.workspace_root, "Cargo.toml");
+    const atRoot = metadata.packages.find(
+      (p) => import_node_path.default.resolve(p.manifest_path) === import_node_path.default.resolve(manifestPath)
+    );
+    if (atRoot)
+      return atRoot;
+  }
+  return metadata.packages.length === 1 ? metadata.packages[0] : void 0;
+}
+function collectBinTargets(metadata) {
+  const workspaceIds = new Set(metadata.workspace_members ?? []);
+  const defaultPackage = findDefaultPackage(metadata);
+  const members = metadata.packages.filter(
+    (pkg) => workspaceIds.size === 0 || workspaceIds.has(pkg.id)
+  );
+  return members.flatMap(
+    (pkg) => (pkg.targets ?? []).filter((target) => target.kind.includes("bin")).map((target) => ({
+      name: target.name,
+      packageId: pkg.id,
+      packageName: pkg.name,
+      srcPath: target.src_path,
+      isDefaultPackage: pkg.id === defaultPackage?.id
+    }))
+  );
+}
+function looksLikeBinName(value) {
+  return Boolean(value) && !value.includes("/") && !value.includes("\\") && !value.includes(".");
+}
+function realPath(value) {
+  try {
+    return import_node_fs.realpathSync.native(import_node_path.default.resolve(value));
+  } catch {
+    return import_node_path.default.resolve(value);
+  }
+}
+function describeCandidates(targets) {
+  const packages = new Set(targets.map((target) => target.packageName));
+  return targets.map(
+    (target) => packages.size > 1 ? `${target.packageName}:${target.name}` : target.name
+  ).join(", ");
+}
+function resolveStandaloneBinary(metadata, entrypoint, workPath) {
+  const binTargets = collectBinTargets(metadata);
+  if (binTargets.length === 0) {
+    throw new Error(
+      "No binary target found in this Cargo project. Add a `src/main.rs` or a `[[bin]]` target to your `Cargo.toml`."
+    );
+  }
+  if (entrypoint) {
+    if (!looksLikeBinName(entrypoint)) {
+      const entryPath = import_node_path.default.resolve(workPath, entrypoint);
+      const resolvedEntry = realPath(entryPath);
+      const bySrcPath = binTargets.filter(
+        (target) => realPath(target.srcPath) === resolvedEntry
+      );
+      if (bySrcPath.length === 1)
+        return bySrcPath[0];
+      if (bySrcPath.length > 1) {
+        throw new Error(
+          `The entrypoint \`${entrypoint}\` matches multiple binary targets (${describeCandidates(bySrcPath)}). Give the targets unique source paths.`
+        );
+      }
+      if ((0, import_node_fs.existsSync)(entryPath)) {
+        throw new Error(
+          `The entrypoint \`${entrypoint}\` exists but is not a Cargo binary target. Point it at a binary target declared by this project (${describeCandidates(binTargets)}).`
+        );
+      }
+    } else {
+      const byName = binTargets.filter((target) => target.name === entrypoint);
+      if (byName.length === 1)
+        return byName[0];
+      if (byName.length > 1) {
+        throw new Error(
+          `The binary name \`${entrypoint}\` is ambiguous (${describeCandidates(byName)}). Set the entrypoint to the binary's source path.`
+        );
+      }
+      throw new Error(
+        `No Cargo binary target named \`${entrypoint}\` was found. Available targets: ${describeCandidates(binTargets)}.`
+      );
+    }
+  }
+  const defaultTargets = binTargets.filter((target) => target.isDefaultPackage);
+  const candidates = defaultTargets.length > 0 ? defaultTargets : binTargets;
+  const defaultPackage = findDefaultPackage(metadata);
+  if (defaultPackage?.default_run) {
+    const byDefaultRun = candidates.find(
+      (target) => target.name === defaultPackage.default_run
+    );
+    if (byDefaultRun)
+      return byDefaultRun;
+  }
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  throw new Error(
+    `Unable to determine which binary to deploy. This Cargo project declares multiple binary targets (${describeCandidates(candidates)}). Set the entrypoint to the binary you want to deploy \u2014 either its source path (e.g. \`src/bin/server.rs\`) or its name (e.g. \`server\`) \u2014 or set \`default-run\` in your \`Cargo.toml\`.`
+  );
+}
+function resolvedPackageUsesVercelRuntime(metadata, binary) {
+  const owner = metadata.packages.find(
+    (pkg) => pkg.id === binary.packageId || pkg.name === binary.packageName && pkg.targets.some(
+      (target) => realPath(target.src_path) === realPath(binary.srcPath)
+    )
+  );
+  if (!owner)
+    return false;
+  const node = metadata.resolve.nodes.find(
+    (candidate) => candidate.id === owner.id
+  );
+  if (!node)
+    return false;
+  return node.deps.some((dep) => {
+    const resolved = metadata.packages.find((pkg) => pkg.id === dep.pkg);
+    return resolved !== void 0 && normalizeCrateName(resolved.name) === VERCEL_RUNTIME_CRATE && dep.dep_kinds.some((kind) => kind.kind === null);
+  });
+}
+function assertStandaloneBinary(metadata, binary, workPath) {
+  if (!resolvedPackageUsesVercelRuntime(metadata, binary))
+    return;
+  const srcPath = (0, import_build_utils2.normalizePath)(
+    import_node_path.default.relative(realPath(workPath), realPath(binary.srcPath))
+  );
+  throw new Error(
+    `The package \`${binary.packageName}\` depends on \`${VERCEL_RUNTIME_CRATE}\`, so its binary \`${binary.name}\` cannot be deployed as a standalone server. Set the entrypoint to the binary's source file (\`${srcPath}\`) to keep the \`${VERCEL_RUNTIME_CRATE}\` output.`
+  );
+}
 function findBinaryName(workspace, entryPath) {
   const { bin } = workspace.toml;
   if (bin) {
-    const relativePath = import_node_path.default.relative(import_node_path.default.dirname(workspace.root), entryPath);
-    const entry = bin.find((binEntry) => binEntry.path === relativePath);
+    const relativePath = (0, import_build_utils2.normalizePath)(
+      import_node_path.default.relative(import_node_path.default.dirname(workspace.root), entryPath)
+    );
+    const entry = bin.find(
+      (binEntry) => binEntry.path && (0, import_build_utils2.normalizePath)(binEntry.path) === relativePath
+    );
     if (entry?.name) {
       return entry.name;
     }
@@ -120,7 +685,49 @@ function findBinaryName(workspace, entryPath) {
 // src/lib/utils.ts
 var import_node_fs2 = __toESM(require("fs"));
 var import_node_path2 = __toESM(require("path"));
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
+var CARGO_MANIFEST2 = "Cargo.toml";
+function cargoManifestDirs(files) {
+  return Object.keys(files).filter(
+    (filePath) => filePath === CARGO_MANIFEST2 || filePath.endsWith(`/${CARGO_MANIFEST2}`)
+  ).map((filePath) => filePath.slice(0, -CARGO_MANIFEST2.length));
+}
+function excludeCargoTargetDir(files, env = process.env, workPath) {
+  const rawTargetDir = env.CARGO_TARGET_DIR || "target";
+  const prefixes = [];
+  if (import_node_path2.default.isAbsolute(rawTargetDir)) {
+    if (workPath) {
+      const relative = import_node_path2.default.relative(
+        import_node_path2.default.resolve(workPath),
+        import_node_path2.default.resolve(rawTargetDir)
+      );
+      if (relative && !relative.startsWith("..")) {
+        prefixes.push(`${relative.split(import_node_path2.default.sep).join("/")}/`);
+      }
+    }
+  } else {
+    const targetDir = rawTargetDir.replace(/^\.\//, "").replace(/\/+$/, "");
+    prefixes.push(`${targetDir}/`);
+    for (const dir of cargoManifestDirs(files)) {
+      prefixes.push(`${dir}${targetDir}/`);
+    }
+  }
+  const filtered = {};
+  let excluded = 0;
+  for (const [filePath, file] of Object.entries(files)) {
+    if (prefixes.some((prefix) => filePath.startsWith(prefix))) {
+      excluded++;
+      continue;
+    }
+    filtered[filePath] = file;
+  }
+  if (excluded > 0) {
+    (0, import_build_utils3.debug)(
+      `Excluded ${excluded} file(s) under \`${rawTargetDir}\` from the build`
+    );
+  }
+  return filtered;
+}
 function getExecutableName(binName) {
   return process.platform === "win32" ? `${binName}.exe` : binName;
 }
@@ -134,54 +741,121 @@ async function runUserScripts(dir) {
   const buildScriptPath = import_node_path2.default.join(dir, "build.sh");
   const buildScriptExists = import_node_fs2.default.existsSync(buildScriptPath);
   if (buildScriptExists) {
-    (0, import_build_utils2.debug)("Running `build.sh`");
-    await (0, import_build_utils2.runShellScript)(buildScriptPath);
+    (0, import_build_utils3.debug)("Running `build.sh`");
+    await (0, import_build_utils3.runShellScript)(buildScriptPath);
   }
 }
 async function gatherExtraFiles(globMatcher, workPath) {
   if (!globMatcher)
     return {};
-  (0, import_build_utils2.debug)(
+  (0, import_build_utils3.debug)(
     `Gathering extra files for glob \`${JSON.stringify(
       globMatcher
     )}\` in ${workPath}`
   );
   if (Array.isArray(globMatcher)) {
     const allMatches = await Promise.all(
-      globMatcher.map((pattern) => (0, import_build_utils2.glob)(pattern, workPath))
+      globMatcher.map((pattern) => (0, import_build_utils3.glob)(pattern, workPath))
     );
     return allMatches.reduce((acc, matches) => ({ ...acc, ...matches }), {});
   }
-  return (0, import_build_utils2.glob)(globMatcher, workPath);
+  return (0, import_build_utils3.glob)(globMatcher, workPath);
+}
+
+// src/lib/compile.ts
+var import_node_path3 = __toESM(require("path"));
+var import_execa3 = __toESM(require("execa"));
+var import_build_utils4 = require("@vercel/build-utils");
+function createRustEnv() {
+  const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
+  const PATH = assertEnv("PATH");
+  return {
+    PATH: `${import_node_path3.default.join(HOME, ".cargo/bin")}${import_node_path3.default.delimiter}${PATH}`,
+    RUSTFLAGS: [process.env.RUSTFLAGS].filter(Boolean).join(" ")
+  };
+}
+async function compileCargoBinary({
+  workPath,
+  rustEnv,
+  binaryName,
+  packageName,
+  crossCompilation,
+  targetTriple,
+  release,
+  verbose
+}) {
+  const args = crossCompilation ? ["zigbuild", "--target", targetTriple] : ["build"];
+  if (packageName) {
+    args.push("-p", packageName);
+  }
+  args.push("--bin", binaryName);
+  args.push(verbose ? "--verbose" : "--quiet");
+  if (release) {
+    args.push("--release");
+  }
+  (0, import_build_utils4.debug)(`Running \`cargo ${args.join(" ")}\``);
+  try {
+    await (0, import_execa3.default)("cargo", args, { cwd: workPath, env: rustEnv });
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
+    throw err;
+  }
+}
+function resolveCompiledBinaryPath({
+  targetDirectory,
+  crossCompilation,
+  targetTriple,
+  buildTarget = "",
+  variant,
+  binaryName
+}) {
+  let dir = targetDirectory;
+  if (crossCompilation) {
+    dir = import_node_path3.default.join(dir, targetTriple);
+  }
+  dir = import_node_path3.default.join(dir, buildTarget);
+  return import_node_path3.default.join(dir, variant, getExecutableName(binaryName));
+}
+function getTargetTriple(architecture) {
+  return architecture === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu";
+}
+async function getRustHostTargetTriple(rustEnv) {
+  try {
+    const { stdout } = await (0, import_execa3.default)("rustc", ["-vV"], { env: rustEnv });
+    return /^host:\s+(.+)$/m.exec(stdout)?.[1];
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Failed to determine the Rust host target: ${err}`);
+    return void 0;
+  }
 }
 
 // src/lib/start-dev-server.ts
 var import_child_process = require("child_process");
 var import_events = require("events");
 var import_get_port = __toESM(require("get-port"));
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/lib/dev-build.ts
-var import_node_path3 = __toESM(require("path"));
-var import_execa3 = __toESM(require("execa"));
-var import_build_utils3 = require("@vercel/build-utils");
+var import_node_path4 = __toESM(require("path"));
+var import_execa4 = __toESM(require("execa"));
+var import_build_utils5 = require("@vercel/build-utils");
 async function buildExecutableForDev(workPath, entrypoint) {
-  (0, import_build_utils3.debug)(`Building executable for development: ${entrypoint}`);
+  (0, import_build_utils5.debug)(`Building executable for development: ${entrypoint}`);
   const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
   const PATH = assertEnv("PATH");
   const rustEnv = {
-    PATH: `${import_node_path3.default.join(HOME, ".cargo/bin")}${import_node_path3.default.delimiter}${PATH}`,
+    PATH: `${import_node_path4.default.join(HOME, ".cargo/bin")}${import_node_path4.default.delimiter}${PATH}`,
     RUSTFLAGS: [process.env.RUSTFLAGS].filter(Boolean).join(" ")
   };
-  const entryPath = import_node_path3.default.join(workPath, entrypoint);
+  const entryPath = import_node_path4.default.join(workPath, entrypoint);
   const cargoWorkspace = await findCargoWorkspace({
     env: rustEnv,
-    cwd: import_node_path3.default.dirname(entryPath)
+    cwd: import_node_path4.default.dirname(entryPath)
   });
   const binaryName = findBinaryName(cargoWorkspace, entryPath);
-  (0, import_build_utils3.debug)(`Building binary "${binaryName}" in debug mode for dev server`);
+  (0, import_build_utils5.debug)(`Building binary "${binaryName}" in debug mode for dev server`);
   try {
-    await (0, import_execa3.default)(
+    await (0, import_execa4.default)(
       "cargo",
       [
         "build",
@@ -196,24 +870,24 @@ async function buildExecutableForDev(workPath, entrypoint) {
       }
     );
   } catch (err) {
-    (0, import_build_utils3.debug)(`Cargo build failed for ${binaryName}`);
+    (0, import_build_utils5.debug)(`Cargo build failed for ${binaryName}`);
     throw new Error(`Failed to build Rust binary for development: ${err}`);
   }
   const { target_directory: targetDirectory } = await getCargoMetadata({
     cwd: workPath,
     env: rustEnv
   });
-  const executablePath = import_node_path3.default.join(
+  const executablePath = import_node_path4.default.join(
     targetDirectory,
     "debug",
     getExecutableName(binaryName)
   );
-  (0, import_build_utils3.debug)(`Built executable at: ${executablePath}`);
+  (0, import_build_utils5.debug)(`Built executable at: ${executablePath}`);
   return executablePath;
 }
 
 // src/lib/dev-server.ts
-var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 function createDevServerEnv(baseEnv, meta = {}, port) {
   const devEnv = {
     // Base environment
@@ -234,7 +908,7 @@ function createDevServerEnv(baseEnv, meta = {}, port) {
       delete devEnv[key];
     }
   });
-  (0, import_build_utils4.debug)(`Dev server environment: ${Object.keys(devEnv).join(", ")}`);
+  (0, import_build_utils6.debug)(`Dev server environment: ${Object.keys(devEnv).join(", ")}`);
   return devEnv;
 }
 
@@ -253,7 +927,7 @@ function installGlobalCleanupHandlers() {
       try {
         child.kill("SIGTERM");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server on signal: ${err}`);
+        (0, import_build_utils7.debug)(`Error sending SIGTERM to Rust dev server on signal: ${err}`);
       }
     }
   };
@@ -308,18 +982,18 @@ function terminate(child) {
     try {
       child.kill("SIGTERM");
     } catch (err) {
-      (0, import_build_utils5.debug)(`Error sending SIGTERM to Rust dev server: ${err}`);
+      (0, import_build_utils7.debug)(`Error sending SIGTERM to Rust dev server: ${err}`);
       done();
       return;
     }
     timer = setTimeout(() => {
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils7.debug)(
         `Rust dev server did not exit within ${SHUTDOWN_TIMEOUT}ms, sending SIGKILL`
       );
       try {
         child.kill("SIGKILL");
       } catch (err) {
-        (0, import_build_utils5.debug)(`Error sending SIGKILL to Rust dev server: ${err}`);
+        (0, import_build_utils7.debug)(`Error sending SIGKILL to Rust dev server: ${err}`);
       }
     }, SHUTDOWN_TIMEOUT);
     timer.unref?.();
@@ -332,7 +1006,7 @@ var startDevServer = async (opts) => {
     const executablePath = await buildExecutableForDev(workPath, entrypoint);
     const requestedPort = typeof meta.port === "number" ? meta.port : meta.env?.VERCEL_DEV_PORT ? Number(meta.env.VERCEL_DEV_PORT) : void 0;
     const port = typeof requestedPort === "number" && Number.isInteger(requestedPort) ? requestedPort : await (0, import_get_port.default)();
-    (0, import_build_utils5.debug)(`Starting Rust dev server: ${executablePath} (port=${port})`);
+    (0, import_build_utils7.debug)(`Starting Rust dev server: ${executablePath} (port=${port})`);
     const devEnv = createDevServerEnv(process.env, meta, port);
     const child = (0, import_child_process.spawn)(executablePath, [], {
       cwd: workPath,
@@ -343,7 +1017,7 @@ var startDevServer = async (opts) => {
       throw new Error("Failed to start Rust dev server process");
     }
     trackDevServer(child);
-    (0, import_build_utils5.debug)(`Rust dev server process started with PID: ${child.pid}`);
+    (0, import_build_utils7.debug)(`Rust dev server process started with PID: ${child.pid}`);
     let buffer = "";
     let portEmitted = false;
     let stderrTail = "";
@@ -355,7 +1029,7 @@ var startDevServer = async (opts) => {
         if (match) {
           portEmitted = true;
           const reportedPort = parseInt(match[1], 10);
-          (0, import_build_utils5.debug)(`Rust dev server reported ready on port ${reportedPort}`);
+          (0, import_build_utils7.debug)(`Rust dev server reported ready on port ${reportedPort}`);
           child.emit("message", { port: reportedPort }, null);
           buffer = "";
         }
@@ -376,10 +1050,10 @@ var startDevServer = async (opts) => {
       }
     });
     child.on("error", (err) => {
-      (0, import_build_utils5.debug)(`Rust dev server error: ${err}`);
+      (0, import_build_utils7.debug)(`Rust dev server error: ${err}`);
     });
     child.on("exit", (code, signal2) => {
-      (0, import_build_utils5.debug)(`Rust dev server exited with code ${code}, signal ${signal2}`);
+      (0, import_build_utils7.debug)(`Rust dev server exited with code ${code}, signal ${signal2}`);
     });
     const onMessage = (0, import_events.once)(child, "message");
     const onExit = (0, import_events.once)(child, "close");
@@ -395,7 +1069,7 @@ var startDevServer = async (opts) => {
     ]);
     if (result.state === "message") {
       const readyPort = typeof result.value?.port === "number" ? result.value.port : port;
-      (0, import_build_utils5.debug)(`Rust dev server ready on port ${readyPort} (pid ${child.pid})`);
+      (0, import_build_utils7.debug)(`Rust dev server ready on port ${readyPort} (pid ${child.pid})`);
       if (!child.pid) {
         throw new Error("Child process has no PID");
       }
@@ -414,13 +1088,13 @@ var startDevServer = async (opts) => {
         `Rust dev server failed to bind port ${port} ("address already in use"). A previous dev server instance may not have shut down yet. Please retry, or ensure no other process is using that port.`
       );
     }
-    (0, import_build_utils5.debug)(
+    (0, import_build_utils7.debug)(
       `Rust dev server exited before becoming ready (${reason}). Falling back to build-and-invoke mode.` + (stderr ? ` stderr:
 ${stderr}` : "")
     );
     return null;
   } catch (error) {
-    (0, import_build_utils5.debug)(`Failed to start Rust dev server: ${error}`);
+    (0, import_build_utils7.debug)(`Failed to start Rust dev server: ${error}`);
     if (error instanceof RustDevServerError) {
       throw error;
     }
@@ -428,8 +1102,14 @@ ${stderr}` : "")
   }
 };
 
+// src/standalone-server.ts
+var import_node_path5 = __toESM(require("path"));
+var import_node_child_process = require("child_process");
+var import_build_utils9 = require("@vercel/build-utils");
+var import_ipc_proxy = __toESM(require_dist());
+
 // src/diagnostics.ts
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 function parseSource(source) {
   if (!source)
     return { include: false };
@@ -463,6 +1143,8 @@ async function generateProjectManifest({
     const { packages, resolve } = cargoMetadata;
     const pkgById = new Map(packages.map((p) => [p.id, p]));
     const rootId = resolve.root;
+    if (!rootId)
+      return;
     const rootNode = resolve.nodes.find((n) => n.id === rootId);
     if (!rootNode)
       return;
@@ -512,7 +1194,7 @@ async function generateProjectManifest({
         transitiveEntries.push(entry);
     }
     const manifest = {
-      version: import_build_utils6.MANIFEST_VERSION,
+      version: import_build_utils8.MANIFEST_VERSION,
       runtime: "rust",
       ...framework ? { framework } : {},
       ...serviceType ? { serviceType } : {},
@@ -522,11 +1204,332 @@ async function generateProjectManifest({
         ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
       ]
     };
-    await (0, import_build_utils6.writeProjectManifest)(manifest, workPath, "rust");
+    await (0, import_build_utils8.writeProjectManifest)(manifest, workPath, "rust");
   } catch {
   }
 }
-var diagnostics = (0, import_build_utils6.createDiagnostics)("rust");
+var diagnostics = (0, import_build_utils8.createDiagnostics)("rust");
+
+// src/standalone-server.ts
+var STANDALONE_LAMBDA_PATH = "rust";
+function ownsRouteTable(service) {
+  return !(service?.name && service.type);
+}
+function getStandaloneServerRoutes(service) {
+  if (!ownsRouteTable(service)) {
+    return void 0;
+  }
+  return [
+    { handle: "filesystem" },
+    {
+      src: "/(.*)",
+      dest: `/${STANDALONE_LAMBDA_PATH}`,
+      transforms: [
+        {
+          type: "request.path",
+          op: "set",
+          args: "/$1"
+        }
+      ]
+    }
+  ];
+}
+function getVercelRuntimeRoutes(entrypoint, service) {
+  if (isApiHandlerBuild(entrypoint) || !ownsRouteTable(service)) {
+    return void 0;
+  }
+  return [
+    { handle: "filesystem" },
+    { src: "/(.*)", dest: `/${entrypoint.replace(/\.rs$/, "")}` }
+  ];
+}
+function isApiHandlerBuild(entrypoint) {
+  return entrypoint.startsWith("api/");
+}
+var STANDALONE_MODE_CACHE = /* @__PURE__ */ new Map();
+var RESOLVED_STANDALONE_MODE_CACHE = /* @__PURE__ */ new Map();
+var RESOLVED_STANDALONE_MODE_HINTS = /* @__PURE__ */ new Map();
+function useStandaloneMode(workPath, entrypoint) {
+  if (isApiHandlerBuild(entrypoint))
+    return Promise.resolve(false);
+  const key = `${workPath}::${entrypoint}`;
+  const resolved = RESOLVED_STANDALONE_MODE_HINTS.get(key);
+  if (resolved)
+    return resolved;
+  let result = STANDALONE_MODE_CACHE.get(key);
+  if (!result) {
+    result = hasVercelRuntimeDependency(workPath, entrypoint).then(
+      (hasCrate) => !hasCrate
+    );
+    STANDALONE_MODE_CACHE.set(key, result);
+  }
+  return result;
+}
+function resolveStandaloneMode(workPath, entrypoint, rustEnv, filterPlatform) {
+  if (isApiHandlerBuild(entrypoint))
+    return Promise.resolve(false);
+  const modeKey = `${workPath}::${entrypoint}`;
+  const cacheKey = `${modeKey}::${filterPlatform ?? "host"}`;
+  let result = RESOLVED_STANDALONE_MODE_CACHE.get(cacheKey);
+  if (!result) {
+    result = (async () => {
+      const metadata = await getCargoMetadata(
+        { cwd: workPath, env: rustEnv },
+        filterPlatform
+      );
+      const binary = resolveStandaloneBinary(metadata, entrypoint, workPath);
+      return !resolvedPackageUsesVercelRuntime(metadata, binary);
+    })();
+    RESOLVED_STANDALONE_MODE_CACHE.set(cacheKey, result);
+  }
+  RESOLVED_STANDALONE_MODE_HINTS.set(modeKey, result);
+  return result;
+}
+async function buildStandaloneServer(options, { rustEnv, crossCompilation, verbose }) {
+  const { entrypoint, workPath, config, service } = options;
+  (0, import_build_utils9.debug)(`Building standalone Rust server: ${entrypoint}`);
+  const lambdaOptions = await (0, import_build_utils9.getLambdaOptionsFromFunction)({
+    sourceFile: entrypoint,
+    config
+  });
+  const architecture = lambdaOptions?.architecture || "x86_64";
+  const targetTriple = getTargetTriple(architecture);
+  const metadataTarget = options.meta?.isDev ? await getRustHostTargetTriple(rustEnv) : targetTriple;
+  const cargoMetadata = await getCargoMetadata(
+    { cwd: workPath, env: rustEnv },
+    metadataTarget
+  );
+  const binary = resolveStandaloneBinary(cargoMetadata, entrypoint, workPath);
+  assertStandaloneBinary(cargoMetadata, binary, workPath);
+  const cargoWorkspace = await findCargoWorkspace({
+    env: rustEnv,
+    cwd: import_node_path5.default.dirname(binary.srcPath)
+  });
+  const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
+  await runUserScripts(workPath);
+  await compileCargoBinary({
+    workPath,
+    rustEnv,
+    binaryName: binary.name,
+    packageName: binary.packageName,
+    crossCompilation,
+    targetTriple,
+    release: true,
+    verbose
+  });
+  const userServerPath = resolveCompiledBinaryPath({
+    targetDirectory: cargoMetadata.target_directory,
+    crossCompilation,
+    targetTriple,
+    buildTarget: cargoBuildConfiguration?.build.target,
+    variant: "release",
+    binaryName: binary.name
+  });
+  (0, import_build_utils9.debug)(`Compiled standalone Rust server at ${userServerPath}`);
+  const includedFiles = await gatherExtraFiles(config.includeFiles, workPath);
+  const lambda = await (0, import_ipc_proxy.createStandaloneLambda)({
+    userServerPath,
+    architecture,
+    lambdaOptions,
+    includedFiles,
+    runtimeLanguage: "rust"
+  });
+  lambda.zipBuffer = await lambda.createZip();
+  await generateProjectManifest({
+    workPath,
+    cargoMetadata,
+    framework: config?.framework ?? void 0,
+    serviceType: service ? (0, import_build_utils9.getReportedServiceType)(service) : void 0
+  });
+  if (!ownsRouteTable(service)) {
+    return { resultVersion: 3, result: { output: lambda } };
+  }
+  return {
+    resultVersion: 2,
+    result: {
+      output: { [STANDALONE_LAMBDA_PATH]: lambda },
+      routes: getStandaloneServerRoutes(service)
+    }
+  };
+}
+var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
+var PENDING_STARTS = /* @__PURE__ */ new Map();
+function snapshotFiles(files) {
+  return new Map(Object.entries(files));
+}
+function filesAreUnchanged(snapshot, files) {
+  const entries = Object.entries(files);
+  return snapshot.size === entries.length && entries.every(([filePath, file]) => snapshot.get(filePath) === file);
+}
+var cleanupHandlersInstalled2 = false;
+function installGlobalCleanupHandlers2() {
+  if (cleanupHandlersInstalled2)
+    return;
+  cleanupHandlersInstalled2 = true;
+  const killAll = () => {
+    for (const [key, server] of PERSISTENT_SERVERS.entries()) {
+      PERSISTENT_SERVERS.delete(key);
+      try {
+        server.handle.child.kill("SIGKILL");
+      } catch (err) {
+        (0, import_build_utils9.debug)(`Error killing standalone Rust dev server: ${err}`);
+      }
+    }
+  };
+  process.on("SIGINT", killAll);
+  process.on("SIGTERM", killAll);
+  process.on("exit", killAll);
+}
+function toDevServerResult(serverKey, handle) {
+  return {
+    port: handle.port,
+    pid: handle.pid,
+    persistent: true,
+    shutdown: async () => {
+      if (PERSISTENT_SERVERS.get(serverKey)?.handle === handle) {
+        PERSISTENT_SERVERS.delete(serverKey);
+      }
+      await handle.close();
+    }
+  };
+}
+async function startStandaloneDevServer(opts) {
+  const { entrypoint, workPath, meta = {} } = opts;
+  const serverKey = `${workPath}::${entrypoint}`;
+  const existing = PERSISTENT_SERVERS.get(serverKey);
+  if (existing && filesAreUnchanged(existing.files, opts.files)) {
+    return toDevServerResult(serverKey, existing.handle);
+  }
+  const pending = PENDING_STARTS.get(serverKey);
+  if (pending) {
+    await pending;
+    return startStandaloneDevServer(opts);
+  }
+  const startPromise = (async () => {
+    if (existing) {
+      PERSISTENT_SERVERS.delete(serverKey);
+      await existing.handle.close();
+    }
+    await installRustToolchain();
+    const rustEnv = createRustEnv();
+    const hostTarget = await getRustHostTargetTriple(rustEnv);
+    const cargoMetadata = await getCargoMetadata(
+      { cwd: workPath, env: rustEnv },
+      hostTarget
+    );
+    const binary = resolveStandaloneBinary(cargoMetadata, entrypoint, workPath);
+    assertStandaloneBinary(cargoMetadata, binary, workPath);
+    const cargoWorkspace = await findCargoWorkspace({
+      env: rustEnv,
+      cwd: import_node_path5.default.dirname(binary.srcPath)
+    });
+    const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
+    await compileCargoBinary({
+      workPath,
+      rustEnv,
+      binaryName: binary.name,
+      packageName: binary.packageName,
+      crossCompilation: false,
+      targetTriple: getTargetTriple("x86_64"),
+      release: false,
+      verbose: Boolean(process.env.VERCEL_BUILDER_DEBUG ?? false)
+    });
+    const executablePath = resolveCompiledBinaryPath({
+      targetDirectory: cargoMetadata.target_directory,
+      crossCompilation: false,
+      targetTriple: getTargetTriple("x86_64"),
+      buildTarget: cargoBuildConfiguration?.build.target,
+      variant: "debug",
+      binaryName: binary.name
+    });
+    const env = (0, import_build_utils9.cloneEnv)(process.env, meta.env);
+    (0, import_build_utils9.debug)(`Starting standalone Rust dev server: ${executablePath}`);
+    const handle = await (0, import_ipc_proxy.startDevProxy)({
+      port: typeof meta.port === "number" ? meta.port : void 0,
+      env,
+      label: "Standalone Rust dev server",
+      spawnServer: (internalPort) => {
+        const child = (0, import_node_child_process.spawn)(executablePath, [], {
+          cwd: workPath,
+          env: (0, import_build_utils9.cloneEnv)(env, { PORT: String(internalPort) }),
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        const forward = (stream, onData, fallback) => {
+          stream?.on("data", (data) => {
+            const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            if (onData) {
+              onData(chunk);
+            } else {
+              fallback.write(
+                new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+              );
+            }
+          });
+        };
+        forward(child.stdout, opts.onStdout, process.stdout);
+        forward(child.stderr, opts.onStderr, process.stderr);
+        return child;
+      }
+    });
+    const server = { handle, files: snapshotFiles(opts.files) };
+    PERSISTENT_SERVERS.set(serverKey, server);
+    handle.child.once("exit", () => {
+      if (PERSISTENT_SERVERS.get(serverKey)?.handle === handle) {
+        PERSISTENT_SERVERS.delete(serverKey);
+      }
+      handle.close().catch((err) => {
+        (0, import_build_utils9.debug)(`Error closing standalone Rust dev proxy: ${err}`);
+      });
+    });
+    installGlobalCleanupHandlers2();
+    return server;
+  })();
+  PENDING_STARTS.set(serverKey, startPromise);
+  try {
+    const server = await startPromise;
+    return toDevServerResult(serverKey, server.handle);
+  } finally {
+    if (PENDING_STARTS.get(serverKey) === startPromise) {
+      PENDING_STARTS.delete(serverKey);
+    }
+  }
+}
+
+// src/entrypoint.ts
+var import_node_path6 = __toESM(require("path"));
+var import_node_fs3 = require("fs");
+var import_build_utils10 = require("@vercel/build-utils");
+async function detectRustEntrypoint(workPath, configuredEntrypoint) {
+  if (configuredEntrypoint?.endsWith(".rs") && (0, import_node_fs3.existsSync)(import_node_path6.default.join(workPath, configuredEntrypoint))) {
+    (0, import_build_utils10.debug)(`Using configured Rust entrypoint: ${configuredEntrypoint}`);
+    return configuredEntrypoint;
+  }
+  try {
+    const metadata = await getCargoMetadata({
+      cwd: workPath,
+      env: createRustEnv()
+    });
+    const binary = resolveStandaloneBinary(
+      metadata,
+      configuredEntrypoint,
+      workPath
+    );
+    const relative = (0, import_build_utils10.normalizePath)(
+      import_node_path6.default.relative(realPath(workPath), realPath(binary.srcPath))
+    );
+    (0, import_build_utils10.debug)(`Detected Rust entrypoint: ${relative} (bin "${binary.name}")`);
+    return relative;
+  } catch (err) {
+    (0, import_build_utils10.debug)(`Failed to detect Rust entrypoint: ${err}`);
+    return null;
+  }
+}
+var detectEntrypoint = async ({ workPath }) => {
+  const file = await detectRustEntrypoint(workPath);
+  if (!file)
+    return null;
+  return { kind: "file", entrypoint: file };
+};
 
 // src/index.ts
 async function buildHandler(options) {
@@ -540,70 +1543,70 @@ async function buildHandler(options) {
     );
   }
   await installRustToolchain();
-  (0, import_build_utils7.debug)("Creating file system");
-  const downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
-  const entryPath = downloadedFiles[entrypoint].fsPath;
-  const HOME = process.platform === "win32" ? assertEnv("USERPROFILE") : assertEnv("HOME");
-  const PATH = assertEnv("PATH");
-  const rustEnv = {
-    PATH: `${import_node_path4.default.join(HOME, ".cargo/bin")}${import_node_path4.default.delimiter}${PATH}`,
-    RUSTFLAGS: [process.env.RUSTFLAGS].filter(Boolean).join(" ")
-  };
+  (0, import_build_utils11.debug)("Creating file system");
+  const downloadedFiles = await (0, import_build_utils11.download)(
+    excludeCargoTargetDir(files, process.env, workPath),
+    workPath,
+    meta
+  );
+  const rustEnv = createRustEnv();
+  const lambdaOptions = await (0, import_build_utils11.getLambdaOptionsFromFunction)({
+    sourceFile: entrypoint,
+    config
+  });
+  const architecture = lambdaOptions?.architecture || "x86_64";
+  const targetTriple = getTargetTriple(architecture);
+  const modeTarget = meta?.isDev ? await getRustHostTargetTriple(rustEnv) : targetTriple;
+  if (await resolveStandaloneMode(workPath, entrypoint, rustEnv, modeTarget)) {
+    return buildStandaloneServer(options, {
+      rustEnv,
+      crossCompilation: crossCompilationEnabled,
+      verbose: BUILDER_DEBUG
+    });
+  }
+  const downloadedEntry = downloadedFiles[entrypoint];
+  if (!downloadedEntry) {
+    throw new Error(
+      `Entrypoint "${entrypoint}" was not found. Make sure the file exists, or set the entrypoint to the Rust source file you want to deploy.`
+    );
+  }
+  const entryPath = downloadedEntry.fsPath;
   const cargoWorkspace = await findCargoWorkspace({
     env: rustEnv,
-    cwd: import_node_path4.default.dirname(entryPath)
+    cwd: import_node_path7.default.dirname(entryPath)
   });
   const binaryName = findBinaryName(cargoWorkspace, entryPath);
   const cargoBuildConfiguration = await findCargoBuildConfiguration(cargoWorkspace);
   await runUserScripts(workPath);
   const extraFiles = await gatherExtraFiles(config.includeFiles, workPath);
-  const lambdaOptions = await (0, import_build_utils7.getLambdaOptionsFromFunction)({
-    sourceFile: entrypoint,
-    config
-  });
-  const architecture = lambdaOptions?.architecture || "x86_64";
   const buildVariant = meta?.isDev ? "debug" : "release";
-  const buildTarget = cargoBuildConfiguration?.build.target ?? "";
-  const targetTriple = architecture === "x86_64" ? "x86_64-unknown-linux-gnu" : "aarch64-unknown-linux-gnu";
-  try {
-    const args = crossCompilationEnabled ? ["zigbuild", "--target", targetTriple, "--bin", binaryName].concat(
-      BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
-      ["--release"]
-    ) : ["build", "--bin", binaryName].concat(
-      BUILDER_DEBUG ? ["--verbose"] : ["--quiet"],
-      meta?.isDev ? [] : ["--release"]
-    );
-    (0, import_build_utils7.debug)(
-      `Running \`cargo build\` for \`${binaryName}\` (\`${architecture}\`)`
-    );
-    await (0, import_execa4.default)("cargo", args, {
-      cwd: workPath,
-      env: rustEnv
-    });
-  } catch (err) {
-    (0, import_build_utils7.debug)(`Running \`cargo build\` for \`${binaryName}\` failed`);
-    throw err;
-  }
-  (0, import_build_utils7.debug)(
+  await compileCargoBinary({
+    workPath,
+    rustEnv,
+    binaryName,
+    crossCompilation: crossCompilationEnabled,
+    targetTriple,
+    release: crossCompilationEnabled || !meta?.isDev,
+    verbose: BUILDER_DEBUG
+  });
+  (0, import_build_utils11.debug)(
     `Building \`${binaryName}\` for \`${process.platform}\` (\`${architecture}\`) completed`
   );
   const cargoMetadata = await getCargoMetadata(
     { cwd: workPath, env: rustEnv },
     targetTriple
   );
-  let { target_directory: targetDirectory } = cargoMetadata;
-  if (crossCompilationEnabled) {
-    targetDirectory = import_node_path4.default.join(targetDirectory, targetTriple);
-  }
-  targetDirectory = import_node_path4.default.join(targetDirectory, buildTarget);
-  const bin = import_node_path4.default.join(
-    targetDirectory,
-    buildVariant,
-    getExecutableName(binaryName)
-  );
+  const bin = resolveCompiledBinaryPath({
+    targetDirectory: cargoMetadata.target_directory,
+    crossCompilation: crossCompilationEnabled,
+    targetTriple,
+    buildTarget: cargoBuildConfiguration?.build.target,
+    variant: buildVariant,
+    binaryName
+  });
   const handler = getExecutableName("executable");
-  const executableFile = new import_build_utils7.FileFsRef({ mode: 493, fsPath: bin });
-  const lambda = new import_build_utils7.Lambda({
+  const executableFile = new import_build_utils11.FileFsRef({ mode: 493, fsPath: bin });
+  const lambda = new import_build_utils11.Lambda({
     ...lambdaOptions,
     files: {
       ...extraFiles,
@@ -618,13 +1621,13 @@ async function buildHandler(options) {
   lambda.zipBuffer = await lambda.createZip();
   let resolvedRustVersion;
   try {
-    const { stdout: rustcOut } = await (0, import_execa4.default)("rustc", ["--version"], {
+    const { stdout: rustcOut } = await (0, import_execa5.default)("rustc", ["--version"], {
       env: rustEnv,
       cwd: workPath
     });
     resolvedRustVersion = rustcOut.split(" ")[1];
   } catch {
-    (0, import_build_utils7.debug)("Failed to determine rustc version");
+    (0, import_build_utils11.debug)("Failed to determine rustc version");
   }
   const rootPkg = cargoMetadata.packages.find(
     (p) => p.id === cargoMetadata.resolve.root
@@ -634,23 +1637,27 @@ async function buildHandler(options) {
     workPath,
     cargoMetadata,
     framework: config?.framework ?? void 0,
-    serviceType: service ? (0, import_build_utils7.getReportedServiceType)(service) : void 0,
+    serviceType: service ? (0, import_build_utils11.getReportedServiceType)(service) : void 0,
     runtimeVersion: resolvedRustVersion ? {
       ...requestedRustVersion ? { requested: requestedRustVersion } : {},
       resolved: resolvedRustVersion
     } : void 0
   });
-  (0, import_build_utils7.debug)(`generating function for \`${entrypoint}\``);
+  (0, import_build_utils11.debug)(`generating function for \`${entrypoint}\``);
+  const routes = getVercelRuntimeRoutes(entrypoint, service);
   return {
-    output: lambda
+    resultVersion: 3,
+    result: { output: lambda, ...routes ? { routes } : {} }
   };
 }
 var runtime = {
-  version: 3,
+  // Standalone builds need a named V2 output and their own route table. The
+  // classic `vercel_runtime` path stays V3 so preset routing remains intact.
+  version: -1,
   build: buildHandler,
   prepareCache: async ({ workPath }) => {
-    (0, import_build_utils7.debug)(`Caching \`${workPath}\``);
-    const cacheFiles = await (0, import_build_utils7.glob)("target/**", workPath);
+    (0, import_build_utils11.debug)(`Caching \`${workPath}\``);
+    const cacheFiles = await (0, import_build_utils11.glob)("target/**", workPath);
     for (const f of Object.keys(cacheFiles)) {
       const accept = /(?:^|\/)target\/release\/\.fingerprint\//.test(f) || /(?:^|\/)target\/release\/build\//.test(f) || /(?:^|\/)target\/release\/deps\//.test(f) || /(?:^|\/)target\/debug\/\.fingerprint\//.test(f) || /(?:^|\/)target\/debug\/build\//.test(f) || /(?:^|\/)target\/debug\/deps\//.test(f);
       if (!accept) {
@@ -659,21 +1666,35 @@ var runtime = {
     }
     return cacheFiles;
   },
-  startDevServer,
+  startDevServer: async (options) => {
+    const { workPath, entrypoint } = options;
+    await installRustToolchain();
+    const rustEnv = createRustEnv();
+    const hostTarget = await getRustHostTargetTriple(rustEnv);
+    if (await resolveStandaloneMode(workPath, entrypoint, rustEnv, hostTarget)) {
+      return startStandaloneDevServer(options);
+    }
+    return startDevServer(options);
+  },
   shouldServe: async (options) => {
-    (0, import_build_utils7.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
+    (0, import_build_utils11.debug)(`Requested ${options.requestPath} for ${options.entrypoint}`);
+    if (await useStandaloneMode(options.workPath, options.entrypoint)) {
+      return true;
+    }
     const entrypointWithoutExt = options.entrypoint.replace(/\.rs$/, "");
     const matches = options.requestPath === options.entrypoint || options.requestPath === entrypointWithoutExt;
-    (0, import_build_utils7.debug)(
+    (0, import_build_utils11.debug)(
       `shouldServe: ${matches} (entrypointWithoutExt: ${entrypointWithoutExt})`
     );
-    return Promise.resolve(matches);
+    return matches;
   }
 };
 var { version, build, prepareCache, startDevServer: startDevServer2, shouldServe } = runtime;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  detectEntrypoint,
+  detectRustEntrypoint,
   diagnostics,
   prepareCache,
   shouldServe,