@sveltejs/kit 3.0.0-next.12 → 3.0.0-next.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.12",
+  "version": "3.0.0-next.14",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -30,7 +30,7 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@playwright/test": "^1.61.1",
+    "@playwright/test": "~1.61.0",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@types/connect": "^3.4.38",
     "@types/node": "^22.19.19",
@@ -40,7 +40,7 @@
     "svelte": "^5.56.3",
     "svelte-preprocess": "^6.0.5",
     "typescript": "~6.0.3",
-    "valibot": "^1.2.0",
+    "valibot": "^1.4.2",
     "vite": "^8.1.5",
     "vitest": "^4.1.10"
   },
@@ -127,7 +127,7 @@
   },
   "types": "types/index.d.ts",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.17"
   },
   "scripts": {
     "lint": "prettier --config ../../.prettierrc --check .",
@@ -136,15 +136,15 @@
     "format": "prettier --config ../../.prettierrc --write .",
     "test": "pnpm test:unit && pnpm test:integration",
     "test:integration": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test",
-    "test:cross-platform:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:dev",
-    "test:cross-platform:build": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:build",
+    "test:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:dev",
+    "test:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:build",
+    "test:cross-platform:dev": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:dev",
+    "test:cross-platform:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:cross-platform:build",
     "test:server-side-route-resolution:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:server-side-route-resolution:dev",
-    "test:server-side-route-resolution:build": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:server-side-route-resolution:build",
+    "test:server-side-route-resolution:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:server-side-route-resolution:build",
     "test:svelte-async:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:svelte-async:dev",
-    "test:svelte-async:build": "pnpm test:unit && pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:svelte-async:build",
-    "test:unit:dev": "vitest --config kit.vitest.config.js run",
-    "test:unit:prod": "NODE_ENV=production vitest --config kit.vitest.config.js run csp.spec.js cookie.spec.js",
-    "test:unit": "pnpm test:unit:dev && pnpm test:unit:prod",
+    "test:svelte-async:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:svelte-async:build",
+    "test:unit": "vitest run ./",
     "generate:version": "node scripts/generate-version.js",
     "generate:types": "node scripts/generate-dts.js"
   }

package/src/cli.js

@@ -75,10 +75,10 @@ if (!command) {
 }
 
 if (command === 'sync') {
-	// create placeholder node_modules/$app/tsconfig/tsconfig.json if necessary, to squelch warnings.
+	// create placeholder node_modules/$app/tsconfig.json if necessary, to squelch warnings.
 	// this isn't bulletproof — if someone has some esoteric config, it will continue
 	// to harmlessly warn — but we handle the 90% case and clean up after ourselves
-	const dir = 'node_modules/$app/tsconfig';
+	const dir = 'node_modules/$app';
 	const base_tsconfig = `${dir}/tsconfig.json`;
 	const base_tsconfig_json = '{}';
 

package/src/core/adapt/builder.js

@@ -109,16 +109,19 @@ export function create_builder({
 
 		async compress(directory) {
 			if (!existsSync(directory)) {
-				return;
+				return [];
 			}
 
-			const files = list_files(directory, (file) => extensions.includes(extname(file))).map(
-				(file) => resolve(directory, file)
-			);
+			const files = list_files(directory, (file) => extensions.includes(extname(file)));
 
 			await Promise.all(
-				files.flatMap((file) => [compress_file(file, 'gz'), compress_file(file, 'br')])
+				files.flatMap((file) => {
+					const abs = resolve(directory, file);
+					return [compress_file(abs, 'gz'), compress_file(abs, 'br')];
+				})
 			);
+
+			return files;
 		},
 
 		findServerAssets(route_data) {

package/src/core/generate_manifest/index.js

@@ -94,6 +94,12 @@ export function generate_manifest({
 		mime_types[ext] ??= mime_lookup(ext) || '';
 	}
 
+	// record extensions that only exist in prerendered output, e.g. a prerendered favicon.ico
+	for (const pathname of prerendered) {
+		const ext = path.extname(pathname);
+		if (ext) mime_types[ext] ??= mime_lookup(ext) || '';
+	}
+
 	// prettier-ignore
 	// String representation of
 	/** @template {import('@sveltejs/kit').SSRManifest} T */

package/src/core/postbuild/entities.js

@@ -2236,7 +2236,7 @@ const entities = {
 	'zwnj;': '‌'
 };
 
-const numeric = /&#(x)?([0-9a-f]+);/i;
+const numeric = /&#(x)?([0-9a-f]+);/gi;
 const named = new RegExp(
 	`&(${Object.keys(entities)
 		.sort((a, b) => b.length - a.length)
@@ -2247,6 +2247,12 @@ const named = new RegExp(
 /** @param {string} str */
 export function decode(str) {
 	return str
-		.replace(numeric, (_match, hex, code) => String.fromCharCode(hex ? parseInt(code, 16) : +code))
+		.replace(numeric, (_match, hex, code) => {
+			const codepoint = hex ? parseInt(code, 16) : +code;
+			// mirror the HTML parser, which replaces invalid numeric references with U+FFFD
+			return Number.isInteger(codepoint) && codepoint <= 0x10ffff
+				? String.fromCodePoint(codepoint)
+				: '\ufffd';
+		})
 		.replace(named, (_match, entity) => entities[entity]);
 }

package/src/core/postbuild/fallback.js

@@ -39,7 +39,8 @@ async function generate_fallback({ manifest_path, env, out_dir, origin, assets }
 		prerendering: {
 			fallback: true,
 			dependencies: new Map(),
-			remote_responses: new Map()
+			remote_responses: new Map(),
+			resolved_route_ids: new Set()
 		},
 		read: (file) => readFileSync(join(assets, file))
 	});

package/src/core/postbuild/prerender.js

@@ -17,6 +17,7 @@ import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
 import { log_response } from '../../exports/vite/utils.js';
+import { matches_content_type } from '../../utils/http.js';
 
 export default forked(import.meta.url, prerender);
 
@@ -262,10 +263,13 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	/** @type {Map<string, Promise<any>>} */
 	const remote_responses = new Map();
 
+	/** @type {Set<string>} */
+	const resolved_route_ids = new Set();
+
 	/** @type {Map<string, Set<string>>} */
 	const expected_hashlinks = new Map();
 
-	/** @type {Map<string, string[]>} */
+	/** @type {Map<string, Set<string>>} */
 	const actual_hashlinks = new Map();
 
 	/**
@@ -307,7 +311,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 			},
 			prerendering: {
 				dependencies,
-				remote_responses
+				remote_responses,
+				resolved_route_ids
 			},
 			read: (file) => {
 				// stuff we just wrote
@@ -387,14 +392,18 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		// if it's a 200 HTML response, crawl it. Skip error responses, as we don't save those
-		if (response.ok && config.prerender.crawl && headers['content-type'] === 'text/html') {
+		if (
+			response.ok &&
+			config.prerender.crawl &&
+			matches_content_type(headers['content-type'], 'text/html')
+		) {
 			const { ids, hrefs, invalid } = crawl(body.toString(), decoded);
 
 			for (const href of invalid) {
 				handle_invalid_url({ href, referrer: decoded });
 			}
 
-			actual_hashlinks.set(decoded, ids);
+			actual_hashlinks.set(decoded, new Set(ids));
 
 			/** @param {string} href */
 			const removePrerenderOrigin = (href) => {
@@ -444,7 +453,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		const type = headers['content-type'];
-		const is_html = response_type === REDIRECT || type === 'text/html';
+		const is_html = response_type === REDIRECT || matches_content_type(type, 'text/html');
 
 		if (!is_html && response.status === 200 && decoded.slice(config.paths.base.length + 1) === '') {
 			throw new Error(
@@ -646,7 +655,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		// ignore fragment links to pages that were not prerendered
 		if (!hashlinks) continue;
 
-		if (!hashlinks.includes(id) && !SPECIAL_HASHLINKS.has(id)) {
+		if (!hashlinks.has(id) && !SPECIAL_HASHLINKS.has(id)) {
 			handle_missing_id({ id, path, referrers: Array.from(referrers) });
 		}
 	}

package/src/core/sync/create_manifest_data/conflict.js

@@ -60,7 +60,7 @@ function normalize_route_id(id) {
 			.replace(/(?<=^|\/)\(.+?\)(?=$|\/)/g, '')
 
 			.replace(/\[[ux]\+([0-9a-f]+)\]/g, (_, x) =>
-				String.fromCharCode(parseInt(x, 16)).replace(/\//g, '%2f')
+				String.fromCodePoint(parseInt(x, 16)).replace(/\//g, '%2f')
 			)
 
 			// replace `[param]` with `<*>`, `[param=x]` with `<x>`, and `[[param]]` with `<?*>`

package/src/core/sync/create_manifest_data/index.js

@@ -41,6 +41,34 @@ export default function create_manifest_data({
 	};
 }
 
+/**
+ * Whether this route has a `+page`. Independent of `is_endpoint_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_page_route(route) {
+	return !!route.page;
+}
+
+/**
+ * Whether this route has a `+server`. Independent of `is_page_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_endpoint_route(route) {
+	return !!route.endpoint;
+}
+
+/**
+ * Whether the router can match this route. `manifest_data.routes` also contains entries for
+ * directories with layouts or errors, which never reach `event.route.id`.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_app_route(route) {
+	return is_page_route(route) || is_endpoint_route(route);
+}
+
 /**
  * Returns a list of files in the `static` directory.
  * @param {import('types').ValidatedConfig} config
@@ -85,7 +113,7 @@ function resolve_params(config, cwd) {
  */
 function create_routes_and_nodes(cwd, config, fallback) {
 	/** @type {import('types').RouteData[]} */
-	const routes = [];
+	let routes = [];
 
 	const routes_base = posixify(path.relative(cwd, config.kit.files.routes));
 
@@ -125,7 +153,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 						);
 					}
 
-					return String.fromCharCode(parseInt(code, 16));
+					return String.fromCodePoint(parseInt(code, 16));
 				}
 			});
 
@@ -440,6 +468,9 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 	}
 
+	// remove route objects with no route file
+	routes = routes.filter((route) => route.endpoint || route.leaf || route.layout || route.error);
+
 	// add parents to error nodes so that we can compute which page options apply to them
 	for (const route of routes) {
 		if (!route.error) continue;

package/src/core/sync/write_app_types.js

@@ -4,15 +4,42 @@ import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { write_if_changed } from './utils.js';
 import { s } from '../../utils/misc.js';
-import { get_route_segments } from '../../utils/routing.js';
-
-const replace_optional_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[\[[^\]]+\]\]/g, '${string}');
-const replace_required_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[[^\]]+\]/g, '/${string}');
-/** Convert route ID to pathname by removing layout groups */
-const remove_group_segments = (/** @type {string} */ id) => {
-	return '/' + get_route_segments(id).join('/');
+import {
+	decode_escape_sequence,
+	encode_pathname_chars,
+	get_route_segments,
+	segment_pattern
+} from '../../utils/routing.js';
+import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
+
+const optional_param_pattern = /^\[\[[\w-]+(?:=[\w-]+)?\]\]$/;
+const rest_param_pattern = /^\[\.\.\.[\w-]+(?:=[\w-]+)?\]$/;
+
+/**
+ * Convert a route ID to the pathnames it can match (relative to the base path), in which each
+ * param is replaced with `${string}` and each escape sequence is expanded. A param that fills an
+ * entire segment can be absent, so it contributes a pathname with the segment and one without,
+ * rather than one that absorbs the `/`
+ * @param {string} id
+ */
+const get_pathname_patterns = (id) => {
+	let pathnames = [''];
+
+	for (const segment of get_route_segments(id)) {
+		const omittable = optional_param_pattern.test(segment) || rest_param_pattern.test(segment);
+		const content = omittable
+			? '${string}'
+			: segment.replace(segment_pattern, (_, escape_type, escape_code) =>
+					escape_type ? encode_pathname_chars(decode_escape_sequence(escape_code)) : '${string}'
+				);
+
+		pathnames = pathnames.flatMap((pathname) => {
+			const joined = pathname === '' ? content : `${pathname}/${content}`;
+			return omittable ? [joined, pathname] : [joined];
+		});
+	}
+
+	return [...new Set(pathnames)];
 };
 
 /**
@@ -53,8 +80,6 @@ function get_pathnames_for_trailing_slash(pathname, route) {
 const template = `
 declare module "svelte/elements" {
 	export interface HTMLAttributes<T> {
-		'data-sveltekit-keepfocus'?: true | false | '' | undefined | null;
-		'data-sveltekit-noscroll'?: true | false | '' | undefined | null;
 		'data-sveltekit-preload-code'?:
 			| true
 			| false
@@ -68,6 +93,7 @@ declare module "svelte/elements" {
 		'data-sveltekit-preload-data'?: true | false | '' | 'hover' | 'tap' | undefined | null;
 		'data-sveltekit-reload'?: true | false | '' | undefined | null;
 		'data-sveltekit-replacestate'?: true | false | '' | undefined | null;
+		'data-sveltekit-reset'?: true | false | '' | undefined | null;
 	}
 }
 `;
@@ -143,6 +169,15 @@ function generate_app_types(manifest_data, config, dir) {
 	/** @type {Set<string>} */
 	const pathnames = new Set();
 
+	/** @type {string[]} */
+	const page_route_ids = [];
+
+	/** @type {string[]} */
+	const endpoint_route_ids = [];
+
+	/** @type {string[]} */
+	const app_route_ids = [];
+
 	/** @type {string[]} */
 	const dynamic_routes = [];
 
@@ -151,15 +186,17 @@ function generate_app_types(manifest_data, config, dir) {
 
 	/** @type {Map<string, Map<string, { optional: boolean, matchers: Set<string> | null }>>} */
 	const layout_params_by_route = new Map(
-		manifest_data.routes.map((route) => [
-			route.id,
-			new Map(
-				route.params.map((p) => [
-					p.name,
-					{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
-				])
-			)
-		])
+		manifest_data.routes
+			.filter((route) => route.layout)
+			.map((route) => [
+				route.id,
+				new Map(
+					route.params.map((p) => [
+						p.name,
+						{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
+					])
+				)
+			])
 	);
 
 	for (const route of manifest_data.routes) {
@@ -193,8 +230,11 @@ function generate_app_types(manifest_data, config, dir) {
 	}
 
 	for (const route of manifest_data.routes) {
-		const pathname = remove_group_segments(route.id);
-		let normalized_pathname = pathname.slice(1);
+		const id = s(route.id);
+
+		if (is_page_route(route)) page_route_ids.push(id);
+		if (is_endpoint_route(route)) endpoint_route_ids.push(id);
+		if (is_app_route(route)) app_route_ids.push(id);
 
 		/** @type {(path: string) => string} */
 		let serialise = s;
@@ -204,16 +244,18 @@ function generate_app_types(manifest_data, config, dir) {
 				const type = get_matcher_type(p.matcher);
 				return `${/^\w+$/.test(p.name) ? p.name : `'${p.name}'`}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
 			});
-			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
 
-			dynamic_routes.push(route_type);
+			if (is_app_route(route)) {
+				dynamic_routes.push(`${s(route.id)}: { ${params.join('; ')} }`);
+			}
 
-			normalized_pathname = replace_required_params(replace_optional_params(pathname)).slice(1);
 			serialise = (p) => `\`${p}\` & {}`;
 		}
 
-		for (const p of get_pathnames_for_trailing_slash(normalized_pathname, route)) {
-			pathnames.add(serialise(p));
+		for (const pathname of get_pathname_patterns(route.id)) {
+			for (const p of get_pathnames_for_trailing_slash(pathname, route)) {
+				pathnames.add(serialise(p));
+			}
 		}
 
 		let layout_type = 'Record<string, never>';
@@ -230,7 +272,7 @@ function generate_app_types(manifest_data, config, dir) {
 			if (params.length > 0) layout_type = `{ ${params} }`;
 		}
 
-		layouts.push(`${s(route.id)}: ${layout_type}`);
+		if (route.layout) layouts.push(`${s(route.id)}: ${layout_type}`);
 	}
 
 	const assets = manifest_data.assets.map((asset) => s(asset.file));
@@ -238,7 +280,9 @@ function generate_app_types(manifest_data, config, dir) {
 	return [
 		'declare module "$app/types" {',
 		'\texport interface AppTypes {',
-		`\t\tRouteId(): ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
+		`\t\tPageRouteId(): ${page_route_ids.join(' | ') || 'never'};`,
+		`\t\tEndpointRouteId(): ${endpoint_route_ids.join(' | ') || 'never'};`,
+		`\t\tRouteId(): ${app_route_ids.join(' | ') || 'never'};`,
 		`\t\tRouteParams(): {\n\t\t\t${dynamic_routes.join(';\n\t\t\t')}\n\t\t};`,
 		`\t\tLayoutParams(): {\n\t\t\t${layouts.join(';\n\t\t\t')}\n\t\t};`,
 		`\t\tPath(): ${Array.from(pathnames).join(' | ')};`,

package/src/core/sync/write_tsconfig/index.js

@@ -2,7 +2,6 @@
 import process from 'node:process';
 import fs from 'node:fs';
 import path from 'node:path';
-import ts from 'typescript';
 import { styleText } from 'node:util';
 import { write_if_changed } from '../utils.js';
 import {
@@ -15,6 +14,14 @@ import {
 	validate_resolved_config
 } from './utils.js';
 
+/** @type {import('typescript')} */
+let ts;
+try {
+	ts = await import('typescript');
+} catch {
+	// The user has not installed TypeScript.
+}
+
 /**
  * Generates the tsconfig that the user's tsconfig inherits from.
  * @param {import('types').ValidatedKitConfig} kit
@@ -78,13 +85,19 @@ export function write_tsconfig(kit, root) {
  * @param {ValidatedKitConfig['typescript']['config']} [transform] TODO get rid of this
  */
 function write_parent_tsconfig(root, dir, id, config, example, transform) {
-	const out_file = path.join(root, `node_modules/${id}/tsconfig.json`);
+	// simplified tsconfig resolvers (e.g. Playwright's) only find `${id}.json`, not `${id}/tsconfig.json`
+	const out_file = path.join(root, `node_modules/${id}.json`);
 
 	let normalized = normalize_config(out_file, config);
 	normalized = transform?.(normalized) ?? normalized;
 
 	write_if_changed(out_file, JSON.stringify(normalized, null, '\t'));
 
+	if (!ts) {
+		// The user has not installed TypeScript. Skip validation of config.
+		return;
+	}
+
 	const user_config = load_user_tsconfig(dir);
 
 	if (user_config && modified_since_last_check(user_config.file)) {

package/src/core/sync/write_types/index.js

@@ -5,6 +5,7 @@ import { rimraf, walk, resolve_entry } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
+import { is_page_route } from '../create_manifest_data/index.js';
 const remove_relative_parent_traversals = (/** @type {string} */ path) =>
 	path.replace(/\.\.\//g, '');
 const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
@@ -278,7 +279,9 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 		let all_pages_have_load = true;
 		/** @type {import('types').RouteParam[]} */
 		const layout_params = [];
-		const ids = ['RouteId'];
+		// a layout can live in a directory that has no `+page` of its own, in which case its own id
+		// is never the matched route — a request to a colocated `+server` doesn't execute layouts
+		const ids = is_page_route(route) ? ['RouteId'] : [];
 
 		route.layout.child_pages?.forEach((page) => {
 			const leaf = routes.get(page);
@@ -312,7 +315,7 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 			ids.push('null');
 		}
 
-		declarations.push(`type LayoutRouteId = ${ids.join(' | ')}`);
+		declarations.push(`type LayoutRouteId = ${ids.join(' | ') || 'never'}`);
 
 		declarations.push(
 			'type LayoutParams = RouteParams & ' + generate_params_type(layout_params, outdir, config)

package/src/exports/index.js

@@ -27,10 +27,10 @@ export { defineParams } from './params.js';
  * return an error response without invoking `handleError`.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {string} [message] The error message.
  * @overload
- * @param {number} status
- * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} body
+ * @param {{ status: number; message: string } extends App.Error ? number : never} status
+ * @param {{ status: number; message: string } extends App.Error ? string : never} [message]
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
@@ -41,10 +41,12 @@ export { defineParams } from './params.js';
  * return an error response without invoking `handleError`.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {{ status: number; message: string } extends App.Error ? string | void | undefined : never} body The error message.
+ * @param {string} message The error message.
+ * @param {{ status: number; message: string } extends App.Error ? never : Omit<App.Error, 'status' | 'message'>} properties Additional properties of the App.Error type.
  * @overload
  * @param {number} status
- * @param {{ status: number; message: string } extends App.Error ? string | void | undefined : never} body
+ * @param {string} message
+ * @param {{ status: number; message: string } extends App.Error ? never : Omit<App.Error, 'status' | 'message'>} properties
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
@@ -54,13 +56,12 @@ export { defineParams } from './params.js';
  * When called during request handling, this will cause SvelteKit to
  * return an error response without invoking `handleError`.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @deprecated Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {string} body The error message.
- * @param {{ status: number; message: string } extends App.Error ? never : Omit<App.Error, 'status' | 'message'>} properties Additional properties of the App.Error type.
+ * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
  * @overload
  * @param {number} status
- * @param {string} body
- * @param {{ status: number; message: string } extends App.Error ? never : Omit<App.Error, 'status' | 'message'>} properties
+ * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} properties
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
@@ -71,18 +72,28 @@ export { defineParams } from './params.js';
  * return an error response without invoking `handleError`.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @param {any} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
- * @param {any} [body] An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {any} [message] A string, or (deprecated) a partial App.Error object
  * @param {any} [properties] Additional properties of the App.Error type when passing a string message.
  * @return {never}
  * @throws {import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
  * @throws {Error} If the provided status is invalid (not between 400 and 599).
  */
-export function error(status, body, properties) {
+export function error(status, message, properties) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 400 || status > 599)) {
 		throw new Error(`HTTP error status codes must be between 400 and 599 — ${status} is invalid`);
 	}
 
-	throw new HttpError(status, body, properties);
+	if (message !== undefined && typeof message !== 'string') {
+		if (DEV) {
+			console.warn(
+				'Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third'
+			);
+		}
+
+		({ message, ...properties } = message);
+	}
+
+	throw new HttpError({ ...properties, status, message: message ?? `Error: ${status}` });
 }
 
 /**

package/src/exports/internal/shared.js

@@ -2,19 +2,11 @@
 
 export class HttpError {
 	/**
-	 * @param {number} status
-	 * @param {Omit<App.Error, 'status'> | string | undefined} body
-	 * @param {Omit<App.Error, 'status' | 'message'>} [properties]
+	 * @param {App.Error} error
 	 */
-	constructor(status, body, properties) {
-		this.status = status;
-		if (typeof body === 'string') {
-			this.body = { ...properties, message: body, status };
-		} else if (body) {
-			this.body = { ...body, status };
-		} else {
-			this.body = { message: `Error: ${status}`, status };
-		}
+	constructor(error) {
+		this.status = error.status;
+		this.body = error;
 	}
 
 	toString() {

package/src/exports/node/index.js

@@ -137,14 +137,9 @@ export function getRequest({ request, base, bodySizeLimit }) {
 	}
 
 	const controller = new AbortController();
-	// TODO: Whenever Node >=22.17 is the minimum supported version, we can do `if (request.readableAborted) controller.abort()` instead
-	// see https://github.com/nodejs/node/blob/5cf3c3e24c7257a0c6192ed8ef71efec8ddac22b/lib/internal/streams/readable.js#L1443-L1453
-	let errored = false;
-	let end_emitted = false;
-	request.once('error', () => (errored = true));
-	request.once('end', () => (end_emitted = true));
+
 	request.once('close', () => {
-		if ((errored || request.destroyed) && !end_emitted) {
+		if (request.readableAborted) {
 			controller.abort();
 		}
 	});