breaking: remove support for edge and node 20 runtimes

.changeset/ten-worms-shine.md

@@ -0,0 +1,5 @@
+---
+'@sveltejs/adapter-vercel': major
+---
+
+breaking: remove support for edge and Node 20 runtimes

documentation/docs/25-build-and-deploy/90-adapter-vercel.md

@@ -42,17 +42,11 @@ export const config = {
 };
 ```
 
-The following options apply to all functions:
+You can set the following options:
 
-- `runtime`: `'edge'`, `'nodejs20.x'` or `'nodejs22.x'`. By default, the adapter will select the `'nodejs<version>.x'` corresponding to the Node version your project is configured to use on the Vercel dashboard
-  > [!NOTE] This option is deprecated and will be removed in a future version, at which point all your functions will use whichever Node version is specified in the project configuration on Vercel
-- `regions`: an array of [edge network regions](https://vercel.com/docs/concepts/edge-network/regions) (defaulting to `["iad1"]` for serverless functions) or `'all'` if `runtime` is `edge` (its default). Note that multiple regions for serverless functions are only supported on Enterprise plans
+- `runtime`: `'nodejs22.x'`, `'nodejs24.x'` or `bun1.x`. By default, the adapter will select the runtime used for the build, which corresponds to the Node version your project is configured to use on the Vercel dashboard unless you [build the app with Bun](https://bun.com/docs/guides/ecosystem/vite)
+- `regions`: an array of [edge network regions](https://vercel.com/docs/concepts/edge-network/regions) (defaulting to `["iad1"]`). Note that multiple regions for serverless functions are only supported on Enterprise plans
 - `split`: if `true`, causes a route to be deployed as an individual function. If `split` is set to `true` at the adapter level, all routes will be deployed as individual functions
-
-Additionally, the following option applies to edge functions:
-- `external`: an array of dependencies that Rolldown should treat as external when bundling functions. This should only be used to exclude optional dependencies that will not run outside Node
-
-And the following option apply to serverless functions:
 - `memory`: the amount of memory available to the function. Defaults to `1024` Mb, and can be decreased to `128` Mb or [increased](https://vercel.com/docs/concepts/limits/overview#serverless-function-memory) in 64Mb increments up to `3008` Mb on Pro or Enterprise accounts
 - `maxDuration`: [maximum execution duration](https://vercel.com/docs/functions/runtimes#max-duration) of the function. Defaults to `10` seconds for Hobby accounts, `15` for Pro and `900` for Enterprise
 - `isr`: configuration Incremental Static Regeneration, described below
@@ -209,12 +203,6 @@ Projects created before a certain date may default to using an older Node versio
 
 ### Accessing the file system
 
-You can't use `fs` in edge functions.
-
-You _can_ use it in serverless functions, but it won't work as expected, since files are not copied from your project into your deployment. Instead, use the [`read`]($app-server#read) function from `$app/server` to access your files. It also works inside routes deployed as edge functions by fetching the file from the deployed public assets location.
+Using `node:fs` directly in serverless functions most likely won't work as you expect, since files are not copied from your project into your deployment. Instead, use the [`read`]($app-server#read) function from `$app/server` to access your files.
 
 Alternatively, you can [prerender](page-options#prerender) the routes in question.
-
-### Deployment protection
-
-If using [`read`]($app-server#read) in an edge function, SvelteKit will `fetch` the file in question from your deployment. If you are using [Deployment Protection](https://vercel.com/docs/deployment-protection), you must also enable [Protection Bypass for Automation](https://vercel.com/docs/deployment-protection/methods-to-bypass-deployment-protection/protection-bypass-automation) so that the request does not result in a [401 Unauthorized](https://http.dog/401) response.

packages/adapter-vercel/index.d.ts

@@ -1,28 +1,25 @@
 import { Adapter } from '@sveltejs/kit';
-import './ambient.js';
-import { RuntimeConfigKey } from './utils.js';
+import { RuntimeKey } from './utils.js';
 
 export default function plugin(config?: Config): Adapter;
 
 export interface ServerlessConfig {
 	/**
-	 * Whether to use [Edge Functions](https://vercel.com/docs/concepts/functions/edge-functions) (`'edge'`) or [Serverless Functions](https://vercel.com/docs/concepts/functions/serverless-functions) (`'nodejs22.x'`, `'nodejs24.x'` etc).
+	 * Which [Serverless Function](https://vercel.com/docs/concepts/functions/serverless-functions) runtime to use (`'nodejs22.x'`, `'nodejs24.x'` etc).
 	 * @default Same as the build environment
 	 */
-	runtime?: Exclude<RuntimeConfigKey, 'edge'>;
+	runtime?: RuntimeKey;
 	/**
-	 * To which regions to deploy the app. A list of regions.
+	 * A list of regions to deploy the app to
 	 * More info: https://vercel.com/docs/concepts/edge-network/regions
 	 */
 	regions?: string[];
 	/**
 	 * Maximum execution duration (in seconds) that will be allowed for the Serverless Function.
-	 * Serverless only.
 	 */
 	maxDuration?: number;
 	/**
 	 * Amount of memory (RAM in MB) that will be allocated to the Serverless Function.
-	 * Serverless only.
 	 */
 	memory?: number;
 	/**
@@ -32,7 +29,6 @@ export interface ServerlessConfig {
 
 	/**
 	 * [Incremental Static Regeneration](https://vercel.com/docs/concepts/incremental-static-regeneration/overview) configuration.
-	 * Serverless only.
 	 */
 	isr?:
 		| {
@@ -75,89 +71,9 @@ type ImagesConfig = {
 	contentDispositionType?: string;
 };
 
-/** @deprecated */
-export interface EdgeConfig {
-	/**
-	 * Whether to use [Edge Functions](https://vercel.com/docs/concepts/functions/edge-functions) (`'edge'`) or [Serverless Functions](https://vercel.com/docs/concepts/functions/serverless-functions) (`'nodejs22.x'`, `'nodejs24.x'` etc).
-	 */
-	runtime?: 'edge';
-	/**
-	 * To which regions to deploy the app. A list of regions or `'all'`.
-	 * More info: https://vercel.com/docs/concepts/edge-network/regions
-	 */
-	regions?: string[] | 'all';
-	/**
-	 * List of packages that should not be bundled into the Edge Function.
-	 * Edge only.
-	 */
-	external?: string[];
-	/**
-	 * If `true`, this route will always be deployed as its own separate function
-	 */
-	split?: boolean;
-}
-
-export type Config = (EdgeConfig | ServerlessConfig) & {
+export type Config = ServerlessConfig & {
 	/**
 	 * https://vercel.com/docs/build-output-api/v3/configuration#images
 	 */
 	images?: ImagesConfig;
 };
-
-// we copy the RequestContext interface from `@vercel/edge` because that package can't co-exist with `@types/node`.
-// see https://github.com/sveltejs/kit/pull/9280#issuecomment-1452110035
-
-/**
- * An extension to the standard `Request` object that is passed to every Edge Function.
- *
- * @deprecated - use [`@vercel/functions`](https://vercel.com/docs/functions/functions-api-reference/vercel-functions-package) instead.
- *
- * @example
- * ```ts
- * import type { RequestContext } from '@vercel/edge';
- *
- * export default async function handler(request: Request, ctx: RequestContext): Promise<Response> {
- *   // ctx is the RequestContext
- * }
- * ```
- */
-export interface RequestContext {
-	/**
-	 * A method that can be used to keep the function running after a response has been sent.
-	 * This is useful when you have an async task that you want to keep running even after the
-	 * response has been sent and the request has ended.
-	 *
-	 * @example
-	 *
-	 * <caption>Sending an internal error to an error tracking service</caption>
-	 *
-	 * ```ts
-	 * import type { RequestContext } from '@vercel/edge';
-	 *
-	 * export async function handleRequest(request: Request, ctx: RequestContext): Promise<Response> {
-	 *  try {
-	 *    return await myFunctionThatReturnsResponse();
-	 *  } catch (e) {
-	 *    ctx.waitUntil((async () => {
-	 *      // report this error to your error tracking service
-	 *      await fetch('https://my-error-tracking-service.com', {
-	 *        method: 'POST',
-	 *        body: JSON.stringify({
-	 *          stack: e.stack,
-	 *          message: e.message,
-	 *          name: e.name,
-	 *          url: request.url,
-	 *        }),
-	 *      });
-	 *    })());
-	 *    return new Response('Internal Server Error', { status: 500 });
-	 *  }
-	 * }
-	 * ```
-	 */
-	waitUntil(
-		/**
-		 * A promise that will be kept alive until it resolves or rejects.
-		 */ promise: Promise<unknown>
-	): void;
-}