blume 1.7.3 → 2.0.1

package/src/deploy/adapter-output.ts

@@ -5,111 +5,56 @@ import { dirname, join } from "pathe";
 
 import type { ResolvedConfig } from "../core/schema.ts";
 import type { ProjectContext } from "../core/types.ts";
-
-type Adapter = NonNullable<ResolvedConfig["deployment"]["adapter"]>;
-
-/** An optional per-adapter path, keyed by the closed adapter union. */
-type AdapterPathMap = { [A in Adapter]?: string };
-
-/**
- * Top-level directory each server adapter writes its deploy bundle into, for
- * `.gitignore` — the bundle is a build artifact, and the platform's own state
- * lives alongside it (`.vercel/project.json`, `.netlify/state.json`), so the
- * whole directory is ignored. `node` and `cloudflare` emit into `dist/`, which
- * `blume init` already ignores.
- */
-export const ADAPTER_IGNORE_DIRS: AdapterPathMap = {
-  netlify: ".netlify/",
-  vercel: ".vercel/",
-};
+import type { ResolvedDeployment } from "./adapters/registry.ts";
+import { deployPlatform } from "./platforms/index.ts";
+import { distDir } from "./platforms/paths.ts";
 
 /**
- * Server adapters whose deploy bundle lands *outside* Astro's `outDir`, at a
- * path relative to the Astro project root. Blume points the Astro root at the
- * hidden `<root>/.blume` runtime, so these adapters write their bundle to
- * `<root>/.blume/<path>` — where the deploy platform never looks. Each value is
- * the sub-path to surface up to the real project root.
- *
- * `netlify` writes a Frameworks API tree at `.netlify/v1` (its `.netlify/build`
- * sibling is only the intermediate SSR bundle, already traced into
- * `v1/functions`); only `v1` is moved, so the `.netlify/state.json` written by
- * `netlify link` survives too. `node` and `cloudflare` emit into `dist/`
- * (already at the project root), so they are absent here and need no
- * relocation.
- *
- * `vercel` is absent for a different reason: it is shown the real project root
- * up front (see `withAdapterRoot`), because its `@vercel/nft` dependency trace
- * is rooted there too and tracing from `.blume` silently drops the function's
- * chunks and `node_modules`. Given the right root it writes its Build Output
- * tree straight to `<root>/.vercel/output`, so there is nothing left to move.
+ * Where a build's output lands. Every static build and most server builds
+ * write to Astro's `outDir`; the Vercel adapter writes its Build Output tree
+ * beside it instead. Each platform declares its own (see `deploy/platforms`).
  */
-export const ADAPTER_OUTPUT_PATHS: AdapterPathMap = {
-  netlify: ".netlify/v1",
+export const deployOutputDir = (
+  config: ResolvedConfig,
+  context: ProjectContext
+): string => {
+  const { deployment } = config;
+  return deployment.options.output === "server"
+    ? deployPlatform(deployment).serverOutputDir(context)
+    : distDir(context);
 };
 
-/**
- * Whether this build keeps Astro's `dist/client` + `dist/server` split and
- * serves only the `client/` half. True for Node and Cloudflare server builds:
- * the Node standalone server's static handler reads only `build.client`, and
- * `@astrojs/cloudflare` declares `preserveBuildClientDir: true` and points the
- * ASSETS binding in the `dist/server/wrangler.json` it generates at
- * `../client` — the Worker serves that directory and nothing above it. A
- * Cloudflare *static* build has no server dir to split against, so its
- * `outDir` root is what ships.
- */
-export const servesClientSubdir = (
-  deployment: ResolvedConfig["deployment"]
-): boolean =>
-  deployment.output === "server" &&
-  (deployment.adapter === "node" || deployment.adapter === "cloudflare");
-
-/**
- * Whether the platform applies a `_headers` file to the static assets it
- * serves. True for every static build (Netlify and Cloudflare Pages/Workers
- * both read it) and, additionally, for a **Cloudflare server** build: the
- * Worker serves `dist/client` through its ASSETS binding, and Workers static
- * assets honor `_headers` from that directory exactly as Pages does.
- *
- * Deliberately not true for a Node server build. Node's standalone server has
- * its own static handler with no `_headers` support, so writing the file there
- * would be inert — and reporting a header that is not applied is worse than
- * omitting it.
- *
- * A Vercel **server** build is excluded because its headers arrive through the
- * routing config instead (see `deploy/vercel-negotiation.ts`), which
- * `_headers` would duplicate rather than complement. A *static* build on the
- * Vercel adapter still returns true: Vercel ignores the file, so it is inert
- * there, matching what the old `output === "static"` gate emitted.
- */
-export const readsHeaderFiles = (
-  deployment: ResolvedConfig["deployment"]
-): boolean =>
-  deployment.output === "static" ||
-  (deployment.output === "server" && deployment.adapter === "cloudflare");
-
 /**
  * Directory whose contents the deploy platform serves as static files. Build
  * artifacts (robots.txt, sitemap.xml, llms.txt, …) must be written here to be
- * served. For a Vercel server build that is the adapter's
- * `.vercel/output/static`; for a Node or Cloudflare server build it is Astro's
- * `build.client` dir (`dist/client/` — see {@link servesClientSubdir}). Every
- * other build serves `dist/` itself, Netlify included.
+ * served. A static build serves `dist/` wherever it lands; a server build
+ * serves what its platform declares — the Build Output tree's `static/` half
+ * on Vercel, Astro's `build.client` dir (`dist/client/`) on Node and
+ * Cloudflare, `dist/` on Netlify.
  */
 export const deployStaticDir = (
   config: ResolvedConfig,
   context: ProjectContext
 ): string => {
-  const { adapter, output } = config.deployment;
-  if (output === "server" && adapter === "vercel") {
-    return join(context.root, ".vercel", "output", "static");
-  }
-  const dist = context.distDir ?? join(context.root, "dist");
-  if (servesClientSubdir(config.deployment)) {
-    return join(dist, "client");
-  }
-  return dist;
+  const { deployment } = config;
+  return deployment.options.output === "server"
+    ? deployPlatform(deployment).serverStaticDir(context)
+    : distDir(context);
 };
 
+/**
+ * Whether the platform applies a `_headers` file to the static assets it
+ * serves — true where Netlify or Cloudflare read one, including a Cloudflare
+ * **server** build (the Worker serves `dist/client` through its ASSETS
+ * binding, which honors `_headers` exactly as Pages does), and for a static
+ * build with no named host. Deliberately false where the file would be inert:
+ * Node's standalone server has its own static handler with no `_headers`
+ * support, and Vercel's headers arrive through the routing config instead.
+ * Reporting a header that is not applied is worse than omitting it.
+ */
+export const readsHeaderFiles = (deployment: ResolvedDeployment): boolean =>
+  deployPlatform(deployment).readsHeaderFiles[deployment.options.output];
+
 /** Outcome of {@link surfaceAdapterOutput}, for logging. */
 export type SurfaceResult =
   | { moved: false }
@@ -117,19 +62,20 @@ export type SurfaceResult =
 
 /**
  * Move a server adapter's deploy bundle out of the hidden `.blume` runtime and
- * up to the project root, where the deploy platform (and `vercel deploy
- * --prebuilt`) expects it. A no-op for static builds, for adapters that emit
- * into `dist/`, and when the expected output is absent.
+ * up to the project root, where the deploy platform expects it. A no-op for
+ * static builds, for platforms whose bundle already lands where they look
+ * (`hiddenRuntime.surfacePath` is null), and when the expected output is
+ * absent.
  */
 export const surfaceAdapterOutput = async (
   config: ResolvedConfig,
   context: ProjectContext
 ): Promise<SurfaceResult> => {
-  const { adapter, output } = config.deployment;
-  if (output !== "server" || !adapter) {
+  const { deployment } = config;
+  if (deployment.options.output !== "server") {
     return { moved: false };
   }
-  const rel = ADAPTER_OUTPUT_PATHS[adapter];
+  const rel = deployPlatform(deployment).hiddenRuntime.surfacePath;
   if (!rel) {
     return { moved: false };
   }
@@ -150,7 +96,21 @@ export const surfaceAdapterOutput = async (
   // ERR_MODULE_NOT_FOUND. Verbatim, the links stay relative and internal to the
   // bundle, surviving both this move and the platform's own (Vercel mounts the
   // bundle at `/var/task`).
-  await cp(from, to, { recursive: true, verbatimSymlinks: true });
+  try {
+    await cp(from, to, { recursive: true, verbatimSymlinks: true });
+  } catch (error) {
+    // SAFETY: a rejected `cp` always yields a Node system error, whose `code`
+    // is the only field read here.
+    if ((error as NodeJS.ErrnoException).code !== "EPERM") {
+      throw error;
+    }
+    // `EPERM` is Windows refusing to create a symlink without Developer Mode
+    // or admin rights (the same answer `symlinkDir` handles for the deps
+    // link). Copy through the links instead: each becomes an ordinary
+    // directory holding its target's files — bigger, but self-contained.
+    await rm(to, { force: true, recursive: true });
+    await cp(from, to, { dereference: true, recursive: true });
+  }
   await rm(from, { force: true, recursive: true });
   return { from, moved: true, to };
 };

package/src/deploy/adapters/cloudflare.ts

@@ -0,0 +1,39 @@
+import { adapterDescriptorSchema } from "../../core/adapter.ts";
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
+
+/** The Astro adapter package a Cloudflare server build imports. */
+export const CLOUDFLARE_ADAPTER_PACKAGE = "@astrojs/cloudflare";
+
+/**
+ * Options for {@link cloudflare}: `output`, `site`, and `base`, plus any
+ * option of `@astrojs/cloudflare` forwarded verbatim (`platformProxy`,
+ * `routes`, `cloudflareModules`, …). Blume sets `prerenderEnvironment`,
+ * `imageService`, and `configPath` itself; an option you pass wins.
+ */
+export type CloudflareOptions = DeployOptions;
+
+export type CloudflareAdapter = DeployAdapter<"cloudflare">;
+
+export const cloudflareOptionsSchema = deployOptionsSchema;
+
+export const cloudflareAdapterSchema = adapterDescriptorSchema(
+  "cloudflare",
+  cloudflareOptionsSchema
+);
+
+/**
+ * Cloudflare Workers and Pages. A server build emits a Worker into
+ * `dist/server` (with a generated wrapper that answers `Accept:
+ * text/markdown`) and serves `dist/client` through the ASSETS binding.
+ * `@astrojs/cloudflare` is an optional peer: install it in the project
+ * (`npm install @astrojs/cloudflare`).
+ */
+export const cloudflare = (
+  options: CloudflareOptions = {}
+): CloudflareAdapter => ({
+  kind: "cloudflare",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: serverRuntimeDeps(options, CLOUDFLARE_ADAPTER_PACKAGE),
+});

package/src/deploy/adapters/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Deployment adapters for `blume.config.ts`:
+ *
+ * ```ts
+ * import { defineConfig } from "blume";
+ * import { vercel } from "blume/deploy";
+ *
+ * export default defineConfig({
+ *   deployment: vercel({ site: "https://docs.example.com" }),
+ * });
+ * ```
+ *
+ * Naming a host switches the build to server output on that host; leave
+ * `deployment` unset (or `{ site, base }`) for a static build anywhere. Each
+ * factory returns a plain descriptor (see `core/adapter.ts`) that the schema
+ * validates; the generated `astro.config.mjs` imports the real `@astrojs/*`
+ * adapter and passes the options through verbatim.
+ */
+export type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+export { cloudflare } from "./cloudflare.ts";
+export type { CloudflareAdapter, CloudflareOptions } from "./cloudflare.ts";
+export { netlify } from "./netlify.ts";
+export type { NetlifyAdapter, NetlifyOptions } from "./netlify.ts";
+export { node } from "./node.ts";
+export type { NodeAdapter, NodeOptions } from "./node.ts";
+export type {
+  AnyDeployAdapter,
+  DeployAdapterKind,
+  DeploymentInput,
+  ResolvedDeployment,
+  ResolvedDeployOptions,
+} from "./registry.ts";
+export type {
+  DeployAdapter,
+  DeployNamedOptions,
+  DeployOptions,
+  DeployOutput,
+  StaticDeployment,
+} from "./types.ts";
+export { vercel } from "./vercel.ts";
+export type { VercelAdapter, VercelOptions } from "./vercel.ts";

package/src/deploy/adapters/netlify.ts

@@ -0,0 +1,34 @@
+import { adapterDescriptorSchema } from "../../core/adapter.ts";
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
+
+/** The Astro adapter package a Netlify server build imports. */
+export const NETLIFY_ADAPTER_PACKAGE = "@astrojs/netlify";
+
+/**
+ * Options for {@link netlify}: `output`, `site`, and `base`, plus any option
+ * of `@astrojs/netlify` forwarded verbatim (`edgeMiddleware`, `imageCDN`,
+ * `cacheOnDemandPages`, …).
+ */
+export type NetlifyOptions = DeployOptions;
+
+export type NetlifyAdapter = DeployAdapter<"netlify">;
+
+export const netlifyOptionsSchema = deployOptionsSchema;
+
+export const netlifyAdapterSchema = adapterDescriptorSchema(
+  "netlify",
+  netlifyOptionsSchema
+);
+
+/**
+ * Netlify. A server build runs on Netlify Functions from the Frameworks API
+ * tree the adapter writes to `.netlify/v1`. `@astrojs/netlify` is an optional
+ * peer: install it in the project (`npm install @astrojs/netlify`).
+ */
+export const netlify = (options: NetlifyOptions = {}): NetlifyAdapter => ({
+  kind: "netlify",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: serverRuntimeDeps(options, NETLIFY_ADAPTER_PACKAGE),
+});

package/src/deploy/adapters/node.ts

@@ -0,0 +1,34 @@
+import { adapterDescriptorSchema } from "../../core/adapter.ts";
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
+
+/** The Astro adapter package a Node server build imports. */
+export const NODE_ADAPTER_PACKAGE = "@astrojs/node";
+
+/**
+ * Options for {@link node}: `output`, `site`, and `base`, plus any option of
+ * `@astrojs/node` forwarded verbatim (`mode`, `host`, `port`, …). Blume
+ * defaults `mode` to `"standalone"`; an option you pass wins.
+ */
+export type NodeOptions = DeployOptions;
+
+export type NodeAdapter = DeployAdapter<"node">;
+
+export const nodeOptionsSchema = deployOptionsSchema;
+
+export const nodeAdapterSchema = adapterDescriptorSchema(
+  "node",
+  nodeOptionsSchema
+);
+
+/**
+ * A self-hosted Node server (containers, VMs). The standalone server in
+ * `dist/server/entry.mjs` serves `dist/client` itself. `@astrojs/node` is one
+ * of Blume's own dependencies.
+ */
+export const node = (options: NodeOptions = {}): NodeAdapter => ({
+  kind: "node",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: serverRuntimeDeps(options, NODE_ADAPTER_PACKAGE),
+});

package/src/deploy/adapters/registry.ts

@@ -0,0 +1,127 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+import { cloudflare, cloudflareAdapterSchema } from "./cloudflare.ts";
+import type { CloudflareAdapter } from "./cloudflare.ts";
+import { netlify, netlifyAdapterSchema } from "./netlify.ts";
+import type { NetlifyAdapter } from "./netlify.ts";
+import { node, nodeAdapterSchema } from "./node.ts";
+import type { NodeAdapter } from "./node.ts";
+import type { DeployOutput, StaticDeployment } from "./types.ts";
+import { vercel, vercelAdapterSchema } from "./vercel.ts";
+import type { VercelAdapter } from "./vercel.ts";
+
+/** Every descriptor a host adapter factory can return. */
+export type AnyDeployAdapter =
+  | CloudflareAdapter
+  | NetlifyAdapter
+  | NodeAdapter
+  | VercelAdapter;
+
+/** Every adapter identity, including the resolved `static` default. */
+export type DeployAdapterKind = "static" | AnyDeployAdapter["kind"];
+
+/**
+ * A resolved deployment's options: `output` is always present (a host adapter
+ * defaults to `server`, the static form is `static`), and anything else the
+ * adapter was given rides along for the `@astrojs/*` constructor.
+ */
+export type ResolvedDeployOptions = {
+  base?: string;
+  output: DeployOutput;
+  site?: string;
+} & { [option: string]: JsonValue };
+
+/**
+ * What `config.deployment` resolves to: the descriptor the factory returned
+ * with `output` filled in, or the `static` descriptor for the plain form.
+ */
+export type ResolvedDeployment = AdapterDescriptor<
+  DeployAdapterKind,
+  ResolvedDeployOptions
+>;
+
+/** What `blume.config.ts` accepts under `deployment`. */
+export type DeploymentInput = AnyDeployAdapter | StaticDeployment;
+
+const HINT =
+  'deployment takes a host adapter from "blume/deploy" — e.g. `deployment: vercel()`, `netlify({ output: "static" })`, `node({ site })` — or `{ site, base }` for a static build on any host. The 1.x `adapter`/`output` fields were removed.';
+
+/**
+ * The static form, `{ site?, base? }`. Its discriminator is optional so the
+ * union resolves a plain object (and `{}`) to it; the 1.x object form fails
+ * here on its unrecognized `adapter`/`output` keys with the adapter hint.
+ */
+const staticDeploymentSchema = z.strictObject(
+  {
+    base: z.string().optional(),
+    kind: z.literal("static").optional(),
+    site: z.url().optional(),
+  },
+  {
+    error: (issue) => (issue.code === "unrecognized_keys" ? HINT : undefined),
+  }
+);
+
+/** The union `deployment` is validated against, before resolution. */
+const deploymentInputSchema = z.discriminatedUnion(
+  "kind",
+  [
+    cloudflareAdapterSchema,
+    netlifyAdapterSchema,
+    nodeAdapterSchema,
+    vercelAdapterSchema,
+    staticDeploymentSchema,
+  ],
+  {
+    error: (issue) =>
+      issue.code === "invalid_union" || issue.code === "invalid_type"
+        ? HINT
+        : undefined,
+  }
+);
+
+/** A host adapter with `output` resolved: unset means a server build. */
+const resolveHost = (adapter: AnyDeployAdapter): ResolvedDeployment => ({
+  ...adapter,
+  options: { ...adapter.options, output: adapter.options.output ?? "server" },
+});
+
+/**
+ * Validates what a factory returned (or the plain static form) and resolves
+ * it to the canonical descriptor, re-derived through the factory so a
+ * descriptor that went through JSON carries the same metadata Blume ships.
+ * `static` is internal: `kind: "static"` is admitted but never needed.
+ */
+export const resolvedDeploymentSchema = deploymentInputSchema.transform(
+  (value): ResolvedDeployment => {
+    switch (value.kind) {
+      case "cloudflare": {
+        return resolveHost(cloudflare(value.options));
+      }
+      case "netlify": {
+        return resolveHost(netlify(value.options));
+      }
+      case "node": {
+        return resolveHost(node(value.options));
+      }
+      case "vercel": {
+        return resolveHost(vercel(value.options));
+      }
+      default: {
+        // The static form (`kind` unset or "static") is resolved after the
+        // switch rather than in this block: Bun 1.4.0's line coverage never
+        // credits the closing brace of a switch's final block.
+        break;
+      }
+    }
+    const options: ResolvedDeployOptions = { output: "static" };
+    if (value.base !== undefined) {
+      options.base = value.base;
+    }
+    if (value.site !== undefined) {
+      options.site = value.site;
+    }
+    return { kind: "static", options, requiredSecrets: [], runtimeDeps: [] };
+  }
+);

package/src/deploy/adapters/types.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+import type { AdapterDescriptor, JsonValue } from "../../core/adapter.ts";
+
+/** Build output mode: prerendered HTML only, or a server that can also answer requests. */
+export type DeployOutput = "static" | "server";
+
+/** The options every host adapter maps itself. */
+export interface DeployNamedOptions {
+  /** Base path when the site is served from a subdirectory (`/docs`). */
+  base?: string;
+  /**
+   * Build output mode. Defaults to `server`: naming a host adapter is how a
+   * site opts into server rendering. Pass `"static"` to keep a static build
+   * on that host, with its site detection and platform files.
+   */
+  output?: DeployOutput;
+  /**
+   * Canonical site URL. Needed for absolute links, the sitemap, and OG images;
+   * detected from the platform's env at build time when unset.
+   */
+  site?: string;
+}
+
+/**
+ * Options for a host adapter: the named options plus anything else, forwarded
+ * verbatim to the underlying `@astrojs/*` adapter's constructor. JSON values
+ * only — the descriptor is inlined into the generated `astro.config.mjs`.
+ */
+export type DeployOptions = DeployNamedOptions & {
+  [option: string]: JsonValue;
+};
+
+/**
+ * The descriptor a host adapter factory returns and `blume.config.ts` carries
+ * under `deployment`: the shared {@link AdapterDescriptor} contract, with the
+ * options a host takes. Plain data, never an Astro integration — the generated
+ * config imports the real adapter package itself.
+ */
+export type DeployAdapter<
+  Kind extends string,
+  Options extends DeployOptions = DeployOptions,
+> = AdapterDescriptor<Kind, Options>;
+
+/**
+ * A static build for any host — the form `deployment` takes when no adapter is
+ * named: `{ site, base }`, or nothing at all. `kind` is the resolved
+ * discriminator; leave it unset.
+ */
+export interface StaticDeployment {
+  /** Base path when the site is served from a subdirectory (`/docs`). */
+  base?: string;
+  /** The resolved kind; never needed in a config. */
+  kind?: "static";
+  /**
+   * Canonical site URL. Needed for absolute links, the sitemap, and OG images;
+   * detected from the platform's env at build time when unset.
+   */
+  site?: string;
+}
+
+/** The named options' schema; every host adapter extends it with `z.json()` passthrough. */
+export const deployOptionsSchema = z
+  .object({
+    base: z.string().optional(),
+    output: z.enum(["static", "server"]).optional(),
+    site: z.url().optional(),
+  })
+  .catchall(z.json());
+
+const NAMED_OPTIONS = new Set(["base", "output", "site"]);
+
+/**
+ * The options Blume does not name — what reaches the `@astrojs/*` adapter's
+ * constructor verbatim.
+ */
+export const deployPassthrough = (
+  options: DeployOptions
+): Record<string, JsonValue> =>
+  Object.fromEntries(
+    Object.entries(options).filter(([key]) => !NAMED_OPTIONS.has(key))
+  );
+
+/**
+ * The runtime dependency a host adapter declares: its `@astrojs/*` package,
+ * which the generated `astro.config.mjs` imports for a server build and
+ * nothing imports for a static one. Unset `output` means server.
+ */
+export const serverRuntimeDeps = (
+  options: DeployNamedOptions,
+  adapterPackage: string
+): string[] => (options.output === "static" ? [] : [adapterPackage]);

package/src/deploy/adapters/vercel.ts

@@ -0,0 +1,35 @@
+import { adapterDescriptorSchema } from "../../core/adapter.ts";
+import type { DeployAdapter, DeployOptions } from "./types.ts";
+import { deployOptionsSchema, serverRuntimeDeps } from "./types.ts";
+
+/** The Astro adapter package a Vercel server build imports. */
+export const VERCEL_ADAPTER_PACKAGE = "@astrojs/vercel";
+
+/**
+ * Options for {@link vercel}: `output`, `site`, and `base`, plus any option of
+ * `@astrojs/vercel` forwarded verbatim (`isr`, `maxDuration`, `imageService`,
+ * `webAnalytics`, …).
+ */
+export type VercelOptions = DeployOptions;
+
+export type VercelAdapter = DeployAdapter<"vercel">;
+
+export const vercelOptionsSchema = deployOptionsSchema;
+
+export const vercelAdapterSchema = adapterDescriptorSchema(
+  "vercel",
+  vercelOptionsSchema
+);
+
+/**
+ * Vercel. A server build writes the Build Output tree to `.vercel/output`,
+ * audits the function bundle for imports the platform's dependency trace
+ * dropped, and wires `Accept: text/markdown` negotiation into the routing
+ * config. `@astrojs/vercel` is one of Blume's own dependencies.
+ */
+export const vercel = (options: VercelOptions = {}): VercelAdapter => ({
+  kind: "vercel",
+  options,
+  requiredSecrets: [],
+  runtimeDeps: serverRuntimeDeps(options, VERCEL_ADAPTER_PACKAGE),
+});