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 81b615e38691..da300b6fb0aa 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('@sveltejs/kit').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/package.json b/packages/kit/package.json
index 18c12e137a3a..2a1e04b1e8fa 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 8cf4f508a63a..30ac2302aa9c 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.
  */
@@ -951,13 +953,16 @@ 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.
+ * If omitted, the status defaults to 500.
  */
 export type HandleServerError = (input: {
 	error: unknown;
 	event: RequestEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | App.Error>;
+}) => 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.
@@ -965,20 +970,23 @@ 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 }) => 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.
  *
  * 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.
+ * If omitted, the status defaults to 500.
  */
 export type HandleClientError = (input: {
 	error: unknown;
 	event: NavigationEvent;
 	status: number;
 	message: string;
-}) => MaybePromise<void | App.Error>;
+}) => 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`.
@@ -1834,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/app/server/remote/query.js b/packages/kit/src/runtime/app/server/remote/query.js
index 998b82d11c46..a50cc53985d4 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 { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -347,13 +346,11 @@ 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
 								};
 							}
 						})
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/client/client.js b/packages/kit/src/runtime/client/client.js
index a0fa77db54a5..d5ccee91943e 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(e) };
+					rendering_error = { error, status: error.status };
 					page.error = error;
 					page.status = rendering_error.status;
 					return error;
@@ -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
@@ -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: {
@@ -1247,14 +1247,11 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 			} catch (error) {
 				const handled_error = await handle_error(error, { url, params, route: { id } });
 
-				const status = get_status(error);
-
 				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({
-					status,
 					error: handled_error,
 					url,
 					route
@@ -1297,7 +1294,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({
@@ -1340,12 +1337,10 @@ 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,
 						url,
 						params,
 						route
@@ -1358,7 +1353,6 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 				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;
 				} else if (err instanceof HttpError) {
 					error = err.body;
@@ -1381,12 +1375,11 @@ 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,
 						route
 					});
 				} else {
-					return await server_fallback(url, { id: route.id }, error, status);
+					return await server_fallback(url, { id: route.id }, error);
 				}
 			}
 		} else {
@@ -1401,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
@@ -1440,14 +1432,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
 
@@ -1508,7 +1499,6 @@ async function load_root_error_page({ status, error, url, route }) {
 			url,
 			params,
 			branch: [root_layout, root_error],
-			status,
 			error,
 			errors: [],
 			route: null
@@ -1528,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: 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);
@@ -1794,7 +1784,6 @@ async function navigate({
 							route: { id: null }
 						}
 					),
-					404,
 					replace_state
 				);
 			} else {
@@ -1809,7 +1798,6 @@ async function navigate({
 					params: {},
 					route: { id: null }
 				}),
-				404,
 				replace_state
 			);
 		}
@@ -1847,7 +1835,6 @@ async function navigate({
 		}
 
 		navigation_result = await load_root_error_page({
-			status: 500,
 			error: await handle_error(new Error('Redirect loop'), {
 				url,
 				params: {},
@@ -2071,23 +2058,21 @@ 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,
 			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.)'
 		);
@@ -2226,9 +2211,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) {
+export async function handle_error(error, event) {
 	if (error instanceof HttpError) {
 		return error.body;
 	}
@@ -2240,10 +2225,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) };
 }
 
 /**
@@ -2630,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 {
@@ -2657,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;
@@ -2671,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
@@ -3028,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;
 
@@ -3114,9 +3096,10 @@ 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 }),
+			error: handled_error,
 			url,
 			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 80c49e42fcdd..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';
@@ -428,9 +434,14 @@ 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 };
-					const status = e instanceof HttpError ? e.status : 500;
-					void set_nearest_error_page(error, status);
+						e instanceof HttpError
+							? e.body
+							: 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/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/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/data/index.js b/packages/kit/src/runtime/server/data/index.js
index ae4e54e419d9..86bdea376167 100644
--- a/packages/kit/src/runtime/server/data/index.js
+++ b/packages/kit/src/runtime/server/data/index.js
@@ -1,5 +1,5 @@
 import { text } from '@sveltejs/kit';
-import { HttpError, SvelteKitError, Redirect } from '@sveltejs/kit/internal';
+import { Redirect } from '@sveltejs/kit/internal';
 import { normalize_error } from '../../../utils/error.js';
 import { once } from '../../../utils/functions.js';
 import { server_data_serializer_json } from '../page/data_serializer.js';
@@ -107,13 +107,11 @@ 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
 					});
 				})
 			)
@@ -156,7 +154,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, transformed.status);
 		}
 	}
 }
diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index 886d8da63a09..f39b28112742 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 || {}
diff --git a/packages/kit/src/runtime/server/page/actions.js b/packages/kit/src/runtime/server/page/actions.js
index bf224e62c93a..8dbd6c09fafb 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';
@@ -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: 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"
@@ -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: transformed.status
 			}
 		);
 	}
@@ -163,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',
@@ -207,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/src/runtime/server/page/index.js b/packages/kit/src/runtime/server/page/index.js
index 22c5e5d03482..75fd176df282 100644
--- a/packages/kit/src/runtime/server/page/index.js
+++ b/packages/kit/src/runtime/server/page/index.js
@@ -282,8 +282,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 = 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 85fc9155336b..424f279d0fb9 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(e);
+						props.page.status = status = transformed.status;
 						return transformed;
 					}
 				: undefined
@@ -506,7 +505,7 @@ export async function render_response({
 				`error: ${serialized.error}`
 			];
 
-			if (status !== 200) {
+			if (status !== 200 && !error) {
 				hydrate.push(`status: ${status}`);
 			}
 
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..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';
 
@@ -90,6 +89,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 +99,8 @@ export async function respond_with_error({
 				ssr,
 				csr
 			},
-			status,
-			error: await handle_error_and_jsonify(event, event_state, options, error),
+			status: transformed.status,
+			error: transformed,
 			branch,
 			error_components: [],
 			fetched,
@@ -115,10 +116,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, transformed.status, transformed.message);
 	}
 }
diff --git a/packages/kit/src/runtime/server/remote.js b/packages/kit/src/runtime/server/remote.js
index 4b190ce345fb..88a29c5aa950 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';
@@ -171,15 +171,16 @@ 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
 										});
 									}
 								}
@@ -326,19 +327,17 @@ 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);
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
-				error: await handle_error_and_jsonify(event, state, options, error),
-				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'
 				}
@@ -359,13 +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 status =
-			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
-
-		return [status, await handle_error_and_jsonify(event, state, options, error)];
+	function convert_error(error) {
+		return handle_error_and_jsonify(event, state, options, error);
 	}
 
 	/** @type {Promise<any>[]} */
@@ -519,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',
@@ -565,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)
 		};
 	}
diff --git a/packages/kit/src/runtime/server/utils.js b/packages/kit/src/runtime/server/utils.js
index 5e8b2fc637d1..994abb7cbef9 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 = 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', [
@@ -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: get_status(body, error) };
 }
 
 /**
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/src/types/internal.d.ts b/packages/kit/src/types/internal.d.ts
index 4df9878ba9a2..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.
-	 */
-	status?: number;
 }
 
 export interface ServerMetadataRoute {
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..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
 		};
 	}
@@ -47,6 +46,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/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>
 
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..d93c31efc723 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');
+
+		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);
+	});
+
 	test('error in endpoint', async ({ page, read_errors }) => {
 		const res = await page.goto('/errors/endpoint');
 
diff --git a/packages/kit/test/apps/basics/test/server.test.js b/packages/kit/test/apps/basics/test/server.test.js
index 8e4d76ebb4aa..23b4bc679d2b 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
 			});
 		}
 	});
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 d5fc1126b55a..3582653f0590 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.
 	 */
@@ -924,13 +926,16 @@ 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.
+	 * If omitted, the status defaults to 500.
 	 */
 	export type HandleServerError = (input: {
 		error: unknown;
 		event: RequestEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | App.Error>;
+	}) => 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.
@@ -938,20 +943,23 @@ 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 }) => 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.
 	 *
 	 * 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.
+	 * If omitted, the status defaults to 500.
 	 */
 	export type HandleClientError = (input: {
 		error: unknown;
 		event: NavigationEvent;
 		status: number;
 		message: string;
-	}) => MaybePromise<void | App.Error>;
+	}) => 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`.
@@ -1807,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.
@@ -2859,20 +2867,38 @@ 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.
+	 * @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: number, body?: {
+	export function error(status: number, body: {
+		status: number;
 		message: string;
-	} extends App.Error ? App.Error | string | undefined : never): 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
+	 * 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: {
+		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.
@@ -3796,6 +3822,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;
 	}