From 8ca5d84d10d09c83d111c3572e6469c9631cfb3e Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Thu, 25 Jun 2026 00:01:03 +0200
Subject: [PATCH 01/24] breaking: allow `handleError` to influence status code

...by returning `{ status: ..., ... }` from `handleError`.

Breaking change because theoretically someone could've used this as part of `App.Error` before, and now it's kind of outside that, a reserved property on `handleError`'s return object.

Closes #14442
---
 .changeset/ripe-tires-chew.md                 |  6 ++++
 documentation/docs/30-advanced/25-errors.md   | 21 ++++++++++++
 packages/kit/src/exports/public.d.ts          |  8 +++--
 .../src/runtime/app/server/remote/query.js    | 16 ++++++----
 packages/kit/src/runtime/client/client.js     | 20 ++++++++----
 packages/kit/src/runtime/server/data/index.js | 21 +++++++-----
 .../kit/src/runtime/server/page/actions.js    | 22 +++++++------
 packages/kit/src/runtime/server/page/index.js |  2 +-
 .../kit/src/runtime/server/page/render.js     |  2 +-
 .../runtime/server/page/respond_with_error.js | 14 ++++----
 packages/kit/src/runtime/server/remote.js     | 28 ++++++++--------
 packages/kit/src/runtime/server/utils.js      |  2 +-
 packages/kit/src/types/internal.d.ts          |  2 +-
 packages/kit/src/utils/error.js               | 14 ++++++--
 packages/kit/src/utils/error.spec.js          | 32 +++++++++++++++++++
 .../kit/test/apps/basics/src/hooks.server.js  |  7 ++++
 .../errors/handle-error-status/+page.js       |  4 +++
 .../apps/basics/test/cross-platform/test.js   | 10 ++++++
 packages/kit/types/index.d.ts                 |  8 +++--
 19 files changed, 177 insertions(+), 62 deletions(-)
 create mode 100644 .changeset/ripe-tires-chew.md
 create mode 100644 packages/kit/src/utils/error.spec.js
 create mode 100644 packages/kit/test/apps/basics/src/routes/errors/handle-error-status/+page.js

diff --git a/.changeset/ripe-tires-chew.md b/.changeset/ripe-tires-chew.md
new file mode 100644
index 000000000000..17a8c85a9fd4
--- /dev/null
+++ b/.changeset/ripe-tires-chew.md
@@ -0,0 +1,6 @@
+---
+"@sveltejs/kit": major
+---
+
+breaking: allow `handleError` to influence status code
+  
\ No newline at end of file
diff --git a/documentation/docs/30-advanced/25-errors.md b/documentation/docs/30-advanced/25-errors.md
index 95538d279afe..c81d1ab57810 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -100,6 +100,27 @@ By default, unexpected errors are printed to the console (or, in production, you
 
 Unexpected errors will go through the [`handleError`](hooks#Shared-hooks-handleError) hook, where you can add your own error handling — for example, sending errors to a reporting service, or returning a custom error object which becomes `page.error`.
 
+You can override the HTTP status code used in the response by returning a `status` property:
+
+```js
+/// file: src/hooks.server.js
+// Assuming you have this ...
+class NotFound extends Error {}
+
+/** @type {import('./$types').HandleServerError} */
+export function handleError({ error, event, status, message }) {
+	// ... you can do this
+	if (error instanceof NotFound) {
+		return {
+			status: 404,
+			message: 'Not found'
+		};
+	}
+
+	return { message: 'Something went wrong' };
+}
+```
+
 ## Rendering errors
 
 Ordinarily, if an error happens during server-side rendering (for example inside a component's `<script>` block or template), SvelteKit will return a 500 error page.
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 976483de50e9..9694fce10500 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -939,13 +939,15 @@ export type Handle = (input: {
  *
  * If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event.
  * Make sure that this function _never_ throws an error.
+ *
+ * The returned object can include a `status` property to override the HTTP status code used in the response.
  */
 export type HandleServerError = (input: {
 	error: unknown;
 	event: RequestEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | App.Error>;
+}) => MaybePromise<void | (App.Error & { status?: number })>;
 
 /**
  * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -960,13 +962,15 @@ export type HandleValidationError<Issue extends StandardSchemaV1.Issue = Standar
  *
  * If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event.
  * Make sure that this function _never_ throws an error.
+ *
+ * The returned object can include a `status` property to override the HTTP status code used in the response.
  */
 export type HandleClientError = (input: {
 	error: unknown;
 	event: NavigationEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | App.Error>;
+}) => MaybePromise<void | (App.Error & { status?: number })>;
 
 /**
  * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
diff --git a/packages/kit/src/runtime/app/server/remote/query.js b/packages/kit/src/runtime/app/server/remote/query.js
index 998b82d11c46..5a4a9b79602d 100644
--- a/packages/kit/src/runtime/app/server/remote/query.js
+++ b/packages/kit/src/runtime/app/server/remote/query.js
@@ -14,7 +14,7 @@ import {
 import { noop } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
 import { handle_error_and_jsonify } from '../../../server/utils.js';
-import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
+import { get_status } from '../../../../utils/error.js';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -347,13 +347,17 @@ function batch(validate_or_fn, maybe_fn) {
 								const data = get_result(arg, i);
 								return { type: 'result', data };
 							} catch (error) {
+								const transformed = await handle_error_and_jsonify(
+									event,
+									state,
+									options,
+									error
+								);
+
 								return {
 									type: 'error',
-									error: await handle_error_and_jsonify(event, state, options, error),
-									status:
-										error instanceof HttpError || error instanceof SvelteKitError
-											? error.status
-											: 500
+									error: transformed,
+									status: get_status(transformed, error)
 								};
 							}
 						})
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 532ad57f9a09..9c41dddb3cf6 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -709,7 +709,7 @@ async function initialize(result, target, hydrate) {
 		transformError: __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__
 			? /** @param {unknown} e */ async (e) => {
 					const error = await handle_error(e, current.nav);
-					rendering_error = { error, status: get_status(e) };
+					rendering_error = { error, status: get_status(error, e) };
 					page.error = error;
 					page.status = rendering_error.status;
 					return error;
@@ -1243,7 +1243,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 				}
 
 				return load_root_error_page({
-					status: get_status(error),
+					status: get_status(handled_error, error),
 					error: handled_error,
 					url,
 					route
@@ -1337,17 +1337,20 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					});
 				}
 
-				let status = get_status(err);
 				/** @type {App.Error} */
 				let error;
+				/** @type {number} */
+				let status;
 
 				if (server_data_nodes?.includes(/** @type {import('types').ServerErrorNode} */ (err))) {
 					// this is the server error rethrown above, reconstruct but don't invoke
 					// the client error handler; it should've already been handled on the server
-					status = /** @type {import('types').ServerErrorNode} */ (err).status ?? status;
 					error = /** @type {import('types').ServerErrorNode} */ (err).error;
+					status =
+						/** @type {import('types').ServerErrorNode} */ (err).status ?? get_status(error, err);
 				} else if (err instanceof HttpError) {
 					error = err.body;
+					status = err.status;
 				} else {
 					// Referenced node could have been removed due to redeploy, check
 					const updated = await stores.updated.check();
@@ -1358,6 +1361,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					}
 
 					error = await handle_error(err, { params, url, route: { id: route.id } });
+					status = get_status(error, err);
 				}
 
 				const error_load = await load_nearest_error_page(i, branch, errors);
@@ -1514,7 +1518,7 @@ async function load_root_error_page({ status, error, url, route }) {
 			.replace(/&/g, '&amp;')
 			.replace(/</g, '&lt;')
 			.replace(/>/g, '&gt;');
-		const html = error_template({ status, message });
+		const html = error_template({ status: get_status(handled, error), message });
 		const parsed = new DOMParser().parseFromString(html, 'text/html');
 		document.documentElement.replaceChild(document.adoptNode(parsed.head), document.head);
 		document.documentElement.replaceChild(document.adoptNode(parsed.body), document.body);
@@ -3078,9 +3082,11 @@ async function _hydrate(
 			return await native_navigation(new URL(error.location, location.href));
 		}
 
+		const handled_error = await handle_error(error, { url, params, route });
+
 		result = await load_root_error_page({
-			status: get_status(error),
-			error: await handle_error(error, { url, params, route }),
+			status: get_status(handled_error, error),
+			error: handled_error,
 			url,
 			route
 		});
diff --git a/packages/kit/src/runtime/server/data/index.js b/packages/kit/src/runtime/server/data/index.js
index 83e16c3a9d12..da54e420a2b6 100644
--- a/packages/kit/src/runtime/server/data/index.js
+++ b/packages/kit/src/runtime/server/data/index.js
@@ -1,6 +1,6 @@
 import { text } from '@sveltejs/kit';
-import { HttpError, SvelteKitError, Redirect } from '@sveltejs/kit/internal';
-import { normalize_error } from '../../../utils/error.js';
+import { Redirect } from '@sveltejs/kit/internal';
+import { normalize_error, get_status } from '../../../utils/error.js';
 import { once } from '../../../utils/functions.js';
 import { server_data_serializer_json } from '../page/data_serializer.js';
 import { load_server_data } from '../page/load_data.js';
@@ -107,13 +107,17 @@ export async function render_data(
 					// Math.min because array isn't guaranteed to resolve in order
 					length = Math.min(length, i + 1);
 
+					const transformed = await handle_error_and_jsonify(
+						event,
+						event_state,
+						options,
+						error
+					);
+
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
-						error: await handle_error_and_jsonify(event, event_state, options, error),
-						status:
-							error instanceof HttpError || error instanceof SvelteKitError
-								? error.status
-								: undefined
+						error: transformed,
+						status: get_status(transformed, error)
 					});
 				})
 			)
@@ -156,7 +160,8 @@ export async function render_data(
 		if (error instanceof Redirect) {
 			return redirect_json_response(error);
 		} else {
-			return json_response(await handle_error_and_jsonify(event, event_state, options, error), 500);
+			const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+			return json_response(transformed, get_status(transformed, error));
 		}
 	}
 }
diff --git a/packages/kit/src/runtime/server/page/actions.js b/packages/kit/src/runtime/server/page/actions.js
index bf224e62c93a..7d76fba8149d 100644
--- a/packages/kit/src/runtime/server/page/actions.js
+++ b/packages/kit/src/runtime/server/page/actions.js
@@ -36,13 +36,15 @@ export async function handle_action_json_request(event, event_state, options, se
 			`POST method not allowed. No form actions exist for ${DEV ? `the page at ${event.route.id}` : 'this page'}`
 		);
 
+		const error = await handle_error_and_jsonify(event, event_state, options, no_actions_error);
+
 		return action_json(
 			{
 				type: 'error',
-				error: await handle_error_and_jsonify(event, event_state, options, no_actions_error)
+				error
 			},
 			{
-				status: no_actions_error.status,
+				status: get_status(error, no_actions_error),
 				headers: {
 					// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
 					// "The server must generate an Allow header field in a 405 status code response"
@@ -93,18 +95,20 @@ export async function handle_action_json_request(event, event_state, options, se
 			return action_json_redirect(err);
 		}
 
+		const transformed = await handle_error_and_jsonify(
+			event,
+			event_state,
+			options,
+			check_incorrect_fail_use(err)
+		);
+
 		return action_json(
 			{
 				type: 'error',
-				error: await handle_error_and_jsonify(
-					event,
-					event_state,
-					options,
-					check_incorrect_fail_use(err)
-				)
+				error: transformed
 			},
 			{
-				status: get_status(err)
+				status: get_status(transformed, err)
 			}
 		);
 	}
diff --git a/packages/kit/src/runtime/server/page/index.js b/packages/kit/src/runtime/server/page/index.js
index b83c77c338ad..aa9bb843bdbe 100644
--- a/packages/kit/src/runtime/server/page/index.js
+++ b/packages/kit/src/runtime/server/page/index.js
@@ -281,8 +281,8 @@ export async function render_page(
 						return redirect_response(err.status, err.location);
 					}
 
-					const status = get_status(err);
 					const error = await handle_error_and_jsonify(event, event_state, options, err);
+					const status = get_status(error, err);
 
 					while (i--) {
 						if (page.errors[i]) {
diff --git a/packages/kit/src/runtime/server/page/render.js b/packages/kit/src/runtime/server/page/render.js
index d6768048ba18..1de838e464df 100644
--- a/packages/kit/src/runtime/server/page/render.js
+++ b/packages/kit/src/runtime/server/page/render.js
@@ -205,7 +205,7 @@ export async function render_response({
 
 						const transformed = await handle_error_and_jsonify(event, event_state, options, e);
 						props.page.error = props.error = error = transformed;
-						props.page.status = status = get_status(e);
+						props.page.status = status = get_status(transformed, e);
 						return transformed;
 					}
 				: undefined
diff --git a/packages/kit/src/runtime/server/page/respond_with_error.js b/packages/kit/src/runtime/server/page/respond_with_error.js
index 71717e209c4b..023ce4cf843d 100644
--- a/packages/kit/src/runtime/server/page/respond_with_error.js
+++ b/packages/kit/src/runtime/server/page/respond_with_error.js
@@ -90,6 +90,8 @@ export async function respond_with_error({
 			);
 		}
 
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+
 		return await render_response({
 			options,
 			manifest,
@@ -98,8 +100,8 @@ export async function respond_with_error({
 				ssr,
 				csr
 			},
-			status,
-			error: await handle_error_and_jsonify(event, event_state, options, error),
+			status: get_status(transformed, error),
+			error: transformed,
 			branch,
 			error_components: [],
 			fetched,
@@ -115,10 +117,8 @@ export async function respond_with_error({
 			return redirect_response(e.status, e.location);
 		}
 
-		return static_error_page(
-			options,
-			get_status(e),
-			(await handle_error_and_jsonify(event, event_state, options, e)).message
-		);
+		const transformed = await handle_error_and_jsonify(event, event_state, options, e);
+
+		return static_error_page(options, get_status(transformed, e), transformed.message);
 	}
 }
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 4b190ce345fb..8db845d63115 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -8,7 +8,7 @@ import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
 import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.js';
 import { handle_error_and_jsonify } from './utils.js';
-import { normalize_error } from '../../utils/error.js';
+import { normalize_error, get_status } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
@@ -171,15 +171,17 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 											location: error.location
 										});
 									} else {
-										const status =
-											error instanceof HttpError || error instanceof SvelteKitError
-												? error.status
-												: 500;
+										const transformed = await handle_error_and_jsonify(
+											event,
+											state,
+											options,
+											error
+										);
 
 										send(controller, {
 											type: 'error',
-											error: await handle_error_and_jsonify(event, state, options, error),
-											status
+											error: transformed,
+											status: get_status(transformed, error)
 										});
 									}
 								}
@@ -326,13 +328,13 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			);
 		}
 
-		const status =
-			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		const status = get_status(transformed, error);
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
-				error: await handle_error_and_jsonify(event, state, options, error),
+				error: transformed,
 				status
 			}),
 			{
@@ -362,10 +364,8 @@ export async function collect_remote_data(data, event, state, options) {
 	 * @returns {Promise<[status: number, error: App.Error]>}
 	 */
 	async function convert_error(error) {
-		const status =
-			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
-
-		return [status, await handle_error_and_jsonify(event, state, options, error)];
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		return [get_status(transformed, error), transformed];
 	}
 
 	/** @type {Promise<any>[]} */
diff --git a/packages/kit/src/runtime/server/utils.js b/packages/kit/src/runtime/server/utils.js
index 016d7e7bc245..15df0d8de743 100644
--- a/packages/kit/src/runtime/server/utils.js
+++ b/packages/kit/src/runtime/server/utils.js
@@ -75,8 +75,8 @@ export function static_error_page(options, status, message) {
  */
 export async function handle_fatal_error(event, state, options, error) {
 	error = error instanceof HttpError ? error : coalesce_to_error(error);
-	const status = get_status(error);
 	const body = await handle_error_and_jsonify(event, state, options, error);
+	const status = get_status(body, error);
 
 	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
 	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
diff --git a/packages/kit/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index 95dc2954ac21..b81bc2946e06 100644
--- a/packages/kit/src/types/internal.d.ts
+++ b/packages/kit/src/types/internal.d.ts
@@ -392,7 +392,7 @@ export interface ServerErrorNode {
 	type: 'error';
 	error: App.Error;
 	/**
-	 * Only set for HttpErrors.
+	 * Only set for HttpErrors, or when overridden by `handleError`.
 	 */
 	status?: number;
 }
diff --git a/packages/kit/src/utils/error.js b/packages/kit/src/utils/error.js
index d62e4bdf8fb9..5c119b6d2a90 100644
--- a/packages/kit/src/utils/error.js
+++ b/packages/kit/src/utils/error.js
@@ -36,10 +36,18 @@ export function normalize_error(error) {
 }
 
 /**
- * @param {unknown} error
+ * @param {any} transformed
+ * @param {any} [error]
  */
-export function get_status(error) {
-	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+export function get_status(transformed, error) {
+	const err = error ?? transformed;
+	const status = err instanceof HttpError || err instanceof SvelteKitError ? err.status : 500;
+
+	if (error == null || typeof transformed?.status !== 'number') {
+		return status;
+	} else {
+		return transformed.status;
+	}
 }
 
 /**
diff --git a/packages/kit/src/utils/error.spec.js b/packages/kit/src/utils/error.spec.js
new file mode 100644
index 000000000000..07959738bb20
--- /dev/null
+++ b/packages/kit/src/utils/error.spec.js
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
+import { get_status } from './error.js';
+
+describe('get_status', () => {
+	it('returns status from transformed error', () => {
+		expect(get_status({ message: 'not found', status: 404 }, new Error('oops'))).toBe(404);
+	});
+
+	it('falls back to HttpError status', () => {
+		const error = new HttpError(403, { message: 'forbidden' });
+		expect(get_status({ message: 'forbidden' }, error)).toBe(403);
+	});
+
+	it('falls back to SvelteKitError status', () => {
+		const error = new SvelteKitError(404, 'Not Found', 'missing');
+		expect(get_status({ message: 'missing' }, error)).toBe(404);
+	});
+
+	it('returns 500 for plain errors', () => {
+		expect(get_status({ message: 'oops' }, new Error('oops'))).toBe(500);
+	});
+
+	it('works with a single HttpError argument', () => {
+		const error = new HttpError(418, { message: 'teapot' });
+		expect(get_status(error)).toBe(418);
+	});
+
+	it('works with a single plain Error argument', () => {
+		expect(get_status(new Error('oops'))).toBe(500);
+	});
+});
diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index e904924c491c..cd15dd823ded 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -47,6 +47,13 @@ export const handleError = ({ event, error: e, status, message }) => {
 		message = /** @type {string} */ (ev.locals.message);
 	}
 
+	if (event.url.pathname === '/errors/handle-error-status') {
+		return {
+			status: 404,
+			message: `${error.message} (${status} ${message})`
+		};
+	}
+
 	return event.url.pathname.endsWith('404-fallback')
 		? undefined
 		: { message: `${error.message} (${status} ${message})` };
diff --git a/packages/kit/test/apps/basics/src/routes/errors/handle-error-status/+page.js b/packages/kit/test/apps/basics/src/routes/errors/handle-error-status/+page.js
new file mode 100644
index 000000000000..25d076279a1d
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/errors/handle-error-status/+page.js
@@ -0,0 +1,4 @@
+/** @type {import('@sveltejs/kit').Load} */
+export async function load() {
+	throw new Error('Status override test');
+}
diff --git a/packages/kit/test/apps/basics/test/cross-platform/test.js b/packages/kit/test/apps/basics/test/cross-platform/test.js
index 9caab5539ab0..119dbcead237 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/test.js
@@ -336,6 +336,16 @@ test.describe('Errors', () => {
 		expect(await page.textContent('#error-layout-data')).toBe('42');
 	});
 
+	test('handleError can override the status code of an unexpected error', async ({ page }) => {
+		const response = await page.goto('/errors/handle-error-status');
+
+		expect(await page.textContent('h1')).toBe('404');
+		expect(await page.textContent('#message')).toBe(
+			'This is your custom error page saying: "Status override test (500 Internal Error)"'
+		);
+		expect(/** @type {Response} */ (response).status()).toBe(404);
+	});
+
 	test('error in endpoint', async ({ page, read_errors }) => {
 		const res = await page.goto('/errors/endpoint');
 
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 54548342513d..b2f46e997f03 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -912,13 +912,15 @@ declare module '@sveltejs/kit' {
 	 *
 	 * If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event.
 	 * Make sure that this function _never_ throws an error.
+	 *
+	 * The returned object can include a `status` property to override the HTTP status code used in the response.
 	 */
 	export type HandleServerError = (input: {
 		error: unknown;
 		event: RequestEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | App.Error>;
+	}) => MaybePromise<void | (App.Error & { status?: number })>;
 
 	/**
 	 * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -933,13 +935,15 @@ declare module '@sveltejs/kit' {
 	 *
 	 * If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event.
 	 * Make sure that this function _never_ throws an error.
+	 *
+	 * The returned object can include a `status` property to override the HTTP status code used in the response.
 	 */
 	export type HandleClientError = (input: {
 		error: unknown;
 		event: NavigationEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | App.Error>;
+	}) => MaybePromise<void | (App.Error & { status?: number })>;
 
 	/**
 	 * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.

From ec110fbfa2c40863f5a784c2e8ef1c4c4c4248ba Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Thu, 25 Jun 2026 01:28:00 +0200
Subject: [PATCH 02/24] Update documentation/docs/30-advanced/25-errors.md

Co-authored-by: vercel[bot] <35613825+vercel[bot]@users.noreply.github.com>
---
 documentation/docs/30-advanced/25-errors.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/30-advanced/25-errors.md b/documentation/docs/30-advanced/25-errors.md
index c81d1ab57810..09ae1fe719a0 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -107,7 +107,7 @@ You can override the HTTP status code used in the response by returning a `statu
 // Assuming you have this ...
 class NotFound extends Error {}
 
-/** @type {import('./$types').HandleServerError} */
+/** @type {import('@sveltejs/kit').HandleServerError} */
 export function handleError({ error, event, status, message }) {
 	// ... you can do this
 	if (error instanceof NotFound) {

From b7f82a814f1f0e2e89b096e49006f237149fc026 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 23:29:49 +0000
Subject: [PATCH 03/24] chore: autofix lint

---
 packages/kit/src/runtime/app/server/remote/query.js | 7 +------
 packages/kit/src/runtime/server/data/index.js       | 7 +------
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/packages/kit/src/runtime/app/server/remote/query.js b/packages/kit/src/runtime/app/server/remote/query.js
index 5a4a9b79602d..8db435048735 100644
--- a/packages/kit/src/runtime/app/server/remote/query.js
+++ b/packages/kit/src/runtime/app/server/remote/query.js
@@ -347,12 +347,7 @@ function batch(validate_or_fn, maybe_fn) {
 								const data = get_result(arg, i);
 								return { type: 'result', data };
 							} catch (error) {
-								const transformed = await handle_error_and_jsonify(
-									event,
-									state,
-									options,
-									error
-								);
+								const transformed = await handle_error_and_jsonify(event, state, options, error);
 
 								return {
 									type: 'error',
diff --git a/packages/kit/src/runtime/server/data/index.js b/packages/kit/src/runtime/server/data/index.js
index da54e420a2b6..0b8ce25fc3f2 100644
--- a/packages/kit/src/runtime/server/data/index.js
+++ b/packages/kit/src/runtime/server/data/index.js
@@ -107,12 +107,7 @@ export async function render_data(
 					// Math.min because array isn't guaranteed to resolve in order
 					length = Math.min(length, i + 1);
 
-					const transformed = await handle_error_and_jsonify(
-						event,
-						event_state,
-						options,
-						error
-					);
+					const transformed = await handle_error_and_jsonify(event, event_state, options, error);
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',

From 3609842f10b66f32108fc540d6e5a5a015e3849b Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Thu, 25 Jun 2026 16:47:35 +0200
Subject: [PATCH 04/24] lint

---
 packages/kit/src/runtime/server/remote.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 8db845d63115..1a16c6e6d835 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -2,7 +2,7 @@
 /** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, SSROptions } from 'types' */
 
 import { json, error } from '@sveltejs/kit';
-import { HttpError, Redirect, SvelteKitError } from '@sveltejs/kit/internal';
+import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';

From 7a185d8f5c6ac6e87bdbfc5d3d78466184b9fd1d Mon Sep 17 00:00:00 2001
From: Simon H <5968653+dummdidumm@users.noreply.github.com>
Date: Thu, 25 Jun 2026 17:31:31 +0200
Subject: [PATCH 05/24] Update
 packages/kit/test/apps/basics/test/cross-platform/test.js

Co-authored-by: Tee Ming <chewteeming01@gmail.com>
---
 packages/kit/test/apps/basics/test/cross-platform/test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/kit/test/apps/basics/test/cross-platform/test.js b/packages/kit/test/apps/basics/test/cross-platform/test.js
index 119dbcead237..d93c31efc723 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/test.js
@@ -339,8 +339,8 @@ test.describe('Errors', () => {
 	test('handleError can override the status code of an unexpected error', async ({ page }) => {
 		const response = await page.goto('/errors/handle-error-status');
 
-		expect(await page.textContent('h1')).toBe('404');
-		expect(await page.textContent('#message')).toBe(
+		await expect(page.locator('h1')).toHaveText('404');
+		await expect(page.locator('#message')).toHaveText(
 			'This is your custom error page saying: "Status override test (500 Internal Error)"'
 		);
 		expect(/** @type {Response} */ (response).status()).toBe(404);

From 3a4ada7cd5364422f003c5d7df967fb2ad23de1c Mon Sep 17 00:00:00 2001
From: Tee Ming Chew <chewteeming01@gmail.com>
Date: Fri, 26 Jun 2026 01:55:44 +1000
Subject: [PATCH 06/24] fix

---
 packages/kit/src/runtime/client/client.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index cccaaa16b127..6ebb327067a6 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -1337,12 +1337,11 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					};
 				}
 
-				let status = get_status(err);
-
 				if (preload && preload_tokens.has(preload)) {
+					const error = await handle_error(err, { params, url, route: { id: route.id } });
 					return preload_error({
-						error: await handle_error(err, { params, url, route: { id: route.id } }),
-						status,
+						error,
+						status: get_status(error, err),
 						url,
 						params,
 						route

From adbdaf58bd5cf762f1b37dab9d56bd2da405da2d Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 17:10:42 +0200
Subject: [PATCH 07/24] tweak error/App.Error shape

---
 packages/kit/package.json                     |  2 +-
 packages/kit/src/exports/index.js             | 31 +++++++--
 packages/kit/src/exports/index.spec.js        | 40 ++++++++++-
 packages/kit/src/exports/internal/index.js    | 11 +--
 packages/kit/src/exports/public.d.ts          |  6 +-
 .../client/remote-functions/form.svelte.js    |  4 +-
 packages/kit/src/runtime/server/index.js      |  4 +-
 packages/kit/src/runtime/server/utils.js      | 12 ++--
 packages/kit/src/types/ambient.d.ts           |  1 +
 .../types/app-error-enhanced/error.test.ts    | 67 +++++++++++++++++++
 .../types/app-error-enhanced/tsconfig.json    | 10 +++
 packages/kit/test/types/error.test.ts         | 48 +++++++++++++
 packages/kit/test/types/tsconfig.json         |  3 +-
 packages/kit/types/index.d.ts                 | 43 ++++++++++--
 14 files changed, 250 insertions(+), 32 deletions(-)
 create mode 100644 packages/kit/test/types/app-error-enhanced/error.test.ts
 create mode 100644 packages/kit/test/types/app-error-enhanced/tsconfig.json
 create mode 100644 packages/kit/test/types/error.test.ts

diff --git a/packages/kit/package.json b/packages/kit/package.json
index c63ff675c454..d81564c02565 100644
--- a/packages/kit/package.json
+++ b/packages/kit/package.json
@@ -71,7 +71,7 @@
 	],
 	"scripts": {
 		"lint": "prettier --config ../../.prettierrc --check .",
-		"check": "tsc && cd ./test/types && tsc",
+		"check": "tsc && cd ./test/types && tsc && cd ./app-error-enhanced && tsc",
 		"check:all": "tsc && pnpm -r --filter=\"./**\" check",
 		"format": "prettier --config ../../.prettierrc --write .",
 		"test": "pnpm test:unit && pnpm test:integration",
diff --git a/packages/kit/src/exports/index.js b/packages/kit/src/exports/index.js
index ff1a02d834c5..03f29d1b5f3e 100644
--- a/packages/kit/src/exports/index.js
+++ b/packages/kit/src/exports/index.js
@@ -26,10 +26,10 @@ export { VERSION } from '../version.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 {App.Error} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @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 {App.Error} body
+ * @param {Omit<App.Error, 'status'> & { status?: App.Error['status'] }} body
  * @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).
@@ -40,10 +40,10 @@ export { VERSION } from '../version.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 {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body] An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @param {{ status: number; message: string } extends App.Error ? string | void | undefined : never} body The error message.
  * @overload
  * @param {number} status
- * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
+ * @param {{ status: number; message: string } extends App.Error ? string | void | undefined : never} body
  * @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,17 +54,34 @@ export { VERSION } from '../version.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 {{ message: string } extends App.Error ? App.Error | string | undefined : never} 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} 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.
+ * @overload
+ * @param {number} status
+ * @param {string} body
+ * @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).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * 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.
+ * @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} [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) {
+export function error(status, body, 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);
+	throw new HttpError(status, body, properties);
 }
 
 /**
diff --git a/packages/kit/src/exports/index.spec.js b/packages/kit/src/exports/index.spec.js
index faac39323672..944543bfa96d 100644
--- a/packages/kit/src/exports/index.spec.js
+++ b/packages/kit/src/exports/index.spec.js
@@ -1,4 +1,4 @@
-import { isRedirect, normalizeUrl, redirect } from './index.js';
+import { error, isHttpError, isRedirect, normalizeUrl, redirect } from './index.js';
 import { assert, describe, it } from 'vitest';
 
 describe('normalizeUrl', () => {
@@ -74,3 +74,41 @@ describe('redirect', () => {
 		);
 	});
 });
+
+describe('error', () => {
+	it('adds status to the body', () => {
+		try {
+			error(418, 'teapot');
+			assert.fail('Expected error to throw');
+		} catch (e) {
+			if (!isHttpError(e)) {
+				assert.fail('Expected an HttpError');
+			}
+
+			assert.equal(e.status, 418);
+			assert.deepEqual(e.body, { message: 'teapot', status: 418 });
+		}
+	});
+
+	it('merges additional body properties', () => {
+		try {
+			// @ts-expect-error
+			error(400, 'Bad request', { code: 'bad_request' });
+			assert.fail('Expected error to throw');
+		} catch (e) {
+			if (!isHttpError(e)) {
+				assert.fail('Expected an HttpError');
+			}
+
+			assert.equal(e.status, 400);
+			assert.deepEqual(
+				e.body,
+				/** @type {any} */ ({
+					code: 'bad_request',
+					message: 'Bad request',
+					status: 400
+				})
+			);
+		}
+	});
+});
diff --git a/packages/kit/src/exports/internal/index.js b/packages/kit/src/exports/internal/index.js
index eb9589c368d4..7e04edc1acd5 100644
--- a/packages/kit/src/exports/internal/index.js
+++ b/packages/kit/src/exports/internal/index.js
@@ -3,16 +3,17 @@
 export class HttpError {
 	/**
 	 * @param {number} status
-	 * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
+	 * @param {Omit<App.Error, 'status'> | string | undefined} body
+	 * @param {Omit<App.Error, 'status' | 'message'>} [properties]
 	 */
-	constructor(status, body) {
+	constructor(status, body, properties) {
 		this.status = status;
 		if (typeof body === 'string') {
-			this.body = { message: body };
+			this.body = { ...properties, message: body, status };
 		} else if (body) {
-			this.body = body;
+			this.body = { ...body, status };
 		} else {
-			this.body = { message: `Error: ${status}` };
+			this.body = { message: `Error: ${status}`, status };
 		}
 	}
 
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index eae56774de53..1e356d4fc609 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -34,6 +34,8 @@ export { PrerenderOption } from '../types/private.js';
 // @ts-ignore this is an optional peer dependency so could be missing. Written like this so dts-buddy preserves the ts-ignore
 type Span = import('@opentelemetry/api').Span;
 
+type AppErrorWithOptionalStatus = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
+
 /**
  * [Adapters](https://svelte.dev/docs/kit/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
  */
@@ -959,7 +961,7 @@ export type HandleServerError = (input: {
 	event: RequestEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | (App.Error & { status?: number })>;
+}) => MaybePromise<void | AppErrorWithOptionalStatus>;
 
 /**
  * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -982,7 +984,7 @@ export type HandleClientError = (input: {
 	event: NavigationEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | (App.Error & { status?: number })>;
+}) => MaybePromise<void | AppErrorWithOptionalStatus>;
 
 /**
  * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
diff --git a/packages/kit/src/runtime/client/remote-functions/form.svelte.js b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
index 80c49e42fcdd..e4cf41584bf0 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -428,7 +428,9 @@ export function form(id) {
 					await enhance_callback(create_enhance_callback_instance(form, form_data));
 				} catch (e) {
 					const error =
-						e instanceof HttpError ? e.body : { message: /** @type {any} */ (e).message };
+						e instanceof HttpError
+							? e.body
+							: { message: /** @type {any} */ (e).message, status: 500 };
 					const status = e instanceof HttpError ? e.status : 500;
 					void set_nearest_error_page(error, status);
 				} finally {
diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index 886d8da63a09..cf6b41074987 100644
--- a/packages/kit/src/runtime/server/index.js
+++ b/packages/kit/src/runtime/server/index.js
@@ -120,7 +120,7 @@ export class Server {
 						module.handleValidationError ||
 						(({ issues }) => {
 							console.error('Remote function schema validation failed:', issues);
-							return { message: 'Bad Request' };
+							return { message: 'Bad Request', status: 400 };
 						}),
 					reroute: module.reroute || noop,
 					transport: module.transport || {}
@@ -144,7 +144,7 @@ export class Server {
 						handleError: ({ error }) => console.error(error),
 						handleFetch: ({ request, fetch }) => fetch(request),
 						handleValidationError: () => {
-							return { message: 'Bad Request' };
+							return { message: 'Bad Request', status: 400 };
 						},
 						reroute: noop,
 						transport: {}
diff --git a/packages/kit/src/runtime/server/utils.js b/packages/kit/src/runtime/server/utils.js
index 5756d2085ab8..205adba468f1 100644
--- a/packages/kit/src/runtime/server/utils.js
+++ b/packages/kit/src/runtime/server/utils.js
@@ -103,7 +103,7 @@ export async function handle_fatal_error(event, state, options, error) {
 export async function handle_error_and_jsonify(event, state, options, error) {
 	if (error instanceof HttpError) {
 		// @ts-expect-error custom user errors may not have a message field if App.Error is overwritten
-		return { message: 'Unknown Error', ...error.body };
+		return { message: 'Unknown Error', ...error.body, status: error.status };
 	}
 
 	if (__SVELTEKIT_DEV__ && typeof error == 'object') {
@@ -113,11 +113,11 @@ export async function handle_error_and_jsonify(event, state, options, error) {
 	const status = get_status(error);
 	const message = get_message(error);
 
-	return (
-		(await with_request_store({ event, state }, () =>
-			options.hooks.handleError({ error, event, status, message })
-		)) ?? { message }
-	);
+	const body = (await with_request_store({ event, state }, () =>
+		options.hooks.handleError({ error, event, status, message })
+	)) ?? { message };
+
+	return { ...body, status: body.status ?? status };
 }
 
 /**
diff --git a/packages/kit/src/types/ambient.d.ts b/packages/kit/src/types/ambient.d.ts
index df84cc12ce72..426beb2474b3 100644
--- a/packages/kit/src/types/ambient.d.ts
+++ b/packages/kit/src/types/ambient.d.ts
@@ -25,6 +25,7 @@ declare namespace App {
 	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Unexpected errors are handled by the `handleError` hooks which should return this shape.
 	 */
 	export interface Error {
+		status: number;
 		message: string;
 	}
 
diff --git a/packages/kit/test/types/app-error-enhanced/error.test.ts b/packages/kit/test/types/app-error-enhanced/error.test.ts
new file mode 100644
index 000000000000..29877e626c60
--- /dev/null
+++ b/packages/kit/test/types/app-error-enhanced/error.test.ts
@@ -0,0 +1,67 @@
+import { error, type HandleClientError, type HandleServerError } from '@sveltejs/kit';
+
+const app_error: App.Error = { status: 500, message: 'Unexpected error', additional: true };
+
+declare global {
+	namespace App {
+		interface Error {
+			additional: boolean;
+		}
+	}
+}
+
+// @ts-expect-error App.Error requires status
+const app_error_without_status: App.Error = { message: 'Unexpected error' };
+
+const handle_error_hooks: [
+	HandleServerError,
+	HandleServerError,
+	HandleClientError,
+	HandleClientError
+] = [
+	() => ({ message: 'Unexpected error', additional: true }),
+	// @ts-expect-error App.Error requires additional
+	() => ({ message: 'Unexpected error' }),
+	() => ({ message: 'Unexpected error', additional: true }),
+	// @ts-expect-error App.Error requires
+	() => ({ message: 'Unexpected error' })
+];
+
+void app_error;
+void app_error_without_status;
+void handle_error_hooks;
+
+function a() {
+	// @ts-expect-error App.Error requires additional
+	error(400, 'Bad request');
+}
+
+function b() {
+	// @ts-expect-error App.Error requires additional
+	error(400, { message: 'Bad request' });
+}
+
+function c() {
+	error(400, 'Bad request', { additional: true });
+}
+
+function d() {
+	// @ts-expect-error
+	error(400, { message: 'Bad request' });
+}
+
+function e() {
+	error(400, { message: 'Bad request', additional: true });
+}
+
+function f() {
+	// @ts-expect-error
+	error(400);
+}
+
+a;
+b;
+c;
+d;
+e;
+f;
diff --git a/packages/kit/test/types/app-error-enhanced/tsconfig.json b/packages/kit/test/types/app-error-enhanced/tsconfig.json
new file mode 100644
index 000000000000..cccbcf5d4ea7
--- /dev/null
+++ b/packages/kit/test/types/app-error-enhanced/tsconfig.json
@@ -0,0 +1,10 @@
+{
+	"extends": "../../../tsconfig.json",
+	"compilerOptions": {
+		"noEmit": true,
+		"paths": {
+			"@sveltejs/kit": ["../../../types/index.d.ts"]
+		}
+	},
+	"include": ["**/*.test.ts", "../../../types/index.d.ts"]
+}
diff --git a/packages/kit/test/types/error.test.ts b/packages/kit/test/types/error.test.ts
new file mode 100644
index 000000000000..8724a3cf1888
--- /dev/null
+++ b/packages/kit/test/types/error.test.ts
@@ -0,0 +1,48 @@
+import { error, type HandleClientError, type HandleServerError } from '@sveltejs/kit';
+
+const app_error: App.Error = { status: 500, message: 'Unexpected error' };
+
+// @ts-expect-error App.Error requires status
+const app_error_without_status: App.Error = { message: 'Unexpected error' };
+
+const handle_error_hooks: [HandleServerError, HandleClientError] = [
+	() => ({ message: 'Unexpected error' }),
+	() => ({ message: 'Unexpected error' })
+];
+
+void app_error;
+void app_error_without_status;
+void handle_error_hooks;
+
+function a() {
+	error(400, 'Bad request');
+}
+
+function b() {
+	error(400, { message: 'Bad request' });
+}
+
+function c() {
+	// @ts-expect-error
+	error(400, 'Bad request', { cause: new Error('cause') });
+}
+
+function d() {
+	error(400, { message: 'Bad request' });
+}
+
+function e() {
+	// @ts-expect-error
+	error(400, { message: 'Bad request', cause: new Error('cause') });
+}
+
+function f() {
+	error(400);
+}
+
+a;
+b;
+c;
+d;
+e;
+f;
diff --git a/packages/kit/test/types/tsconfig.json b/packages/kit/test/types/tsconfig.json
index 7675e28d941c..9773e7d707f1 100644
--- a/packages/kit/test/types/tsconfig.json
+++ b/packages/kit/test/types/tsconfig.json
@@ -3,5 +3,6 @@
 	"compilerOptions": {
 		"noEmit": true
 	},
-	"include": ["**/*.test.ts", "../../src/types/*.d.ts"]
+	"include": ["**/*.test.ts", "../../src/types/*.d.ts"],
+	"exclude": ["../../**/write_types/test/**", "./app-error-enhanced/**"]
 }
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 268810bf4cba..1902df39894d 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -8,6 +8,8 @@ declare module '@sveltejs/kit' {
 	// @ts-ignore this is an optional peer dependency so could be missing. Written like this so dts-buddy preserves the ts-ignore
 	type Span = import('@opentelemetry/api').Span;
 
+	type AppErrorWithOptionalStatus = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
+
 	/**
 	 * [Adapters](https://svelte.dev/docs/kit/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
 	 */
@@ -932,7 +934,7 @@ declare module '@sveltejs/kit' {
 		event: RequestEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | (App.Error & { status?: number })>;
+	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
 
 	/**
 	 * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -955,7 +957,7 @@ declare module '@sveltejs/kit' {
 		event: NavigationEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | (App.Error & { status?: number })>;
+	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
 
 	/**
 	 * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
@@ -2863,20 +2865,48 @@ declare module '@sveltejs/kit' {
 	 * @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: number, body: App.Error): never;
+	export function error(status: number, body: Omit<App.Error, "status"> & {
+		status?: App.Error["status"];
+	}): never;
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * 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.
 	 * @param 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 body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
 	 * @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: number, body?: {
+	export function error(status: {
+		status: number;
+		message: string;
+	} extends App.Error ? number : never): never;
+	/**
+	 * Throws an error with a HTTP status code and an optional message.
+	 * 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.
+	 * @param 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 body The error message.
+	 * @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: {
+		status: number;
 		message: string;
-	} extends App.Error ? App.Error | string | undefined : never): never;
+	} extends App.Error ? number : never, body: string): never;
+	/**
+	 * Throws an error with a HTTP status code and an optional message.
+	 * 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.
+	 * @param 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 body The error message.
+	 * @param properties Additional properties of the App.Error type.
+	 * @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: number, body: string, properties: Omit<App.Error, "status" | "message">): never;
 	/**
 	 * Checks whether this is an error thrown by {@link error}.
 	 * @param status The status to filter for.
@@ -3800,6 +3830,7 @@ declare namespace App {
 	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Unexpected errors are handled by the `handleError` hooks which should return this shape.
 	 */
 	export interface Error {
+		status: number;
 		message: string;
 	}
 

From 7003c3ab3274acc01d4a5a263f4ec5f70c6f08fa Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 17:33:25 +0200
Subject: [PATCH 08/24] fix tests

---
 packages/kit/test/apps/basics/test/server.test.js | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/kit/test/apps/basics/test/server.test.js b/packages/kit/test/apps/basics/test/server.test.js
index 19cc4e737a00..ed77aee3c12a 100644
--- a/packages/kit/test/apps/basics/test/server.test.js
+++ b/packages/kit/test/apps/basics/test/server.test.js
@@ -576,7 +576,8 @@ test.describe('Errors', () => {
 
 			expect(res.status()).toBe(401);
 			expect(await res.json()).toEqual({
-				message: 'You shall not pass'
+				message: 'You shall not pass',
+				status: 401
 			});
 		}
 	});
@@ -610,7 +611,8 @@ test.describe('Errors', () => {
 			error: {
 				message: process.env.DEV
 					? 'POST method not allowed. No form actions exist for the page at /errors/missing-actions (405 Method Not Allowed)'
-					: 'POST method not allowed. No form actions exist for this page (405 Method Not Allowed)'
+					: 'POST method not allowed. No form actions exist for this page (405 Method Not Allowed)',
+				status: 405
 			}
 		});
 	});
@@ -641,7 +643,8 @@ test.describe('Errors', () => {
 			expect(error.stack).toBe(undefined);
 			expect(res.status()).toBe(500);
 			expect(error).toEqual({
-				message: 'Error in handle (500 Internal Error)'
+				message: 'Error in handle (500 Internal Error)',
+				status: 500
 			});
 		}
 	});
@@ -672,7 +675,8 @@ test.describe('Errors', () => {
 			expect(error.stack).toBe(undefined);
 			expect(res.status()).toBe(500);
 			expect(error).toEqual({
-				message: 'Expected error in handle'
+				message: 'Expected error in handle',
+				status: 500
 			});
 		}
 	});

From e67120f38f5d831344ea5020cd07a2467af9e52a Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 17:34:05 +0200
Subject: [PATCH 09/24] regenerate

---
 packages/kit/types/index.d.ts | 22 ++++++----------------
 1 file changed, 6 insertions(+), 16 deletions(-)

diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 1902df39894d..95a1f233ce24 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -2868,19 +2868,6 @@ declare module '@sveltejs/kit' {
 	export function error(status: number, body: Omit<App.Error, "status"> & {
 		status?: App.Error["status"];
 	}): never;
-	/**
-	 * Throws an error with a HTTP status code and an optional message.
-	 * 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.
-	 * @param 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.
-	 * @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: {
-		status: number;
-		message: string;
-	} extends App.Error ? number : never): never;
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * When called during request handling, this will cause SvelteKit to
@@ -2891,10 +2878,10 @@ declare module '@sveltejs/kit' {
 	 * @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: {
+	export function error(status: number, body: {
 		status: number;
 		message: string;
-	} extends App.Error ? number : never, body: string): never;
+	} extends App.Error ? string | void | undefined : never): never;
 	/**
 	 * Throws an error with a HTTP status code and an optional message.
 	 * When called during request handling, this will cause SvelteKit to
@@ -2906,7 +2893,10 @@ declare module '@sveltejs/kit' {
 	 * @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: number, body: string, properties: Omit<App.Error, "status" | "message">): never;
+	export function error(status: number, body: string, properties: {
+		status: number;
+		message: string;
+	} extends App.Error ? never : Omit<App.Error, "status" | "message">): never;
 	/**
 	 * Checks whether this is an error thrown by {@link error}.
 	 * @param status The status to filter for.

From 60cd9751bbf6af99d813733f5a2deddc76a27c62 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 21:40:27 +0200
Subject: [PATCH 10/24] handleValidationError

---
 packages/kit/src/exports/public.d.ts                 |  2 +-
 packages/kit/src/runtime/app/server/remote/shared.js | 12 +++++-------
 packages/kit/src/runtime/server/index.js             |  2 +-
 packages/kit/types/index.d.ts                        |  2 +-
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 1e356d4fc609..d2a8955cd3ec 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -969,7 +969,7 @@ export type HandleServerError = (input: {
  * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
  */
 export type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
-	(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<App.Error>;
+	(input: { issues: Issue[]; event: RequestEvent }) => AppErrorWithOptionalStatus;
 
 /**
  * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while navigating.
diff --git a/packages/kit/src/runtime/app/server/remote/shared.js b/packages/kit/src/runtime/app/server/remote/shared.js
index b15fabe46134..28be4f400fe1 100644
--- a/packages/kit/src/runtime/app/server/remote/shared.js
+++ b/packages/kit/src/runtime/app/server/remote/shared.js
@@ -35,13 +35,11 @@ export function create_validator(validate_or_fn, maybe_fn) {
 
 			// if the `issues` field exists, the validation failed
 			if (result.issues) {
-				error(
-					400,
-					await state.handleValidationError({
-						issues: result.issues,
-						event
-					})
-				);
+				const body = await state.handleValidationError({
+					issues: result.issues,
+					event
+				});
+				error(body.status ?? 400, body);
 			}
 
 			return result.value;
diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index cf6b41074987..f39b28112742 100644
--- a/packages/kit/src/runtime/server/index.js
+++ b/packages/kit/src/runtime/server/index.js
@@ -144,7 +144,7 @@ export class Server {
 						handleError: ({ error }) => console.error(error),
 						handleFetch: ({ request, fetch }) => fetch(request),
 						handleValidationError: () => {
-							return { message: 'Bad Request', status: 400 };
+							return { message: 'Bad Request' };
 						},
 						reroute: noop,
 						transport: {}
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 95a1f233ce24..cb791b1dec7f 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -942,7 +942,7 @@ declare module '@sveltejs/kit' {
 	 * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
 	 */
 	export type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
-		(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<App.Error>;
+		(input: { issues: Issue[]; event: RequestEvent }) => AppErrorWithOptionalStatus;
 
 	/**
 	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while navigating.

From 04c3ca9fbf717e54d9e1722c98ee36a408b8a10d Mon Sep 17 00:00:00 2001
From: "vercel[bot]" <35613825+vercel[bot]@users.noreply.github.com>
Date: Mon, 29 Jun 2026 19:53:53 +0000
Subject: [PATCH 11/24] Fix: `HandleValidationError` return type dropped its
 `MaybePromise` wrapper, so async `handleValidationError` hooks no longer
 type-check even though the runtime awaits the result.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit fixes the issue reported at packages/kit/src/exports/public.d.ts:972

## Bug

In commit `60cd975`, the `HandleValidationError` type in `packages/kit/src/exports/public.d.ts` was changed:

```ts
- (input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<App.Error>;
+ (input: { issues: Issue[]; event: RequestEvent }) => AppErrorWithOptionalStatus;
```

The switch from `App.Error` to `AppErrorWithOptionalStatus` is intentional (status is now optional — the runtime does `error(body.status ?? 400, body)`). But dropping the `MaybePromise` wrapper is a regression.

### Why it's a bug / failure mode

The runtime explicitly awaits the hook result in `packages/kit/src/runtime/app/server/remote/shared.js`:

```js
const body = await state.handleValidationError({ issues: result.issues, event });
error(body.status ?? 400, body);
```

So returning a `Promise` works at runtime. With the type no longer permitting a `Promise`, a user with an async hook gets a TypeScript error:

```ts
export async function handleValidationError({ issues }) {
  return { message: await translate(issues[0].message) };
}
```

This is inconsistent with the sibling hooks `HandleServerError` / `HandleClientError`, which use `MaybePromise<void | AppErrorWithOptionalStatus>`, and the type had been `MaybePromise<App.Error>` since its introduction.

## Fix

Restore the `MaybePromise` wrapper:

```ts
(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
```

Applied to both `packages/kit/src/exports/public.d.ts` (line 972) and the generated `packages/kit/types/index.d.ts` (line 945) to keep them in sync. `MaybePromise` is already imported/in scope in both files (used by the sibling hooks).

Co-authored-by: Vercel <vercel[bot]@users.noreply.github.com>
Co-authored-by: dummdidumm <sholthausen@web.de>
---
 packages/kit/src/exports/public.d.ts | 2 +-
 packages/kit/types/index.d.ts        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index d2a8955cd3ec..9320d47d8b29 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -969,7 +969,7 @@ export type HandleServerError = (input: {
  * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
  */
 export type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
-	(input: { issues: Issue[]; event: RequestEvent }) => AppErrorWithOptionalStatus;
+	(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
 
 /**
  * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while navigating.
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index cb791b1dec7f..72ab5a590e6c 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -942,7 +942,7 @@ declare module '@sveltejs/kit' {
 	 * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
 	 */
 	export type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
-		(input: { issues: Issue[]; event: RequestEvent }) => AppErrorWithOptionalStatus;
+		(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
 
 	/**
 	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while navigating.

From c75db89d0e9ace354a864f07d5b552ea42e47785 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 22:09:19 +0200
Subject: [PATCH 12/24] simplify

---
 packages/kit/src/runtime/client/client.js     | 27 +++++++++----------
 packages/kit/src/runtime/server/data/index.js |  6 ++---
 .../kit/src/runtime/server/page/actions.js    |  6 ++---
 packages/kit/src/runtime/server/page/index.js |  2 +-
 .../kit/src/runtime/server/page/render.js     |  3 +--
 .../runtime/server/page/respond_with_error.js |  5 ++--
 packages/kit/src/runtime/server/remote.js     |  8 +++---
 packages/kit/src/runtime/server/utils.js      |  6 ++---
 8 files changed, 29 insertions(+), 34 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 7804e74aa12b..af98d2752803 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -714,7 +714,7 @@ async function initialize(result, target, hydrate) {
 		transformError: __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__
 			? /** @param {unknown} e */ async (e) => {
 					const error = await handle_error(e, current.nav);
-					rendering_error = { error, status: get_status(error, e) };
+					rendering_error = { error, status: error.status };
 					page.error = error;
 					page.status = rendering_error.status;
 					return error;
@@ -1246,8 +1246,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 				server_data = await load_data(url, invalid_server_nodes);
 			} catch (error) {
 				const handled_error = await handle_error(error, { url, params, route: { id } });
-
-				const status = get_status(handled_error, error);
+				const status = handled_error.status;
 
 				if (preload && preload_tokens.has(preload)) {
 					return preload_error({ error: handled_error, status, url, params, route });
@@ -1344,7 +1343,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					const error = await handle_error(err, { params, url, route: { id: route.id } });
 					return preload_error({
 						error,
-						status: get_status(error, err),
+						status: error.status,
 						url,
 						params,
 						route
@@ -1360,11 +1359,10 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					// this is the server error rethrown above, reconstruct but don't invoke
 					// the client error handler; it should've already been handled on the server
 					error = /** @type {import('types').ServerErrorNode} */ (err).error;
-					status =
-						/** @type {import('types').ServerErrorNode} */ (err).status ?? get_status(error, err);
+					status = /** @type {import('types').ServerErrorNode} */ (err).status ?? error.status;
 				} else if (err instanceof HttpError) {
 					error = err.body;
-					status = err.status;
+					status = error.status;
 				} else {
 					// Referenced node could have been removed due to redeploy, check
 					const updated = await stores.updated.check();
@@ -1375,7 +1373,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					}
 
 					error = await handle_error(err, { params, url, route: { id: route.id } });
-					status = get_status(error, err);
+					status = error.status;
 				}
 
 				const error_load = await load_nearest_error_page(i, branch, errors);
@@ -1532,7 +1530,7 @@ async function load_root_error_page({ status, error, url, route }) {
 			.replace(/&/g, '&amp;')
 			.replace(/</g, '&lt;')
 			.replace(/>/g, '&gt;');
-		const html = error_template({ status: get_status(handled, error), message });
+		const html = error_template({ status: handled.status, message });
 		const parsed = new DOMParser().parseFromString(html, 'text/html');
 		document.documentElement.replaceChild(document.adoptNode(parsed.head), document.head);
 		document.documentElement.replaceChild(document.adoptNode(parsed.body), document.body);
@@ -2230,9 +2228,9 @@ function setup_preload() {
 /**
  * @param {unknown} error
  * @param {import('@sveltejs/kit').NavigationEvent} event
- * @returns {import('types').MaybePromise<App.Error>}
+ * @returns {Promise<App.Error>}
  */
-function handle_error(error, event) {
+async function handle_error(error, event) {
 	if (error instanceof HttpError) {
 		return error.body;
 	}
@@ -2244,10 +2242,9 @@ function handle_error(error, event) {
 
 	const status = get_status(error);
 	const message = get_message(error);
+	const app_error = (await app.hooks.handleError({ error, event, status, message })) ?? { message };
 
-	return (
-		app.hooks.handleError({ error, event, status, message }) ?? /** @type {any} */ ({ message })
-	);
+	return { ...app_error, status: get_status(app_error, error) };
 }
 
 /**
@@ -3121,7 +3118,7 @@ async function _hydrate(
 		const handled_error = await handle_error(error, { url, params, route });
 
 		result = await load_root_error_page({
-			status: get_status(handled_error, error),
+			status: handled_error.status,
 			error: handled_error,
 			url,
 			route
diff --git a/packages/kit/src/runtime/server/data/index.js b/packages/kit/src/runtime/server/data/index.js
index 9cf6d2047ff5..c054af138123 100644
--- a/packages/kit/src/runtime/server/data/index.js
+++ b/packages/kit/src/runtime/server/data/index.js
@@ -1,6 +1,6 @@
 import { text } from '@sveltejs/kit';
 import { Redirect } from '@sveltejs/kit/internal';
-import { normalize_error, get_status } from '../../../utils/error.js';
+import { normalize_error } from '../../../utils/error.js';
 import { once } from '../../../utils/functions.js';
 import { server_data_serializer_json } from '../page/data_serializer.js';
 import { load_server_data } from '../page/load_data.js';
@@ -112,7 +112,7 @@ export async function render_data(
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
 						error: transformed,
-						status: get_status(transformed, error)
+						status: transformed.status
 					});
 				})
 			)
@@ -156,7 +156,7 @@ export async function render_data(
 			return redirect_json_response(error);
 		} else {
 			const transformed = await handle_error_and_jsonify(event, event_state, options, error);
-			return json_response(transformed, get_status(transformed, error));
+			return json_response(transformed, transformed.status);
 		}
 	}
 }
diff --git a/packages/kit/src/runtime/server/page/actions.js b/packages/kit/src/runtime/server/page/actions.js
index 7d76fba8149d..a6e2a7c898fa 100644
--- a/packages/kit/src/runtime/server/page/actions.js
+++ b/packages/kit/src/runtime/server/page/actions.js
@@ -5,7 +5,7 @@ import { DEV } from 'esm-env';
 import { json } from '@sveltejs/kit';
 import { HttpError, Redirect, ActionFailure, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
-import { get_status, normalize_error } from '../../../utils/error.js';
+import { normalize_error } from '../../../utils/error.js';
 import { is_form_content_type, negotiate } from '../../../utils/http.js';
 import { create_replacer, handle_error_and_jsonify } from '../utils.js';
 import { record_span } from '../../telemetry/record_span.js';
@@ -44,7 +44,7 @@ export async function handle_action_json_request(event, event_state, options, se
 				error
 			},
 			{
-				status: get_status(error, no_actions_error),
+				status: error.status,
 				headers: {
 					// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
 					// "The server must generate an Allow header field in a 405 status code response"
@@ -108,7 +108,7 @@ export async function handle_action_json_request(event, event_state, options, se
 				error: transformed
 			},
 			{
-				status: get_status(transformed, err)
+				status: transformed.status
 			}
 		);
 	}
diff --git a/packages/kit/src/runtime/server/page/index.js b/packages/kit/src/runtime/server/page/index.js
index 9614e68d569a..75fd176df282 100644
--- a/packages/kit/src/runtime/server/page/index.js
+++ b/packages/kit/src/runtime/server/page/index.js
@@ -283,7 +283,7 @@ export async function render_page(
 					}
 
 					const error = await handle_error_and_jsonify(event, event_state, options, err);
-					const status = get_status(error, err);
+					const status = error.status;
 
 					while (i--) {
 						if (page.errors[i]) {
diff --git a/packages/kit/src/runtime/server/page/render.js b/packages/kit/src/runtime/server/page/render.js
index d6ed05e723bf..4a6f55820e55 100644
--- a/packages/kit/src/runtime/server/page/render.js
+++ b/packages/kit/src/runtime/server/page/render.js
@@ -20,7 +20,6 @@ import {
 	get_global_name,
 	handle_error_and_jsonify
 } from '../utils.js';
-import { get_status } from '../../../utils/error.js';
 import * as env from '__sveltekit/env';
 import { collect_remote_data } from '../remote.js';
 
@@ -205,7 +204,7 @@ export async function render_response({
 
 						const transformed = await handle_error_and_jsonify(event, event_state, options, e);
 						props.page.error = props.error = error = transformed;
-						props.page.status = status = get_status(transformed, e);
+						props.page.status = status = transformed.status;
 						return transformed;
 					}
 				: undefined
diff --git a/packages/kit/src/runtime/server/page/respond_with_error.js b/packages/kit/src/runtime/server/page/respond_with_error.js
index 023ce4cf843d..11ba629ed67e 100644
--- a/packages/kit/src/runtime/server/page/respond_with_error.js
+++ b/packages/kit/src/runtime/server/page/respond_with_error.js
@@ -2,7 +2,6 @@ import { Redirect } from '@sveltejs/kit/internal';
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
 import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
-import { get_status } from '../../../utils/error.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
 
@@ -100,7 +99,7 @@ export async function respond_with_error({
 				ssr,
 				csr
 			},
-			status: get_status(transformed, error),
+			status: transformed.status,
 			error: transformed,
 			branch,
 			error_components: [],
@@ -119,6 +118,6 @@ export async function respond_with_error({
 
 		const transformed = await handle_error_and_jsonify(event, event_state, options, e);
 
-		return static_error_page(options, get_status(transformed, e), transformed.message);
+		return static_error_page(options, transformed.status, transformed.message);
 	}
 }
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 1a16c6e6d835..f52ae04cbf8d 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -8,7 +8,7 @@ import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
 import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.js';
 import { handle_error_and_jsonify } from './utils.js';
-import { normalize_error, get_status } from '../../utils/error.js';
+import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
@@ -181,7 +181,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 										send(controller, {
 											type: 'error',
 											error: transformed,
-											status: get_status(transformed, error)
+											status: transformed.status
 										});
 									}
 								}
@@ -329,7 +329,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		}
 
 		const transformed = await handle_error_and_jsonify(event, state, options, error);
-		const status = get_status(transformed, error);
+		const status = transformed.status;
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
@@ -365,7 +365,7 @@ export async function collect_remote_data(data, event, state, options) {
 	 */
 	async function convert_error(error) {
 		const transformed = await handle_error_and_jsonify(event, state, options, error);
-		return [get_status(transformed, error), transformed];
+		return [transformed.status, transformed];
 	}
 
 	/** @type {Promise<any>[]} */
diff --git a/packages/kit/src/runtime/server/utils.js b/packages/kit/src/runtime/server/utils.js
index 205adba468f1..994abb7cbef9 100644
--- a/packages/kit/src/runtime/server/utils.js
+++ b/packages/kit/src/runtime/server/utils.js
@@ -76,7 +76,7 @@ export function static_error_page(options, status, message) {
 export async function handle_fatal_error(event, state, options, error) {
 	error = error instanceof HttpError ? error : coalesce_to_error(error);
 	const body = await handle_error_and_jsonify(event, state, options, error);
-	const status = get_status(body, error);
+	const status = body.status;
 
 	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
 	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
@@ -103,7 +103,7 @@ export async function handle_fatal_error(event, state, options, error) {
 export async function handle_error_and_jsonify(event, state, options, error) {
 	if (error instanceof HttpError) {
 		// @ts-expect-error custom user errors may not have a message field if App.Error is overwritten
-		return { message: 'Unknown Error', ...error.body, status: error.status };
+		return { message: 'Unknown Error', ...error.body };
 	}
 
 	if (__SVELTEKIT_DEV__ && typeof error == 'object') {
@@ -117,7 +117,7 @@ export async function handle_error_and_jsonify(event, state, options, error) {
 		options.hooks.handleError({ error, event, status, message })
 	)) ?? { message };
 
-	return { ...body, status: body.status ?? status };
+	return { ...body, status: get_status(body, error) };
 }
 
 /**

From 16f552df699d6e237c1a5bdf72571f848a3b61af Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Mon, 29 Jun 2026 22:31:19 +0200
Subject: [PATCH 13/24] fix

---
 packages/kit/test/apps/basics/src/hooks.server.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index cd15dd823ded..dc20c948692c 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -20,7 +20,6 @@ resolve('/');
 export function error_to_pojo(error) {
 	if (isHttpError(error)) {
 		return {
-			status: error.status,
 			...error.body
 		};
 	}

From 3708328cc851814eabb4d265f80fd3ff7de2963d Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Tue, 30 Jun 2026 14:03:36 +0200
Subject: [PATCH 14/24] unnecessary

---
 packages/kit/src/runtime/app/server/remote/query.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/kit/src/runtime/app/server/remote/query.js b/packages/kit/src/runtime/app/server/remote/query.js
index 8db435048735..3b8f6e45973d 100644
--- a/packages/kit/src/runtime/app/server/remote/query.js
+++ b/packages/kit/src/runtime/app/server/remote/query.js
@@ -14,7 +14,6 @@ import {
 import { noop } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
 import { handle_error_and_jsonify } from '../../../server/utils.js';
-import { get_status } from '../../../../utils/error.js';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -352,7 +351,7 @@ function batch(validate_or_fn, maybe_fn) {
 								return {
 									type: 'error',
 									error: transformed,
-									status: get_status(transformed, error)
+									status: transformed.status
 								};
 							}
 						})

From 737dd829d4a18def59be6c97b282076ddb3ba651 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Tue, 30 Jun 2026 21:24:33 +0200
Subject: [PATCH 15/24] simplify

---
 packages/kit/src/exports/public.d.ts          |  2 ++
 .../src/runtime/app/server/remote/query.js    |  3 +--
 packages/kit/src/runtime/client/client.js     | 20 +++++++------------
 .../remote-functions/query-batch.svelte.js    |  2 +-
 .../query-live/instance.svelte.js             |  2 +-
 .../remote-functions/query/instance.svelte.js |  2 +-
 .../client/remote-functions/shared.svelte.js  | 13 +++++++-----
 packages/kit/src/runtime/server/data/index.js |  3 +--
 packages/kit/src/runtime/server/remote.js     | 16 ++++++---------
 packages/kit/src/types/internal.d.ts          |  6 +-----
 packages/kit/types/index.d.ts                 |  2 ++
 11 files changed, 31 insertions(+), 40 deletions(-)

diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 5785e1b21263..32d6ef1c96dc 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -955,6 +955,7 @@ export type Handle = (input: {
  * Make sure that this function _never_ throws an error.
  *
  * The returned object can include a `status` property to override the HTTP status code used in the response.
+ * If omitted, the status defaults to 500.
  */
 export type HandleServerError = (input: {
 	error: unknown;
@@ -978,6 +979,7 @@ export type HandleValidationError<Issue extends StandardSchemaV1.Issue = Standar
  * Make sure that this function _never_ throws an error.
  *
  * The returned object can include a `status` property to override the HTTP status code used in the response.
+ * If omitted, the status defaults to 500.
  */
 export type HandleClientError = (input: {
 	error: unknown;
diff --git a/packages/kit/src/runtime/app/server/remote/query.js b/packages/kit/src/runtime/app/server/remote/query.js
index 3b8f6e45973d..a50cc53985d4 100644
--- a/packages/kit/src/runtime/app/server/remote/query.js
+++ b/packages/kit/src/runtime/app/server/remote/query.js
@@ -350,8 +350,7 @@ function batch(validate_or_fn, maybe_fn) {
 
 								return {
 									type: 'error',
-									error: transformed,
-									status: transformed.status
+									error: transformed
 								};
 							}
 						})
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index af98d2752803..c929551fc242 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -1154,14 +1154,14 @@ function diff_search_params(old_url, new_url) {
 }
 
 /**
- * @param {Omit<import('./types.js').NavigationFinished['state'], 'branch'> & { error: App.Error; status: number }} opts
+ * @param {Omit<import('./types.js').NavigationFinished['state'], 'branch'> & { error: App.Error }} opts
  * @returns {import('./types.js').NavigationFinished}
  */
-function preload_error({ error, status, url, route, params }) {
+function preload_error({ error, url, route, params }) {
 	// we skipped loading the error page, so we need to use the current page
 	// store, but we still pass the updated status to the preloadData function
 	const new_page = clone_page(page);
-	new_page.status = status;
+	new_page.status = error.status;
 	return {
 		type: 'loaded',
 		state: {
@@ -1249,7 +1249,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 				const status = handled_error.status;
 
 				if (preload && preload_tokens.has(preload)) {
-					return preload_error({ error: handled_error, status, url, params, route });
+					return preload_error({ error: handled_error, url, params, route });
 				}
 
 				return load_root_error_page({
@@ -1296,7 +1296,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 
 		if (server_data_node?.type === 'error') {
 			// rethrow and catch below
-			throw new HttpError(server_data_node.status ?? 500, server_data_node.error);
+			throw new HttpError(server_data_node.error.status, server_data_node.error);
 		}
 
 		return load_node({
@@ -1343,7 +1343,6 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					const error = await handle_error(err, { params, url, route: { id: route.id } });
 					return preload_error({
 						error,
-						status: error.status,
 						url,
 						params,
 						route
@@ -1352,17 +1351,13 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 
 				/** @type {App.Error} */
 				let error;
-				/** @type {number} */
-				let status;
 
 				if (server_data_nodes?.includes(/** @type {import('types').ServerErrorNode} */ (err))) {
 					// this is the server error rethrown above, reconstruct but don't invoke
 					// the client error handler; it should've already been handled on the server
 					error = /** @type {import('types').ServerErrorNode} */ (err).error;
-					status = /** @type {import('types').ServerErrorNode} */ (err).status ?? error.status;
 				} else if (err instanceof HttpError) {
 					error = err.body;
-					status = error.status;
 				} else {
 					// Referenced node could have been removed due to redeploy, check
 					const updated = await stores.updated.check();
@@ -1373,7 +1368,6 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 					}
 
 					error = await handle_error(err, { params, url, route: { id: route.id } });
-					status = error.status;
 				}
 
 				const error_load = await load_nearest_error_page(i, branch, errors);
@@ -1383,12 +1377,12 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 						params,
 						branch: branch.slice(0, error_load.idx).concat(error_load.node),
 						errors,
-						status,
+						status: error.status,
 						error,
 						route
 					});
 				} else {
-					return await server_fallback(url, { id: route.id }, error, status);
+					return await server_fallback(url, { id: route.id }, error, error.status);
 				}
 			}
 		} else {
diff --git a/packages/kit/src/runtime/client/remote-functions/query-batch.svelte.js b/packages/kit/src/runtime/client/remote-functions/query-batch.svelte.js
index e75b93ad95cf..916bfa0d3bbb 100644
--- a/packages/kit/src/runtime/client/remote-functions/query-batch.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/query-batch.svelte.js
@@ -72,7 +72,7 @@ export function query_batch(id) {
 
 							for (const { resolve, reject } of resolvers) {
 								if (result.type === 'error') {
-									reject(new HttpError(result.status, result.error));
+									reject(new HttpError(result.error.status, result.error));
 								} else {
 									resolve(result.data);
 								}
diff --git a/packages/kit/src/runtime/client/remote-functions/query-live/instance.svelte.js b/packages/kit/src/runtime/client/remote-functions/query-live/instance.svelte.js
index 09fab13ef792..39b59f3ba00c 100644
--- a/packages/kit/src/runtime/client/remote-functions/query-live/instance.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/query-live/instance.svelte.js
@@ -91,7 +91,7 @@ export class LiveQuery {
 				// the query failed during SSR — seed the failed state (mirroring `fail()`,
 				// minus its terminal `#done`), so the main loop still connects as usual
 				// and the query can recover
-				const error = new HttpError(node.e[0] ?? 500, node.e[1]);
+				const error = new HttpError(node.e.status, node.e);
 				this.#loading = false;
 				this.#error = error;
 
diff --git a/packages/kit/src/runtime/client/remote-functions/query/instance.svelte.js b/packages/kit/src/runtime/client/remote-functions/query/instance.svelte.js
index 7115a2491d10..34693d9c668d 100644
--- a/packages/kit/src/runtime/client/remote-functions/query/instance.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/query/instance.svelte.js
@@ -70,7 +70,7 @@ export class Query {
 			delete query_responses[key];
 
 			if (node.e) {
-				this.fail(new HttpError(node.e[0] ?? 500, node.e[1]));
+				this.fail(new HttpError(node.e.status, node.e));
 			} else {
 				this.set(/** @type {T} */ (node.v));
 			}
diff --git a/packages/kit/src/runtime/client/remote-functions/shared.svelte.js b/packages/kit/src/runtime/client/remote-functions/shared.svelte.js
index d231b33f249f..6aef3e77c990 100644
--- a/packages/kit/src/runtime/client/remote-functions/shared.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/shared.svelte.js
@@ -86,7 +86,7 @@ export function pin_while_resolving(cache_map, cache, id, payload, then) {
  */
 export function unwrap_node(node) {
 	if (node.e) {
-		throw new HttpError(node.e[0] ?? 500, node.e[1]);
+		throw new HttpError(node.e.status, node.e);
 	}
 
 	return node.v;
@@ -120,13 +120,16 @@ export async function remote_request(url, init) {
 			error: response.statusText
 		}));
 
-		throw new HttpError(result.status ?? response.status ?? 500, result.error);
+		throw new HttpError(
+			result.error?.status ?? result.status ?? response.status ?? 500,
+			result.error
+		);
 	}
 
 	const result = /** @type {RemoteFunctionResponse} */ (await response.json());
 
 	if (result.type === 'error') {
-		throw new HttpError(result.status ?? 500, result.error);
+		throw new HttpError(result.error.status, result.error);
 	}
 
 	const data = /** @type {RemoteFunctionData} */ (
@@ -142,7 +145,7 @@ export async function remote_request(url, init) {
 	function refresh(key, entry, result) {
 		if (entry?.resource) {
 			if (result.e) {
-				entry.resource.fail(new HttpError(result.e[0] ?? 500, result.e[1]));
+				entry.resource.fail(new HttpError(result.e.status, result.e));
 			} else {
 				entry.resource.set(result.v);
 			}
@@ -196,7 +199,7 @@ export async function handle_side_channel_response(response) {
 	}
 
 	if (response.type === 'error') {
-		throw new HttpError(response.status ?? 500, response.error);
+		throw new HttpError(response.error.status, response.error);
 	}
 
 	return response;
diff --git a/packages/kit/src/runtime/server/data/index.js b/packages/kit/src/runtime/server/data/index.js
index c054af138123..86bdea376167 100644
--- a/packages/kit/src/runtime/server/data/index.js
+++ b/packages/kit/src/runtime/server/data/index.js
@@ -111,8 +111,7 @@ export async function render_data(
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
-						error: transformed,
-						status: transformed.status
+						error: transformed
 					});
 				})
 			)
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index f52ae04cbf8d..afd66d5843f7 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -180,8 +180,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 										send(controller, {
 											type: 'error',
-											error: transformed,
-											status: transformed.status
+											error: transformed
 										});
 									}
 								}
@@ -329,18 +328,16 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		}
 
 		const transformed = await handle_error_and_jsonify(event, state, options, error);
-		const status = transformed.status;
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
-				error: transformed,
-				status
+				error: transformed
 			}),
 			{
 				// By setting a non-200 during prerendering we fail the prerender process (unless handleHttpError handles it).
 				// Errors at runtime will be passed to the client and are handled there
-				status: state.prerendering ? status : undefined,
+				status: state.prerendering ? transformed.status : undefined,
 				headers: {
 					'cache-control': 'private, no-store'
 				}
@@ -361,11 +358,10 @@ export async function collect_remote_data(data, event, state, options) {
 	/**
 	 *
 	 * @param {unknown} error
-	 * @returns {Promise<[status: number, error: App.Error]>}
+	 * @returns {Promise<App.Error>}
 	 */
-	async function convert_error(error) {
-		const transformed = await handle_error_and_jsonify(event, state, options, error);
-		return [transformed.status, transformed];
+	function convert_error(error) {
+		return handle_error_and_jsonify(event, state, options, error);
 	}
 
 	/** @type {Promise<any>[]} */
diff --git a/packages/kit/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index d7e7831dd6cb..2168e93de0a4 100644
--- a/packages/kit/src/types/internal.d.ts
+++ b/packages/kit/src/types/internal.d.ts
@@ -310,7 +310,7 @@ export type RemoteFunctionDataNode = {
 	/** value */
 	v?: any;
 	/** error */
-	e?: [status: number, error: any];
+	e?: App.Error;
 };
 
 export type RemoteFunctionData = {
@@ -391,10 +391,6 @@ export interface ServerDataSkippedNode {
 export interface ServerErrorNode {
 	type: 'error';
 	error: App.Error;
-	/**
-	 * Only set for HttpErrors, or when overridden by `handleError`.
-	 */
-	status?: number;
 }
 
 export interface ServerMetadataRoute {
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 6f082160f346..e940b103b2aa 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -928,6 +928,7 @@ declare module '@sveltejs/kit' {
 	 * Make sure that this function _never_ throws an error.
 	 *
 	 * The returned object can include a `status` property to override the HTTP status code used in the response.
+	 * If omitted, the status defaults to 500.
 	 */
 	export type HandleServerError = (input: {
 		error: unknown;
@@ -951,6 +952,7 @@ declare module '@sveltejs/kit' {
 	 * Make sure that this function _never_ throws an error.
 	 *
 	 * The returned object can include a `status` property to override the HTTP status code used in the response.
+	 * If omitted, the status defaults to 500.
 	 */
 	export type HandleClientError = (input: {
 		error: unknown;

From 231d11e1b92d8b633ce717279222fbfd7e6fc4ba Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Jul 2026 10:37:50 -0400
Subject: [PATCH 16/24] another

---
 packages/kit/src/runtime/client/client.js | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index c929551fc242..32dd65500a10 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -1382,7 +1382,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 						route
 					});
 				} else {
-					return await server_fallback(url, { id: route.id }, error, error.status);
+					return await server_fallback(url, { id: route.id }, error);
 				}
 			}
 		} else {
@@ -1790,7 +1790,6 @@ async function navigate({
 							route: { id: null }
 						}
 					),
-					404,
 					replace_state
 				);
 			} else {
@@ -1805,7 +1804,6 @@ async function navigate({
 					params: {},
 					route: { id: null }
 				}),
-				404,
 				replace_state
 			);
 		}
@@ -2067,23 +2065,22 @@ async function navigate({
  * @param {URL} url
  * @param {{ id: string | null }} route
  * @param {App.Error} error
- * @param {number} status
  * @param {boolean} [replace_state]
  * @returns {Promise<import('./types.js').NavigationFinished | undefined>}
  */
-async function server_fallback(url, route, error, status, replace_state) {
+async function server_fallback(url, route, error, replace_state) {
 	if (url.origin === origin && url.pathname === location.pathname && !hydrated) {
 		// We would reload the same page we're currently on, which isn't hydrated,
 		// which means no SSR, which means we would end up in an endless loop
 		return await load_root_error_page({
-			status,
+			status: error.status,
 			error,
 			url,
 			route
 		});
 	}
 
-	if (DEV && status !== 404) {
+	if (DEV && error.status !== 404) {
 		console.error(
 			'An error occurred while loading the page. This will cause a full page reload. (This message will only appear during development.)'
 		);

From c34b08484776856456f97926ec9e71fc18f60780 Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Jul 2026 10:39:15 -0400
Subject: [PATCH 17/24] another

---
 packages/kit/src/runtime/client/client.js | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 32dd65500a10..70408ebb0c5e 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -1246,14 +1246,12 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 				server_data = await load_data(url, invalid_server_nodes);
 			} catch (error) {
 				const handled_error = await handle_error(error, { url, params, route: { id } });
-				const status = handled_error.status;
 
 				if (preload && preload_tokens.has(preload)) {
 					return preload_error({ error: handled_error, url, params, route });
 				}
 
 				return load_root_error_page({
-					status,
 					error: handled_error,
 					url,
 					route
@@ -1436,14 +1434,13 @@ async function load_nearest_error_page(i, branch, errors) {
 
 /**
  * @param {{
- *   status: number;
  *   error: App.Error;
  *   url: URL;
  *   route: { id: string | null }
  * }} opts
  * @returns {Promise<import('./types.js').NavigationFinished | undefined>} returns `undefined` in case of a redirect
  */
-async function load_root_error_page({ status, error, url, route }) {
+async function load_root_error_page({ error, url, route }) {
 	/** @type {Record<string, string>} */
 	const params = {}; // error page does not have params
 
@@ -1504,7 +1501,7 @@ async function load_root_error_page({ status, error, url, route }) {
 			url,
 			params,
 			branch: [root_layout, root_error],
-			status,
+			status: error.status,
 			error,
 			errors: [],
 			route: null
@@ -1841,7 +1838,6 @@ async function navigate({
 		}
 
 		navigation_result = await load_root_error_page({
-			status: 500,
 			error: await handle_error(new Error('Redirect loop'), {
 				url,
 				params: {},
@@ -2073,7 +2069,6 @@ async function server_fallback(url, route, error, replace_state) {
 		// We would reload the same page we're currently on, which isn't hydrated,
 		// which means no SSR, which means we would end up in an endless loop
 		return await load_root_error_page({
-			status: error.status,
 			error,
 			url,
 			route
@@ -3109,7 +3104,6 @@ async function _hydrate(
 		const handled_error = await handle_error(error, { url, params, route });
 
 		result = await load_root_error_page({
-			status: handled_error.status,
 			error: handled_error,
 			url,
 			route

From 9b8da37717dda1dcc1c4f3f6dea4ac4b54049d7e Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Jul 2026 11:10:15 -0400
Subject: [PATCH 18/24] bit more

---
 packages/kit/src/runtime/client/client.js           | 13 ++++---------
 .../runtime/client/remote-functions/form.svelte.js  |  3 +--
 packages/kit/src/runtime/client/types.d.ts          |  3 ++-
 packages/kit/src/runtime/server/page/render.js      |  2 +-
 4 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 70408ebb0c5e..a8d7dd909490 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -754,7 +754,7 @@ async function initialize(result, target, hydrate) {
  *   params: Record<string, string>;
  *   branch: Array<import('./types.js').BranchNode | undefined>;
  *   errors?: Array<import('types').CSRPageNodeLoader | undefined>;
- *   status: number;
+ *   status?: number;
  *   error: App.Error | null;
  *   route: import('types').CSRRoute | null;
  *   form?: Record<string, any> | null;
@@ -871,7 +871,7 @@ async function get_navigation_result_from_branch({
 				id: route?.id ?? null
 			},
 			state: {},
-			status,
+			status: status ?? error?.status ?? 200,
 			url: new URL(url),
 			form: form ?? null,
 			// The whole page store is updated, but this way the object reference stays the same
@@ -1375,7 +1375,6 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 						params,
 						branch: branch.slice(0, error_load.idx).concat(error_load.node),
 						errors,
-						status: error.status,
 						error,
 						route
 					});
@@ -1395,7 +1394,6 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 		params,
 		branch,
 		errors,
-		status: 200,
 		error: null,
 		route,
 		// Reset `form` on navigation, but not invalidation
@@ -1501,7 +1499,6 @@ async function load_root_error_page({ error, url, route }) {
 			url,
 			params,
 			branch: [root_layout, root_error],
-			status: error.status,
 			error,
 			errors: [],
 			route: null
@@ -2617,7 +2614,7 @@ export async function applyAction(result) {
 	}
 
 	if (result.type === 'error') {
-		await set_nearest_error_page(result.error, result.status);
+		await set_nearest_error_page(result.error);
 	} else if (result.type === 'redirect') {
 		await _goto(result.location, { invalidateAll: true }, 0);
 	} else {
@@ -2644,9 +2641,8 @@ export async function applyAction(result) {
 
 /**
  * @param {App.Error} error
- * @param {number} status
  */
-export async function set_nearest_error_page(error, status = 500) {
+export async function set_nearest_error_page(error) {
 	const url = new URL(location.href);
 
 	const { branch, route } = current;
@@ -2658,7 +2654,6 @@ export async function set_nearest_error_page(error, status = 500) {
 			url,
 			params: current.params,
 			branch: branch.slice(0, error_load.idx).concat(error_load.node),
-			status,
 			error,
 			// do not set errors, we haven't changed the page so the previous ones are still current
 			route
diff --git a/packages/kit/src/runtime/client/remote-functions/form.svelte.js b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
index e4cf41584bf0..2ee7c3519ded 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -431,8 +431,7 @@ export function form(id) {
 						e instanceof HttpError
 							? e.body
 							: { message: /** @type {any} */ (e).message, status: 500 };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+					void set_nearest_error_page(error);
 				} finally {
 					pending_count--;
 				}
diff --git a/packages/kit/src/runtime/client/types.d.ts b/packages/kit/src/runtime/client/types.d.ts
index 209fdc2b57fd..eda85fadaa30 100644
--- a/packages/kit/src/runtime/client/types.d.ts
+++ b/packages/kit/src/runtime/client/types.d.ts
@@ -126,7 +126,8 @@ export interface NavigationState {
 }
 
 export interface HydrateOptions {
-	status: number;
+	/** Provided in the case of a form action that returns `fail`, but otherwise derived from `error` */
+	status?: number;
 	error: App.Error | null;
 	node_ids: number[];
 	params: Record<string, string>;
diff --git a/packages/kit/src/runtime/server/page/render.js b/packages/kit/src/runtime/server/page/render.js
index 4a6f55820e55..424f279d0fb9 100644
--- a/packages/kit/src/runtime/server/page/render.js
+++ b/packages/kit/src/runtime/server/page/render.js
@@ -505,7 +505,7 @@ export async function render_response({
 				`error: ${serialized.error}`
 			];
 
-			if (status !== 200) {
+			if (status !== 200 && !error) {
 				hydrate.push(`status: ${status}`);
 			}
 

From 6134aa053941512de10d7fa3bbc126f3f5e3dbd1 Mon Sep 17 00:00:00 2001
From: "vercel[bot]" <35613825+vercel[bot]@users.noreply.github.com>
Date: Wed, 1 Jul 2026 15:28:24 +0000
Subject: [PATCH 19/24] Fix: Hydrating an SSR'd error page yields `page.status
 === 200` instead of the real error status (e.g. 404/500) because `_hydrate`
 defaults `status` to `200`, defeating the `error?.status` fallback.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit fixes the issue reported at packages/kit/src/runtime/client/client.js:3013

## Bug

After commit `9b8da37`, `status` became derivable from `error.status`:

- `get_navigation_result_from_branch` (client.js:874) computes `status: status ?? error?.status ?? 200`.
- The server (render.js:508) only serializes `status` into the hydrate options when there is **no** error:
  ```js
  if (status !== 200 && !error) {
    hydrate.push(`status: ${status}`);
  }
  ```
  So for an SSR'd error page, `status` is omitted and only `error` (which carries `.status`) is serialized.

However, `_hydrate` (client.js:3013) destructured the options with a default:
```js
{ status = 200, error, ... }
```
When the server omits `status` (the error-page case), `status` defaults to `200`. That `200` is then passed to `get_navigation_result_from_branch` (client.js:3082), where `status ?? error?.status ?? 200` evaluates to `200` (since `200` is not nullish), so `error.status` is never consulted.

**Trigger:** SSR a 404 or 500 error page and hydrate it — `page.status` becomes `200` instead of the actual error status. The other four callers of `get_navigation_result_from_branch` (lines 1373, 1392, 1498, 2653) omit `status` entirely, so their `error?.status` fallback works; only `_hydrate` broke it via the `= 200` default.

## Fix

Removed the `= 200` default in `_hydrate`'s destructuring so `status` is `undefined` when not serialized, allowing the `error?.status` fallback to take effect.

All three paths remain correct:

- **Error page:** `status` omitted → `undefined ?? error.status ?? 200` = `error.status` ✅ (now fixed)
- **Normal page:** `status` omitted, no error → `undefined ?? null?.status ?? 200` = `200` ✅
- **Form `fail`:** `status` serialized, `error` null → serialized status is used ✅

Co-authored-by: Vercel <vercel[bot]@users.noreply.github.com>
Co-authored-by: Rich-Harris <hello@rich-harris.dev>
---
 packages/kit/src/runtime/client/client.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index a8d7dd909490..0a348a72cba4 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -3010,7 +3010,7 @@ function _start_router() {
  */
 async function _hydrate(
 	target,
-	{ status = 200, error, node_ids, params, route, server_route, data: server_data_nodes, form }
+	{ status, error, node_ids, params, route, server_route, data: server_data_nodes, form }
 ) {
 	hydrated = true;
 

From a530dd3b48b813e967252e95cd816fa96610ada3 Mon Sep 17 00:00:00 2001
From: Rich Harris <richard.a.harris@gmail.com>
Date: Wed, 1 Jul 2026 13:28:54 -0400
Subject: [PATCH 20/24] Update packages/kit/src/exports/index.js

---
 packages/kit/src/exports/index.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/kit/src/exports/index.js b/packages/kit/src/exports/index.js
index 03f29d1b5f3e..3cc0e8992d32 100644
--- a/packages/kit/src/exports/index.js
+++ b/packages/kit/src/exports/index.js
@@ -33,6 +33,7 @@ export { VERSION } from '../version.js';
  * @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).
+ * @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
  */
 /**
  * Throws an error with a HTTP status code and an optional message.

From b79730ae354c07a7662f6c2c990c445c02b79a6d Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Jul 2026 13:43:27 -0400
Subject: [PATCH 21/24] gah apparently this falls through? could have sworn it
 worked a moment ago

---
 packages/kit/src/exports/index.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/kit/src/exports/index.js b/packages/kit/src/exports/index.js
index 3cc0e8992d32..03f29d1b5f3e 100644
--- a/packages/kit/src/exports/index.js
+++ b/packages/kit/src/exports/index.js
@@ -33,7 +33,6 @@ export { VERSION } from '../version.js';
  * @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).
- * @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
  */
 /**
  * Throws an error with a HTTP status code and an optional message.

From 4eb034a761e703e6562993f8aa012ce121ef79f4 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Wed, 1 Jul 2026 21:45:08 +0200
Subject: [PATCH 22/24] make sure unexpected errors on form submissions on the
 client are routed through handle_error; narrow the error type

---
 packages/kit/src/exports/public.d.ts               |  2 +-
 packages/kit/src/runtime/app/forms.js              | 11 +++++++++--
 packages/kit/src/runtime/client/client.js          |  2 +-
 .../runtime/client/remote-functions/form.svelte.js | 14 ++++++++++++--
 packages/kit/src/runtime/server/page/actions.js    |  2 ++
 packages/kit/types/index.d.ts                      |  2 +-
 6 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 32d6ef1c96dc..30ac2302aa9c 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -1842,7 +1842,7 @@ export type ActionResult<
 	| { type: 'success'; status: number; data?: Success }
 	| { type: 'failure'; status: number; data?: Failure }
 	| { type: 'redirect'; status: number; location: string }
-	| { type: 'error'; status?: number; error: any };
+	| { type: 'error'; status?: number; error: App.Error };
 
 /**
  * The object returned by the [`error`](https://svelte.dev/docs/kit/@sveltejs-kit#error) function.
diff --git a/packages/kit/src/runtime/app/forms.js b/packages/kit/src/runtime/app/forms.js
index dbc480a686bd..8c65ec79151f 100644
--- a/packages/kit/src/runtime/app/forms.js
+++ b/packages/kit/src/runtime/app/forms.js
@@ -2,7 +2,7 @@ import * as devalue from 'devalue';
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
 import { invalidateAll } from './navigation.js';
-import { app as client_app, applyAction } from '../client/client.js';
+import { app as client_app, applyAction, handle_error } from '../client/client.js';
 import { app as server_app } from '../server/app.js';
 
 export { applyAction };
@@ -201,7 +201,14 @@ export function enhance(form_element, submit = noop) {
 			if (result.type === 'error') result.status = response.status;
 		} catch (error) {
 			if (/** @type {any} */ (error)?.name === 'AbortError') return;
-			result = { type: 'error', error };
+			result = {
+				type: 'error',
+				error: await handle_error(error, {
+					params: {},
+					route: { id: null },
+					url: new URL(location.href)
+				})
+			};
 		}
 
 		await callback({
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 0a348a72cba4..d5ccee91943e 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -2213,7 +2213,7 @@ function setup_preload() {
  * @param {import('@sveltejs/kit').NavigationEvent} event
  * @returns {Promise<App.Error>}
  */
-async function handle_error(error, event) {
+export async function handle_error(error, event) {
 	if (error instanceof HttpError) {
 		return error.body;
 	}
diff --git a/packages/kit/src/runtime/client/remote-functions/form.svelte.js b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
index 2ee7c3519ded..bd0450e5f229 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -4,7 +4,13 @@
 import { app_dir, base } from '$app/paths/internal/client';
 import { DEV } from 'esm-env';
 import { HttpError } from '@sveltejs/kit/internal';
-import { query_responses, _goto, set_nearest_error_page, invalidateAll } from '../client.js';
+import {
+	query_responses,
+	_goto,
+	set_nearest_error_page,
+	invalidateAll,
+	handle_error
+} from '../client.js';
 import { tick } from 'svelte';
 import { categorize_updates, remote_request } from './shared.svelte.js';
 import { createAttachmentKey } from 'svelte/attachments';
@@ -430,7 +436,11 @@ export function form(id) {
 					const error =
 						e instanceof HttpError
 							? e.body
-							: { message: /** @type {any} */ (e).message, status: 500 };
+							: await handle_error(e, {
+									params: {},
+									route: { id: null },
+									url: new URL(location.href)
+								});
 					void set_nearest_error_page(error);
 				} finally {
 					pending_count--;
diff --git a/packages/kit/src/runtime/server/page/actions.js b/packages/kit/src/runtime/server/page/actions.js
index a6e2a7c898fa..8dbd6c09fafb 100644
--- a/packages/kit/src/runtime/server/page/actions.js
+++ b/packages/kit/src/runtime/server/page/actions.js
@@ -167,6 +167,7 @@ export async function handle_action_request(event, event_state, server) {
 		});
 		return {
 			type: 'error',
+			// We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: new SvelteKitError(
 				405,
 				'Method Not Allowed',
@@ -211,6 +212,7 @@ export async function handle_action_request(event, event_state, server) {
 
 		return {
 			type: 'error',
+			// @ts-expect-error We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: check_incorrect_fail_use(err)
 		};
 	}
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index e940b103b2aa..3582653f0590 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -1815,7 +1815,7 @@ declare module '@sveltejs/kit' {
 		| { type: 'success'; status: number; data?: Success }
 		| { type: 'failure'; status: number; data?: Failure }
 		| { type: 'redirect'; status: number; location: string }
-		| { type: 'error'; status?: number; error: any };
+		| { type: 'error'; status?: number; error: App.Error };
 
 	/**
 	 * The object returned by the [`error`](https://svelte.dev/docs/kit/@sveltejs-kit#error) function.

From ae9e34e4486075045225461791bf1b4593246c24 Mon Sep 17 00:00:00 2001
From: Simon Holthausen <simon.holthausen@vercel.com>
Date: Wed, 1 Jul 2026 22:37:36 +0200
Subject: [PATCH 23/24] missed a spot

---
 packages/kit/src/runtime/server/remote.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index afd66d5843f7..88a29c5aa950 100644
--- a/packages/kit/src/runtime/server/remote.js
+++ b/packages/kit/src/runtime/server/remote.js
@@ -515,6 +515,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 		});
 		return {
 			type: 'error',
+			// We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: new SvelteKitError(
 				405,
 				'Method Not Allowed',
@@ -561,6 +562,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 
 		return {
 			type: 'error',
+			// @ts-expect-error We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: check_incorrect_fail_use(err)
 		};
 	}

From 196812d140b7765f0b9856073b7708f910971d5a Mon Sep 17 00:00:00 2001
From: Rich Harris <rich.harris@vercel.com>
Date: Wed, 1 Jul 2026 16:51:50 -0400
Subject: [PATCH 24/24] goddammit

---
 .../apps/basics/src/routes/actions/update-form/+page.svelte     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte b/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
index fd69b8b08794..032ae4039281 100644
--- a/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
+++ b/packages/kit/test/apps/basics/src/routes/actions/update-form/+page.svelte
@@ -13,7 +13,7 @@
 		applyAction({ type: 'redirect', status: 303, location: '/' });
 	}
 	function error() {
-		applyAction({ type: 'error', error: { message: 'Unexpected Form Error' } });
+		applyAction({ type: 'error', error: { status: 400, message: 'Unexpected Form Error' } });
 	}
 </script>