From d4257121b6fedaddda052648d42b9ddfec671c89 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Wed, 5 Aug 2026 16:54:08 -0600
Subject: [PATCH 01/22] breaking: pass all errors through `handleError`, update
 the function contract

---
 .changeset/handle-error-all-errors.md         |  5 +
 .../docs/20-core-concepts/20-load.md          |  2 +-
 .../20-core-concepts/60-remote-functions.md   |  4 +-
 .../docs/30-advanced/10-advanced-routing.md   |  2 +-
 documentation/docs/30-advanced/20-hooks.md    | 52 ++++++++--
 documentation/docs/30-advanced/25-errors.md   | 37 ++++---
 .../src/core/sync/write_client_manifest.js    |  2 +-
 packages/kit/src/exports/index.js             |  8 +-
 packages/kit/src/exports/internal/shared.js   |  9 ++
 packages/kit/src/exports/public.d.ts          | 89 ++++++++++++-----
 packages/kit/src/runtime/client/client.js     | 40 +++++---
 .../client/remote-functions/form.svelte.js    | 15 ++-
 .../remote-functions/prerender.svelte.js      |  4 +-
 .../remote-functions/query-batch.svelte.js    |  4 +-
 .../query-live/instance.svelte.js             | 10 +-
 .../remote-functions/query-live/iterator.js   | 10 +-
 .../remote-functions/query/instance.svelte.js |  7 +-
 .../client/remote-functions/shared.svelte.js  | 23 ++---
 .../remote-functions/shared.transport.spec.js | 10 +-
 packages/kit/src/runtime/server/errors.js     | 64 +++++++-----
 packages/kit/src/runtime/server/index.js      |  5 +-
 packages/kit/src/types/ambient.d.ts           |  2 +-
 packages/kit/src/utils/error.js               | 19 +---
 packages/kit/src/utils/error.spec.js          | 26 ++---
 .../kit/test/apps/async/src/hooks.client.js   | 12 ++-
 .../kit/test/apps/async/src/hooks.server.js   | 12 ++-
 packages/kit/test/apps/basics/.gitignore      |  2 +-
 .../kit/test/apps/basics/src/hooks.client.js  | 26 ++++-
 .../kit/test/apps/basics/src/hooks.server.js  | 36 +++++--
 .../basics/test/cross-platform/client.test.js | 20 ++++
 .../apps/basics/test/cross-platform/test.js   | 83 +++++++++++++---
 .../kit/test/apps/basics/test/server.test.js  | 24 +++--
 packages/kit/test/apps/basics/test/setup.js   |  4 +-
 packages/kit/test/apps/basics/test/test.js    |  8 +-
 .../test/apps/dev-only/src/hooks.client.js    |  5 +-
 .../test/apps/dev-only/src/hooks.server.js    |  5 +-
 .../types/app-error-enhanced/error.test.ts    | 34 +++++++
 packages/kit/test/types/error.test.ts         | 33 ++++++-
 packages/kit/test/utils.js                    | 17 +++-
 packages/kit/types/index.d.ts                 | 97 ++++++++++++++-----
 40 files changed, 607 insertions(+), 260 deletions(-)
 create mode 100644 .changeset/handle-error-all-errors.md

diff --git a/.changeset/handle-error-all-errors.md b/.changeset/handle-error-all-errors.md
new file mode 100644
index 000000000000..f40f914478e3
--- /dev/null
+++ b/.changeset/handle-error-all-errors.md
@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': major
+---
+
+breaking: run all errors through the `handleError` hook
diff --git a/documentation/docs/20-core-concepts/20-load.md b/documentation/docs/20-core-concepts/20-load.md
index 490a09446d23..b947615029ae 100644
--- a/documentation/docs/20-core-concepts/20-load.md
+++ b/documentation/docs/20-core-concepts/20-load.md
@@ -453,7 +453,7 @@ export function load({ locals }) {
 
 Calling `error(...)` will throw an exception, making it easy to stop execution from inside helper functions.
 
-If an [_unexpected_](errors#Unexpected-errors) error is thrown, SvelteKit will invoke [`handleError`](hooks#handleError) and treat it as a 500 Internal Error.
+Every error — expected or otherwise — is passed to the [`handleError`](hooks#handleError) hook. An [_unexpected_](errors#Unexpected-errors) error is treated as a 500 Internal Error unless the hook says otherwise.
 
 > [!NOTE] [In SvelteKit 1.x](migrating-to-sveltekit-2#redirect-and-error-are-no-longer-thrown-by-you) you had to `throw` the error yourself
 
diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index fefdefa7e0fe..d8582cc3b755 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -1236,7 +1236,7 @@ As long as _you're_ not passing invalid data to your remote functions, there are
 - the function signature changed between deployments, and some users are currently on an older version of your app
 - someone is trying to attack your site by poking your exposed endpoints with bad data
 
-In the second case, we don't want to give the attacker any help, so SvelteKit will generate a generic [400 Bad Request](https://http.dog/400) response. You can control the message by implementing the [`handleValidationError`](hooks#handleValidationError) server hook, which, like [`handleError`](hooks#handleError), must return an [`App.Error`](errors#Type-safety) (which defaults to `{ message: string }`):
+In the second case, we don't want to give the attacker any help, so SvelteKit will generate a generic [400 Bad Request](https://http.dog/400) response. You can control the message by implementing the [`handleValidationError`](hooks#handleValidationError) server hook, which must return an object matching [`App.Error`](errors#Type-safety) (which defaults to `{ status: number, message: string }`, with `status` defaulting to `400` if you omit it):
 
 ```js
 /// file: src/hooks.server.js
@@ -1248,6 +1248,8 @@ export function handleValidationError({ event, issues }) {
 }
 ```
 
+The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with a `kind` of `'expected'`.
+
 If you know what you're doing and want to opt out of validation, you can pass the string `'unchecked'` in place of a schema:
 
 ```ts
diff --git a/documentation/docs/30-advanced/10-advanced-routing.md b/documentation/docs/30-advanced/10-advanced-routing.md
index 9647754182d8..5071d9336864 100644
--- a/documentation/docs/30-advanced/10-advanced-routing.md
+++ b/documentation/docs/30-advanced/10-advanced-routing.md
@@ -61,7 +61,7 @@ export function load(event) {
 }
 ```
 
-> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError)
+> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError) as [framework errors](errors#Framework-errors), with a `kind` of `'framework'`. Otherwise, they will appear with a `kind` of `'expected'`.
 
 ## Optional parameters
 
diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 6d1275d8665d..8100adc7f7a7 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -177,18 +177,32 @@ export function handleValidationError({ issues }) {
 
 Be thoughtful about what information you expose here, as the most likely reason for validation to fail is that someone is sending malicious requests to your server.
 
+The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with a `kind` of `'expected'`.
+
 ## handleError
 
 > [!NOTE] Can be added to `src/hooks.server.js` and `src/hooks.client.js`
 
-If an [unexpected error](errors#Unexpected-errors) is thrown during loading, rendering, or from an endpoint, this function will be called with the `error`, `event`, `status` code and `message`. This allows for two things:
+This function is called for _every_ error thrown while loading, rendering, or responding to a request. This allows for two things:
 
 - you can log the error
-- you can generate a custom representation of the error that is safe to show to users, omitting sensitive details like messages and stack traces. The returned value, which defaults to `{ message }`, becomes the value of `page.error`.
+- you can generate a custom representation of the error that is safe to show to users, omitting sensitive details like messages and stack traces. The returned value becomes the value of `page.error`.
+
+Alongside the `event`, the hook receives a `kind` discriminant that tells you where the error came from, and the `error` itself:
+
+| `kind`         | thrown by                           | `error`                                                              | defaults to                                  |
+| -------------- | ----------------------------------- | -------------------------------------------------------------------- | -------------------------------------------- |
+| `'expected'`   | [`error(...)`](@sveltejs-kit#error) | the error body, which matches [`App.Error`](types#Error)             | the error body itself                        |
+| `'unexpected'` | your code, or code it calls         | the thrown value, which may contain information unsafe to expose     | `{ status: 500, message: 'Internal Error' }` |
+| `'framework'`  | SvelteKit — 404s, 405s, 413s...     | `{ status, message }`, where `message` is safe text like `Not Found` | that same `{ status, message }`              |
+
+Errors from [`handleValidationError`](hooks#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
 
-For errors thrown from your code (or library code called by your code) the status will be 500 and the message will be "Internal Error". While `error.message` may contain sensitive information that should not be exposed to users, `message` is safe (albeit meaningless to the average user).
+The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are **optional** — return them only to override the defaults in the table above. Any property you omit is inherited from the caught error, so returning `{}` (or nothing at all) leaves the error untouched, while returning `{ status: 404 }` changes only the status.
 
-To add more information to the `page.error` object in a type-safe way, you can customize the expected shape by declaring an `App.Error` interface (which must include `message: string`, to guarantee sensible fallback behavior). This allows you to — for example — append a tracking ID for users to quote in correspondence with your technical support staff:
+> [!NOTE] If you augment `App.Error` with additional _required_ properties, the hook must return them.
+
+To add more information to the `page.error` object in a type-safe way, you can customize the expected shape by declaring an `App.Error` interface (which must include `status: number` and `message: string`, to guarantee sensible fallback behavior). This allows you to — for example — append a tracking ID for users to quote in correspondence with your technical support staff:
 
 ```ts
 /// file: src/app.d.ts
@@ -220,14 +234,28 @@ import * as Sentry from '@sentry/sveltekit';
 Sentry.init({/*...*/})
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
-export async function handleError({ error, event, status, message }) {
+export async function handleError({ kind, error, event }) {
+	if (kind === 'expected') {
+		// you created this error with `error(...)`, so it already
+		// matches `App.Error` — pass it through unchanged
+		return error;
+	}
+
 	const errorId = crypto.randomUUID();
 
+	if (kind === 'framework') {
+		// a 404 (or similar) — `error.status` and `error.message` are safe to
+		// expose, so we keep them and just add our own property
+		return { ...error, errorId };
+	}
+
 	// example integration with https://sentry.io/
 	Sentry.captureException(error, {
 		extra: { event, errorId, status }
 	});
 
+	// `status` and `message` are optional — we only override `message`,
+	// so the status stays at its default of 500
 	return {
 		message: 'Whoops!',
 		errorId
@@ -251,12 +279,20 @@ import * as Sentry from '@sentry/sveltekit';
 Sentry.init({/*...*/})
 
 /** @type {import('@sveltejs/kit').HandleClientError} */
-export async function handleError({ error, event, status, message }) {
+export async function handleError({ kind, error, event }) {
+	if (kind === 'expected') {
+		return error;
+	}
+
 	const errorId = crypto.randomUUID();
 
+	if (kind === 'framework') {
+		return { ...error, errorId };
+	}
+
 	// example integration with https://sentry.io/
 	Sentry.captureException(error, {
-		extra: { event, errorId, status }
+		extra: { event, errorId }
 	});
 
 	return {
@@ -268,7 +304,7 @@ export async function handleError({ error, event, status, message }) {
 
 > [!NOTE] In `src/hooks.client.js`, the type of `handleError` is `HandleClientError` instead of `HandleServerError`, and `event` is a `NavigationEvent` rather than a `RequestEvent`.
 
-This function is not called for _expected_ errors (those thrown with the [`error`](@sveltejs-kit#error) function imported from `@sveltejs/kit`).
+Errors that were already transformed by the server-side hook are not passed to the client-side hook a second time.
 
 During development, if an error occurs because of a syntax error in your Svelte code, the passed in error has a `frame` property appended highlighting the location of the error.
 
diff --git a/documentation/docs/30-advanced/25-errors.md b/documentation/docs/30-advanced/25-errors.md
index fcb0f2daabeb..68f293623321 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -6,7 +6,7 @@ Errors are an inevitable fact of software development. SvelteKit handles errors
 
 ## Error objects
 
-SvelteKit distinguishes between expected and unexpected errors, both of which are represented as simple `{ status: number, message: string }` objects by default.
+SvelteKit distinguishes between expected errors, unexpected errors, and errors generated by the framework itself, all of which are represented as simple `{ status: number, message: string }` objects by default. Whichever kind it is, every error passes through the [`handleError`](hooks#handleError) hook — which can log it, and customise it — before it is rendered.
 
 You can add additional properties, like a `code` or a tracking `id`, as shown in the examples below. (When using TypeScript this requires you to redefine the `Error` type as described in  [type safety](errors#Type-safety)).
 
@@ -40,6 +40,8 @@ export async function load({ params }) {
 
 This throws an exception that SvelteKit catches, causing it to set the response status code to 404 and render an [`+error.svelte`](routing#error) component, where the `error` is an `App.Error` object with the provided `status` and `message`.
 
+On its way there, the error passes through the [`handleError`](hooks#handleError) hook with a `kind` of `'expected'`. Since the shape of an expected error is determined by you, it is considered safe to expose, and the hook can pass it through unchanged.
+
 ```svelte
 <!--- file: src/routes/+error.svelte --->
 <script>
@@ -83,9 +85,9 @@ By default, unexpected errors are printed to the console (or, in production, you
 { "status": 500, "message": "Internal Error" }
 ```
 
-Unexpected errors will go through the [`handleError`](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 the `error` prop passed to `+error.svelte`.
+Like expected errors, unexpected errors go through the [`handleError`](hooks#handleError) hook — with a `kind` of `'unexpected'` — where you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. Unlike expected errors, the value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
 
-You can override the HTTP status code used in the response by returning a `status` property:
+Anything you return overrides the defaults, so you can — for example — use the type of the thrown error to determine the HTTP status code used in the response:
 
 ```js
 /// file: src/hooks.server.js
@@ -93,19 +95,32 @@ You can override the HTTP status code used in the response by returning a `statu
 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'
-		};
+export function handleError({ kind, error, event }) {
+	if (kind === 'unexpected') {
+		// ... you can do this
+		if (error instanceof NotFound) {
+			return {
+				status: 404,
+				message: 'Not found'
+			};
+		}
+
+		return { message: 'Something went wrong' };
 	}
 
-	return { message: 'Something went wrong' };
+	// expected and framework errors are already safe to expose
+	return error;
 }
 ```
 
+## Framework errors
+
+Some errors are generated by SvelteKit itself rather than by your code — a request for a page that doesn't exist (404), a `POST` request to a page without actions (405), a request body that exceeds the size limit (413), and so on.
+
+These also go through `handleError`, with a `kind` of `'framework'`. The `error` you receive is a `{ status, message }` object whose `message` is a terse but safe description of what went wrong, such as `'Not Found'`, so it can be exposed to users as-is.
+
+If you log errors inside `handleError`, remember that 404s are routine — you will usually want to gate logging on `kind === 'unexpected'`.
+
 ## Error boundaries
 
 Errors that occur during `load` or rendering (for example inside a component's `<script>` block or template) bubble up to the nearest `+error.svelte` component. To handle errors at a more granular level, you can use a [`<svelte:boundary>`](../svelte/svelte-boundary):
diff --git a/packages/kit/src/core/sync/write_client_manifest.js b/packages/kit/src/core/sync/write_client_manifest.js
index 484f34cc0ac6..3d93a77b9318 100644
--- a/packages/kit/src/core/sync/write_client_manifest.js
+++ b/packages/kit/src/core/sync/write_client_manifest.js
@@ -155,7 +155,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			export const hooks = {
 				handleError: ${
 					client_hooks_file ? 'client_hooks.handleError || ' : ''
-				}(({ error }) => { console.error(error) }),
+				}(({ kind, error }) => { if (kind === 'unexpected') { console.error(error); } }),
 				${client_hooks_file ? 'init: client_hooks.init,' : ''}
 				reroute: ${universal_hooks_file ? 'universal_hooks.reroute || ' : ''}(() => {}),
 				transport: ${universal_hooks_file ? 'universal_hooks.transport || ' : ''}{}
diff --git a/packages/kit/src/exports/index.js b/packages/kit/src/exports/index.js
index b0414bc217a2..1b4ea6afe9ca 100644
--- a/packages/kit/src/exports/index.js
+++ b/packages/kit/src/exports/index.js
@@ -24,7 +24,7 @@ export { defineParams } from './params.js';
 /**
  * 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`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * 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 {string} [message] The error message.
@@ -38,7 +38,7 @@ export { defineParams } from './params.js';
 /**
  * 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`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * 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 {string} message The error message.
@@ -54,7 +54,7 @@ export { defineParams } from './params.js';
 /**
  * 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`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
  * @deprecated Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third
  * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
@@ -69,7 +69,7 @@ export { defineParams } from './params.js';
 /**
  * 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`.
+ * return an error response; the error will be passed to `handleError` as an _expected_ error.
  * 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} [message] A string, or (deprecated) a partial App.Error object
diff --git a/packages/kit/src/exports/internal/shared.js b/packages/kit/src/exports/internal/shared.js
index f44099f211c7..107fdaf9ab85 100644
--- a/packages/kit/src/exports/internal/shared.js
+++ b/packages/kit/src/exports/internal/shared.js
@@ -14,6 +14,15 @@ export class HttpError {
 	}
 }
 
+/**
+ * An `HttpError` whose body is already in its final, user-facing form — either produced by the
+ * `handleError` hook on the server and reconstructed here from the response, or authored directly
+ * by the client runtime. Unlike a plain `HttpError` (which represents a fresh `error(...)` call
+ * that the hook has yet to see), `handleError` must not run on it.
+ * @extends HttpError
+ */
+export class HandledHttpError extends HttpError {}
+
 export class Redirect {
 	/**
 	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index ec606da5705f..c42f04aa0922 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -33,6 +33,21 @@ type Span = import('@opentelemetry/api').Span;
 
 type AppErrorWithOptionalStatus = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
 
+type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
+	status?: App.Error['status'];
+	message?: App.Error['message'];
+};
+
+/**
+ * `void` is only a valid `handleError` return when `App.Error` adds no required properties
+ * beyond `status` and `message` — both of which are optional in the return, since they default
+ * to those of the caught error. If `App.Error` is augmented with required properties, the hook
+ * must return them, so returning nothing becomes a type error.
+ */
+type VoidIfNoRequiredAppErrorProperties = { status: number; message: string } extends App.Error
+	? void
+	: never;
+
 /**
  * [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.
  */
@@ -947,20 +962,48 @@ export type Handle = (input: {
 }) => MaybePromise<Response>;
 
 /**
- * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while responding to a request.
+ * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
+ * Use the `kind` discriminant to distinguish expected errors (thrown with the
+ * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), unexpected errors
+ * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
+ * itself, such as 404s).
+ */
+export type CaughtError =
+	| {
+			/** An expected error, thrown with the `error` helper */
+			kind: 'expected';
+			/** The error body, as passed to `error(...)` */
+			error: App.Error;
+	  }
+	| {
+			/** An unexpected error, thrown by your app without the `error` helper */
+			kind: 'unexpected';
+			/** The thrown value. Contents may be unsafe to expose to users */
+			error: unknown;
+	  }
+	| {
+			/** An error generated by SvelteKit itself, such as a 404 */
+			kind: 'framework';
+			/** The status and a safe description of the error */
+			error: { status: number; message: string };
+	  };
+
+/**
+ * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
  *
- * 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 `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
  *
- * 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.
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+ *
+ * Make sure that this function _never_ throws an error.
  */
-export type HandleServerError = (input: {
-	error: unknown;
-	event: RequestEvent;
-	status: number;
-	message: string;
-}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+export type HandleServerError = (
+	input: CaughtError & { event: RequestEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 /**
  * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -971,20 +1014,22 @@ export type HandleValidationError<Issue extends StandardSchemaV1.Issue = Standar
 	(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
 
 /**
- * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while navigating.
+ * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
+ * Errors that were already transformed by the server-side hook are not passed to it a second time.
  *
- * 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 `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+ *
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
  *
- * 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.
+ * Make sure that this function _never_ throws an error.
  */
-export type HandleClientError = (input: {
-	error: unknown;
-	event: NavigationEvent;
-	status: number;
-	message: string;
-}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+export type HandleClientError = (
+	input: CaughtError & { event: NavigationEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 /**
  * The [`handleFetch`](https://svelte.dev/docs/kit/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/client.js b/packages/kit/src/runtime/client/client.js
index 3de752643dc5..a5639273f436 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -8,7 +8,7 @@
 /** @import { LiveQuery } from './remote-functions/query-live/instance.svelte.js' */
 import { BROWSER, DEV } from 'esm-env';
 import { settled, tick, fork, onMount, hydrate, mount } from 'svelte';
-import { HttpError, Redirect, SvelteKitError } from '@sveltejs/kit/internal';
+import { HttpError, Redirect, SvelteKitError, HandledHttpError } from '@sveltejs/kit/internal';
 import { decode_pathname, strip_hash, make_trackable, normalize_path } from '../../utils/url.js';
 import { dev_fetch, initial_fetch, lock_fetch, subsequent_fetch, unlock_fetch } from './fetcher.js';
 import { parse_routes, parse_server_route } from './parse.js';
@@ -48,7 +48,7 @@ import {
 	validate_depends,
 	validate_load_response
 } from '../shared.js';
-import { get_message, get_status } from '../../utils/error.js';
+
 import { page, navigating, updated, notify_version } from './state.svelte.js';
 import { payload } from './payload.js';
 import {
@@ -1519,7 +1519,7 @@ async function load_route({ id, invalidating, url, params, route, preload, actio
 
 		if (server_data_node?.type === 'error') {
 			// rethrow and catch below
-			throw new HttpError(server_data_node.error);
+			throw new HandledHttpError(server_data_node.error);
 		}
 
 		return load_node({
@@ -1574,7 +1574,7 @@ async function load_route({ id, invalidating, url, params, route, preload, actio
 					// the client error handler; it should've already been handled on the server
 					error = /** @type {import('types').ServerErrorNode} */ (err).error;
 				} else if (err instanceof HttpError) {
-					error = err.body;
+					error = await handle_error(err, { params, url, route: { id: route.id } });
 				} else {
 					// Referenced node could have been removed due to redeploy, check
 					if (await updated.check()) {
@@ -2513,20 +2513,37 @@ function setup_preload() {
  * @returns {Promise<App.Error>}
  */
 export async function handle_error(error, event) {
-	if (error instanceof HttpError) {
+	if (error instanceof HandledHttpError) {
 		return error.body;
 	}
 
-	if (DEV) {
+	/** @type {import('@sveltejs/kit').CaughtError} */
+	let caught;
+
+	if (error instanceof HttpError) {
+		caught = { kind: 'expected', error: error.body };
+	} else if (error instanceof SvelteKitError) {
+		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
+	} else {
+		caught = { kind: 'unexpected', error };
+	}
+
+	if (DEV && caught.kind !== 'expected') {
 		errored = true;
 		console.warn('The next HMR update will cause the page to reload');
 	}
 
-	const status = get_status(error);
-	const message = get_message(error);
-	const app_error = (await app.hooks.handleError({ error, event, status, message })) ?? { message };
+	/** @type {App.Error} */
+	const fallback =
+		caught.kind === 'unexpected'
+			? /** @type {App.Error} */ ({ status: 500, message: 'Internal Error' })
+			: /** @type {App.Error} */ (caught.error);
+
+	const app_error = await app.hooks.handleError({ ...caught, event });
 
-	return { ...app_error, status: get_status(app_error, error) };
+	// the hook returns only the properties it wants to override; anything it omits
+	// (including by returning nothing at all) is inherited from the caught error
+	return { ...fallback, ...app_error };
 }
 
 /**
@@ -3719,7 +3736,6 @@ async function load_data(url, invalid) {
 	notify_version(res.headers.get('x-sveltekit-version'));
 
 	if (!res.ok) {
-		// turn it into a HttpError to not call handleError on the client again (was already handled on the server)
 		// if `__data.json` doesn't exist or the server has an internal error,
 		// avoid parsing the HTML error page as a JSON
 		/** @type {App.Error} */
@@ -3731,7 +3747,7 @@ async function load_data(url, invalid) {
 			error.message = 'Not Found';
 		}
 
-		throw new HttpError(error);
+		throw new HandledHttpError(error);
 	}
 
 	return new Promise((resolve, reject) => {
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 0e3a2f7d73c5..b29b405e9484 100644
--- a/packages/kit/src/runtime/client/remote-functions/form.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/form.svelte.js
@@ -3,7 +3,7 @@
 /** @import { InternalRemoteFormIssue } from 'types' */
 import { app_dir, base } from '$app/paths/internal/client';
 import { DEV } from 'esm-env';
-import { HttpError } from '@sveltejs/kit/internal';
+
 import {
 	query_responses,
 	_goto,
@@ -478,14 +478,11 @@ export function form(id) {
 
 					await enhance_callback(create_enhance_callback_instance(form, form_data));
 				} catch (e) {
-					const error =
-						e instanceof HttpError
-							? e.body
-							: await handle_error(e, {
-									params: {},
-									route: { id: null },
-									url: new URL(location.href)
-								});
+					const error = 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/prerender.svelte.js b/packages/kit/src/runtime/client/remote-functions/prerender.svelte.js
index dbbd6aa14ea7..e97e4d5e10f3 100644
--- a/packages/kit/src/runtime/client/remote-functions/prerender.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/prerender.svelte.js
@@ -6,7 +6,7 @@ import { app, _goto, handle_error, prerender_responses } from '../client.js';
 import { get_remote_request_headers, remote_request, unwrap_node } from './shared.svelte.js';
 import { create_remote_key, stringify_remote_arg } from '../../shared.js';
 import { noop } from '../../../utils/functions.js';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 
 // Initialize Cache API for prerender functions
 const CACHE_NAME = __SVELTEKIT_DEV__ ? `sveltekit:${Date.now()}` : `sveltekit:${version}`;
@@ -172,7 +172,7 @@ class Prerender {
 				});
 				this.#loading = false;
 				this.#error = error;
-				throw new HttpError(error); // so that transformError doesn't transform it again
+				throw new HandledHttpError(error);
 			}
 		);
 
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 ac468826bbb5..9c7879a89c00 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
@@ -3,7 +3,7 @@ import { app_dir, base } from '$app/paths/internal/client';
 import { _goto } from '../client.js';
 import { QUERY_FUNCTION_ID, remote_request } from './shared.svelte.js';
 import { QueryProxy } from './query/proxy.js';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 
 /**
  * @param {string} id
@@ -71,7 +71,7 @@ export function query_batch(id) {
 
 							for (const { resolve, reject } of resolvers) {
 								if (result.type === 'error') {
-									reject(new HttpError(result.error));
+									reject(new HandledHttpError(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 b3acac50a26f..d4f78c53fd8d 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
@@ -1,5 +1,5 @@
 import { query_responses, handle_error } from '../../client.js';
-import { HttpError, Redirect } from '@sveltejs/kit/internal';
+import { HttpError, Redirect, HandledHttpError } from '@sveltejs/kit/internal';
 import { noop, once } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
 import { tick } from 'svelte';
@@ -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);
+				const error = new HandledHttpError(node.e);
 				this.#loading = false;
 				this.#error = error.body;
 
@@ -181,8 +181,8 @@ export class LiveQuery {
 				}
 
 				if (error instanceof HttpError) {
-					// Server intentionally sent an error. Surface it and stop.
-					this.fail(error);
+					// Server or client intentionally produced an error. Surface it and stop.
+					await this.#fail(error);
 					break;
 				}
 
@@ -417,7 +417,7 @@ export class LiveQuery {
 			route: { id: null },
 			url: new URL(location.href)
 		});
-		this.fail(new HttpError(error));
+		this.fail(new HandledHttpError(error));
 	}
 
 	get [Symbol.toStringTag]() {
diff --git a/packages/kit/src/runtime/client/remote-functions/query-live/iterator.js b/packages/kit/src/runtime/client/remote-functions/query-live/iterator.js
index cd0e8060e683..db306fbf4502 100644
--- a/packages/kit/src/runtime/client/remote-functions/query-live/iterator.js
+++ b/packages/kit/src/runtime/client/remote-functions/query-live/iterator.js
@@ -4,7 +4,7 @@ import { app } from '../../client.js';
 import { notify_version } from '../../state.svelte.js';
 import { handle_side_channel_response } from '../shared.svelte.js';
 import * as devalue from 'devalue';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HttpError, HandledHttpError } from '@sveltejs/kit/internal';
 import { noop } from '../../../../utils/functions.js';
 import { read_sse } from '../../sse.js';
 
@@ -35,11 +35,9 @@ export async function* create_live_iterator(
 		/** @type {RemoteFunctionResponse | undefined} */
 		const result = await response.json().catch(() => undefined);
 
-		throw new HttpError(
-			result?.type === 'error'
-				? result.error
-				: { status: response.status, message: response.statusText }
-		);
+		throw result?.type === 'error'
+			? new HandledHttpError(result.error)
+			: new HttpError({ status: response.status, message: response.statusText });
 	}
 
 	if (response.headers.get('content-type')?.includes('application/json')) {
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 1501fd2e6958..0380d1ddf22d 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
@@ -1,5 +1,6 @@
+/** @import { HttpError } from '@sveltejs/kit' */
 import { query_responses, handle_error } from '../../client.js';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 import { QUERY_OVERRIDE_KEY } from '../shared.svelte.js';
 import { noop } from '../../../../utils/functions.js';
 import { tick, untrack } from 'svelte';
@@ -70,7 +71,7 @@ export class Query {
 			delete query_responses[key];
 
 			if (node.e) {
-				this.fail(new HttpError(node.e));
+				this.fail(new HandledHttpError(node.e));
 			} else {
 				this.set(/** @type {T} */ (node.v));
 			}
@@ -152,7 +153,7 @@ export class Query {
 					this.#loading = false;
 				});
 
-				reject(new HttpError(error)); // so that transformError doesn't transform it again
+				reject(new HandledHttpError(error));
 			});
 
 		return promise;
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 b47bc8879a1b..49fee58e7c95 100644
--- a/packages/kit/src/runtime/client/remote-functions/shared.svelte.js
+++ b/packages/kit/src/runtime/client/remote-functions/shared.svelte.js
@@ -3,7 +3,7 @@
 /** @import { CacheEntry } from './cache.svelte.js' */
 import * as devalue from 'devalue';
 import { app, _goto, live_query_map, query_map, query_responses } from '../client.js';
-import { HttpError, Redirect } from '@sveltejs/kit/internal';
+import { HttpError, Redirect, HandledHttpError } from '@sveltejs/kit/internal';
 import { untrack } from 'svelte';
 import { create_remote_key, split_remote_key } from '../../shared.js';
 import { navigating, page, notify_version } from '../state.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);
+		throw new HandledHttpError(node.e);
 	}
 
 	return node.v;
@@ -118,22 +118,17 @@ export async function remote_request(url, init) {
 	notify_version(response.headers.get('x-sveltekit-version'));
 
 	if (!response.ok) {
-		const result = await response.json().catch(() => ({
-			type: 'error',
-			status,
-			error: {
-				status,
-				message: response.statusText
-			}
-		}));
+		const result = await response.json().catch(() => undefined);
 
-		throw new HttpError({ status, ...result.error });
+		throw result?.type === 'error'
+			? new HandledHttpError({ status, ...result.error })
+			: new HttpError({ status, message: response.statusText });
 	}
 
 	const result = /** @type {RemoteFunctionResponse} */ (await response.json());
 
 	if (result.type === 'error') {
-		throw new HttpError(result.error);
+		throw new HandledHttpError(result.error);
 	}
 
 	const data = /** @type {RemoteFunctionData} */ (
@@ -148,7 +143,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));
+				entry.resource.fail(new HandledHttpError(result.e));
 			} else {
 				entry.resource.set(result.v);
 			}
@@ -202,7 +197,7 @@ export async function handle_side_channel_response(response) {
 	}
 
 	if (response.type === 'error') {
-		throw new HttpError(response.error);
+		throw new HandledHttpError(response.error);
 	}
 
 	return response;
diff --git a/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js b/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
index 0f6ad4a54248..9052333b5645 100644
--- a/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
+++ b/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
@@ -20,7 +20,7 @@ vi.mock(new URL('../state.svelte.js', import.meta.url).pathname, () => ({
 }));
 
 const { remote_request } = await import('./shared.svelte.js');
-const { HttpError } = await import('@sveltejs/kit/internal');
+const { HttpError, HandledHttpError } = await import('@sveltejs/kit/internal');
 
 /**
  * Build a mock fetch Response. `remote_request` reads `response.headers` before
@@ -59,7 +59,11 @@ describe('remote_request transport error handling', () => {
 		);
 
 		await expect(remote_request('/x')).rejects.toSatisfy((e) => {
-			return e instanceof HttpError && e.status === 401 && e.body?.message === 'unauthorized';
+			return (
+				e instanceof HandledHttpError &&
+				e.status === 401 &&
+				e.body?.message === 'unauthorized'
+			);
 		});
 	});
 
@@ -74,7 +78,7 @@ describe('remote_request transport error handling', () => {
 		);
 
 		await expect(remote_request('/x')).rejects.toSatisfy((e) => {
-			return e instanceof HttpError && e.status === 503;
+			return e instanceof HttpError && !(e instanceof HandledHttpError) && e.status === 503;
 		});
 	});
 
diff --git a/packages/kit/src/runtime/server/errors.js b/packages/kit/src/runtime/server/errors.js
index 06a4ce62a562..087d990a045b 100644
--- a/packages/kit/src/runtime/server/errors.js
+++ b/packages/kit/src/runtime/server/errors.js
@@ -1,7 +1,7 @@
 import { json, text } from '@sveltejs/kit';
 import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store } from '@sveltejs/kit/internal/server';
-import { coalesce_to_error, get_message, get_status } from '../../utils/error.js';
+import { coalesce_to_error } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
 import { fix_stack_trace } from './internal.js';
 import { escape_html } from '../../utils/escape.js';
@@ -13,7 +13,6 @@ import { escape_html } from '../../utils/escape.js';
  * @param {unknown} error
  */
 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 = body.status;
 
@@ -40,29 +39,48 @@ export async function handle_fatal_error(event, state, options, error) {
  * @returns {App.Error | Promise<App.Error>}
  */
 export function handle_error_and_jsonify(event, state, options, error) {
+	/** @type {import('@sveltejs/kit').CaughtError} */
+	let caught;
+
 	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 };
-	}
+		caught = { kind: 'expected', error: error.body };
+	} else if (error instanceof SvelteKitError) {
+		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
+	} else {
+		let e = error;
+		while (e instanceof Error) {
+			fix_stack_trace(e);
+			e = e.cause;
+		}
 
-	let e = error;
-	while (e instanceof Error) {
-		fix_stack_trace(e);
-		e = e.cause;
+		caught = { kind: 'unexpected', error };
 	}
 
-	const status = get_status(error);
-	const message = get_message(error);
+	/** @type {App.Error} */
+	const fallback =
+		caught.kind === 'unexpected'
+			? /** @type {App.Error} */ ({ status: 500, message: 'Internal Error' })
+			: /** @type {App.Error} */ (caught.error);
+
+	/**
+	 * The hook returns only the properties it wants to override; anything it omits
+	 * (including by returning nothing at all) is inherited from the caught error.
+	 * @param {Awaited<ReturnType<import('@sveltejs/kit').HandleServerError>>} body
+	 * @returns {App.Error}
+	 */
+	function merge(body) {
+		return { ...fallback, ...body };
+	}
 
 	// TODO 4.0 await this, rather than handling the non-Promise case
 	let result;
 	try {
 		result = with_request_store({ event, state }, () =>
-			options.hooks.handleError({ error, event, status, message })
-		) ?? { status, message };
+			options.hooks.handleError({ ...caught, event })
+		);
 	} catch (hook_error) {
 		log_handle_error_hook_failure(error, hook_error);
-		return { status, message: 'Internal Error' };
+		return { status: fallback.status, message: 'Internal Error' };
 	}
 
 	if (result instanceof Promise) {
@@ -76,24 +94,18 @@ export function handle_error_and_jsonify(event, state, options, error) {
 			result.catch((hook_error) => log_handle_error_hook_failure(error, hook_error));
 
 			return {
-				status,
+				status: fallback.status,
 				message: 'Internal Error'
 			};
 		}
 
-		return result.then(
-			(body) => {
-				body ??= { status, message };
-				return { ...body, status: get_status(body, error) };
-			},
-			(hook_error) => {
-				log_handle_error_hook_failure(error, hook_error);
-				return { status, message: 'Internal Error' };
-			}
-		);
+		return result.then(merge, (hook_error) => {
+			log_handle_error_hook_failure(error, hook_error);
+			return { status: fallback.status, message: 'Internal Error' };
+		});
 	}
 
-	return { ...result, status: get_status(result, error) };
+	return merge(result);
 }
 
 /**
diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index 218dee43fe1b..32aa03024e1b 100644
--- a/packages/kit/src/runtime/server/index.js
+++ b/packages/kit/src/runtime/server/index.js
@@ -9,6 +9,7 @@ import { SvelteKitError } from '@sveltejs/kit/internal';
 import { init_tracing } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
 import { init_transport } from '#app/internal/transport';
+import { set_app } from './app.js';
 
 /** @type {Promise<any>} */
 let init_promise;
@@ -130,8 +131,8 @@ export class Server {
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
 					handleError:
 						module.handleError ||
-						(({ error }) => {
-							if (error instanceof SvelteKitError) {
+						(({ kind, error }) => {
+							if (kind !== 'unexpected') {
 								// don't log stack traces for 404s etc, it's all internal gubbins
 								return;
 							}
diff --git a/packages/kit/src/types/ambient.d.ts b/packages/kit/src/types/ambient.d.ts
index 893d757b7af6..b890ab70ee5c 100644
--- a/packages/kit/src/types/ambient.d.ts
+++ b/packages/kit/src/types/ambient.d.ts
@@ -22,7 +22,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.
+	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Every error passes through the `handleError` hooks, which must return this shape (with `status` and `message` optional, since they default to those of the caught error).
 	 */
 	export interface Error {
 		status: number;
diff --git a/packages/kit/src/utils/error.js b/packages/kit/src/utils/error.js
index 7fdd73474cc1..f818898dadd3 100644
--- a/packages/kit/src/utils/error.js
+++ b/packages/kit/src/utils/error.js
@@ -35,24 +35,9 @@ export function normalize_error(error) {
 	);
 }
 
-/**
- * @param {any} transformed
- * @param {any} [error]
- */
-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;
-	}
-}
-
 /**
  * @param {unknown} error
  */
-export function get_message(error) {
-	return error instanceof SvelteKitError ? error.text : 'Internal Error';
+export function get_status(error) {
+	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
 }
diff --git a/packages/kit/src/utils/error.spec.js b/packages/kit/src/utils/error.spec.js
index 6f4c8cb4b652..fc4291921f61 100644
--- a/packages/kit/src/utils/error.spec.js
+++ b/packages/kit/src/utils/error.spec.js
@@ -3,30 +3,20 @@ 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('returns the status of an HttpError', () => {
+		expect(get_status(new HttpError({ status: 418, message: 'teapot' }))).toBe(418);
 	});
 
-	it('falls back to HttpError status', () => {
-		const error = new HttpError({ status: 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 the status of a SvelteKitError', () => {
+		expect(get_status(new SvelteKitError(404, 'Not Found', 'missing'))).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({ status: 418, message: 'teapot' });
-		expect(get_status(error)).toBe(418);
+		expect(get_status(new Error('oops'))).toBe(500);
 	});
 
-	it('works with a single plain Error argument', () => {
-		expect(get_status(new Error('oops'))).toBe(500);
+	it('returns 500 for non-errors', () => {
+		expect(get_status({ status: 404 })).toBe(500);
+		expect(get_status(undefined)).toBe(500);
 	});
 });
diff --git a/packages/kit/test/apps/async/src/hooks.client.js b/packages/kit/test/apps/async/src/hooks.client.js
index af343e2d1022..b5fbc37121d0 100644
--- a/packages/kit/test/apps/async/src/hooks.client.js
+++ b/packages/kit/test/apps/async/src/hooks.client.js
@@ -1,13 +1,17 @@
 import { isRedirect } from '@sveltejs/kit';
 
 /** @type {import('@sveltejs/kit').HandleClientError} */
-export const handleError = ({ error: e, event, status, message }) => {
+export const handleError = (input) => {
 	// helps us catch sveltekit redirects thrown in component code
-	if (isRedirect(e)) {
+	if (isRedirect(input.error)) {
 		throw new Error("Redirects shouldn't trigger the handleError hook");
 	}
 
-	const error = /** @type {Error} */ (e);
+	if (input.kind !== 'unexpected') return input.error;
 
-	return { message: `${error.message} (${status} ${message}, on ${event.url.pathname})` };
+	const error = /** @type {Error} */ (input.error);
+
+	return {
+		message: `${error.message} (500 Internal Error, on ${input.event.url.pathname})`
+	};
 };
diff --git a/packages/kit/test/apps/async/src/hooks.server.js b/packages/kit/test/apps/async/src/hooks.server.js
index ec6bf26ad022..25bc17ef5448 100644
--- a/packages/kit/test/apps/async/src/hooks.server.js
+++ b/packages/kit/test/apps/async/src/hooks.server.js
@@ -46,13 +46,17 @@ export const handleValidationError = ({ issues, event }) => {
 };
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
-export const handleError = ({ error: e, event, status, message }) => {
+export const handleError = (input) => {
 	// helps us catch sveltekit redirects thrown in component code
-	if (isRedirect(e)) {
+	if (isRedirect(input.error)) {
 		throw new Error("Redirects shouldn't trigger the handleError hook");
 	}
 
-	const error = /** @type {Error} */ (e);
+	if (input.kind !== 'unexpected') return input.error;
 
-	return { message: `${error.message} (${status} ${message}, on ${event.url.pathname})` };
+	const error = /** @type {Error} */ (input.error);
+
+	return {
+		message: `${error.message} (500 Internal Error, on ${input.event.url.pathname})`
+	};
 };
diff --git a/packages/kit/test/apps/basics/.gitignore b/packages/kit/test/apps/basics/.gitignore
index 7bc5d5fff974..6c5d589cfddf 100644
--- a/packages/kit/test/apps/basics/.gitignore
+++ b/packages/kit/test/apps/basics/.gitignore
@@ -1,4 +1,4 @@
-/test/errors.json
+/test/errors.jsonl
 !/.env
 /src/routes/routing/symlink-from
 /test/spans.jsonl
\ No newline at end of file
diff --git a/packages/kit/test/apps/basics/src/hooks.client.js b/packages/kit/test/apps/basics/src/hooks.client.js
index 54440e09be50..55c801dd6b37 100644
--- a/packages/kit/test/apps/basics/src/hooks.client.js
+++ b/packages/kit/test/apps/basics/src/hooks.client.js
@@ -3,10 +3,28 @@ import { PUBLIC_DYNAMIC } from '$app/env/public';
 window.PUBLIC_DYNAMIC = PUBLIC_DYNAMIC;
 
 /** @type{import("@sveltejs/kit").HandleClientError} */
-export function handleError({ error, event, status, message }) {
-	return event.url.pathname.endsWith('404-fallback')
-		? undefined
-		: { message: `${/** @type {Error} */ (error).message} (${status} ${message})` };
+export function handleError(input) {
+	const { kind } = input;
+
+	if (input.event.url.pathname.startsWith('/errors/kind/')) {
+		return { message: `client ${kind}` };
+	}
+
+	if (kind === 'expected') {
+		return input.error;
+	}
+
+	// the server hook returns `{}` here; between them both spellings are covered
+	if (input.event.url.pathname.endsWith('404-fallback')) {
+		return;
+	}
+
+	const status = kind === 'framework' ? input.error.status : 500;
+	const message = kind === 'framework' ? input.error.message : 'Internal Error';
+	const detail =
+		kind === 'framework' ? input.error.message : /** @type {Error} */ (input.error).message;
+
+	return { message: `${detail} (${status} ${message})` };
 }
 
 export function init() {
diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index a0ac97c57f40..c62f7a53b91e 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -29,17 +29,33 @@ export function error_to_pojo(error) {
 }
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
-export const handleError = ({ event, error: e, status, message }) => {
-	const error = /** @type {Error} */ (e);
+export const handleError = (input) => {
+	const { event, kind } = input;
+
 	// TODO we do this because there's no other way (that i'm aware of)
 	// to communicate errors back to the test suite. even if we could
 	// capture stderr, attributing an error to a specific request
 	// is trickier when things run concurrently
-	const errors = fs.existsSync('test/errors.json')
-		? JSON.parse(fs.readFileSync('test/errors.json', 'utf8'))
-		: {};
-	errors[event.url.pathname] = error_to_pojo(error);
-	fs.writeFileSync('test/errors.json', JSON.stringify(errors));
+	fs.appendFileSync(
+		'test/errors.jsonl',
+		JSON.stringify({
+			path: event.url.pathname,
+			kind,
+			error:
+				kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (input.error)) : input.error
+		}) + '\n'
+	);
+
+	if (kind === 'expected') {
+		// so that `error(...)` bodies reach the page verbatim
+		return input.error;
+	}
+
+	const status = kind === 'framework' ? input.error.status : 500;
+	const detail =
+		kind === 'framework' ? input.error.message : /** @type {Error} */ (input.error).message;
+
+	let message = kind === 'framework' ? input.error.message : 'Internal Error';
 
 	if (event.url.pathname.startsWith('/get-request-event/')) {
 		const ev = getRequestEvent();
@@ -49,7 +65,7 @@ export const handleError = ({ event, error: e, status, message }) => {
 	if (event.url.pathname === '/errors/handle-error-status') {
 		return {
 			status: 404,
-			message: `${error.message} (${status} ${message})`
+			message: `${detail} (${status} ${message})`
 		};
 	}
 
@@ -58,8 +74,8 @@ export const handleError = ({ event, error: e, status, message }) => {
 	}
 
 	return event.url.pathname.endsWith('404-fallback')
-		? undefined
-		: { message: `${error.message} (${status} ${message})` };
+		? {}
+		: { message: `${detail} (${status} ${message})` };
 };
 
 export const handle = sequence(
diff --git a/packages/kit/test/apps/basics/test/cross-platform/client.test.js b/packages/kit/test/apps/basics/test/cross-platform/client.test.js
index 3c459e5926ed..6b66714093c4 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/client.test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/client.test.js
@@ -811,6 +811,26 @@ test.describe.serial('Errors', () => {
 		await clicknav('button:text-is("Redirect")');
 		expect(page.url()).toBe(baseURL + '/load');
 	});
+
+	test('expected errors reach the client handleError hook', async ({ page, clicknav }) => {
+		await page.goto('/errors/kind');
+		await clicknav('[href="/errors/kind/expected"]');
+
+		expect(await page.textContent('#message')).toBe(
+			'This is your custom error page saying: "client expected"'
+		);
+		expect(await page.textContent('h1')).toBe('403');
+	});
+
+	test('unexpected errors reach the client handleError hook', async ({ page, clicknav }) => {
+		await page.goto('/errors/kind');
+		await clicknav('[href="/errors/kind/unexpected"]');
+
+		expect(await page.textContent('#message')).toBe(
+			'This is your custom error page saying: "client unexpected"'
+		);
+		expect(await page.textContent('h1')).toBe('500');
+	});
 });
 
 test.describe('Prefetching', () => {
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 03500f3c85ee..39489c839519 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/test.js
@@ -301,14 +301,21 @@ test.describe('Errors', () => {
 		expect(await get_computed_style('h1', 'color')).toBe('rgb(255, 0, 0)');
 	});
 
-	test('404', async ({ page }) => {
+	test('404', async ({ page, read_errors }) => {
 		const response = await page.goto('/why/would/anyone/fetch/this/url');
 
 		expect(await page.textContent('footer')).toBe('Custom layout');
+		// the hook only sees the safe message for framework errors, not the
+		// detailed `Not found: /why/would/anyone/fetch/this/url`
 		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "Not found: /why/would/anyone/fetch/this/url (404 Not Found)"'
+			'This is your custom error page saying: "Not Found (404 Not Found)"'
 		);
 		expect(/** @type {Response} */ (response).status()).toBe(404);
+
+		expect(read_errors('/why/would/anyone/fetch/this/url')).toEqual({
+			kind: 'framework',
+			error: { status: 404, message: 'Not Found' }
+		});
 	});
 
 	test('server-side error from load() is a string', async ({ page }) => {
@@ -346,11 +353,41 @@ test.describe('Errors', () => {
 		expect(/** @type {Response} */ (response).status()).toBe(404);
 	});
 
+	test('expected errors reach the handleError hook', async ({ page, read_errors }) => {
+		const response = await page.goto('/errors/kind/expected');
+
+		expect(read_errors('/errors/kind/expected')).toEqual({
+			kind: 'expected',
+			error: { status: 403, message: 'expected error' }
+		});
+
+		expect(await page.textContent('#message')).toBe(
+			'This is your custom error page saying: "expected error"'
+		);
+		expect(/** @type {Response} */ (response).status()).toBe(403);
+	});
+
+	test('unexpected errors reach the handleError hook', async ({ page, read_errors }) => {
+		const response = await page.goto('/errors/kind/unexpected');
+
+		const { kind, error } = read_errors('/errors/kind/unexpected');
+		expect(kind).toBe('unexpected');
+		expect(error.message).toBe('unexpected error');
+
+		expect(await page.textContent('#message')).toBe(
+			'This is your custom error page saying: "unexpected error (500 Internal Error)"'
+		);
+		expect(/** @type {Response} */ (response).status()).toBe(500);
+	});
+
 	test('error in endpoint', async ({ page, read_errors }) => {
 		const res = await page.goto('/errors/endpoint');
 
+		const { kind, error } = read_errors('/errors/endpoint.json');
+		expect(kind).toBe('unexpected');
+
 		// should include stack trace
-		const lines = read_errors('/errors/endpoint.json').stack.split('\n');
+		const lines = error.stack.split('\n');
 		expect(lines[0]).toMatch('nope');
 
 		if (process.env.DEV) {
@@ -366,8 +403,11 @@ test.describe('Errors', () => {
 	test('error in shadow endpoint', async ({ page, read_errors }) => {
 		const res = await page.goto('/errors/endpoint-shadow');
 
+		const { kind, error } = read_errors('/errors/endpoint-shadow');
+		expect(kind).toBe('unexpected');
+
 		// should include stack trace
-		const lines = read_errors('/errors/endpoint-shadow').stack.split('\n');
+		const lines = error.stack.split('\n');
 		expect(lines[0]).toMatch('nope');
 
 		if (process.env.DEV) {
@@ -383,7 +423,10 @@ test.describe('Errors', () => {
 	test('not ok response from shadow endpoint', async ({ page, read_errors }) => {
 		const res = await page.goto('/errors/endpoint-shadow-not-ok');
 
-		expect(read_errors('/errors/endpoint-shadow-not-ok')).toBeUndefined();
+		expect(read_errors('/errors/endpoint-shadow-not-ok')).toEqual({
+			kind: 'expected',
+			error: { status: 555, message: 'Error: 555' }
+		});
 
 		expect(res && res.status()).toBe(555);
 		expect(await page.textContent('#message')).toBe(
@@ -414,9 +457,10 @@ test.describe('Errors', () => {
 			JSON.stringify({ status: 500, message: 'oops (500 Internal Error)' }, null, '  ')
 		);
 
-		const { status, name, message, stack, fancy } = read_errors(
-			'/errors/page-endpoint/get-implicit'
-		);
+		const { kind, error } = read_errors('/errors/page-endpoint/get-implicit');
+		expect(kind).toBe('unexpected');
+
+		const { status, name, message, stack, fancy } = error;
 		expect(status).toBe(undefined);
 		expect(name).toBe('FancyError');
 		expect(message).toBe('oops');
@@ -439,8 +483,10 @@ test.describe('Errors', () => {
 			JSON.stringify({ status: 400, message: 'oops' }, null, '  ')
 		);
 
-		const error = read_errors('/errors/page-endpoint/get-explicit');
-		expect(error).toBe(undefined);
+		expect(read_errors('/errors/page-endpoint/get-explicit')).toEqual({
+			kind: 'expected',
+			error: { status: 400, message: 'oops' }
+		});
 	});
 
 	test('page endpoint POST unexpected error message is preserved', async ({
@@ -457,9 +503,10 @@ test.describe('Errors', () => {
 			JSON.stringify({ status: 500, message: 'oops (500 Internal Error)' }, null, '  ')
 		);
 
-		const { status, name, message, stack, fancy } = read_errors(
-			'/errors/page-endpoint/post-implicit'
-		);
+		const { kind, error } = read_errors('/errors/page-endpoint/post-implicit');
+		expect(kind).toBe('unexpected');
+
+		const { status, name, message, stack, fancy } = error;
 
 		expect(status).toBe(undefined);
 		expect(name).toBe('FancyError');
@@ -485,8 +532,10 @@ test.describe('Errors', () => {
 			JSON.stringify({ status: 400, message: 'oops' }, null, '  ')
 		);
 
-		const error = read_errors('/errors/page-endpoint/post-explicit');
-		expect(error).toBe(undefined);
+		expect(read_errors('/errors/page-endpoint/post-explicit')).toEqual({
+			kind: 'expected',
+			error: { status: 400, message: 'oops' }
+		});
 	});
 });
 
@@ -554,7 +603,9 @@ test.describe('Redirects', () => {
 
 		if (!javaScriptEnabled) {
 			// handleError is not invoked for client-side navigation
-			const lines = read_errors('/redirect/missing-status/a').stack.split('\n');
+			const { kind, error } = read_errors('/redirect/missing-status/a');
+			expect(kind).toBe('unexpected');
+			const lines = error.stack.split('\n');
 			expect(lines[0]).toBe(`Error: ${message}`);
 		}
 	});
diff --git a/packages/kit/test/apps/basics/test/server.test.js b/packages/kit/test/apps/basics/test/server.test.js
index 752db7dfa6ec..74b0fbef6cf5 100644
--- a/packages/kit/test/apps/basics/test/server.test.js
+++ b/packages/kit/test/apps/basics/test/server.test.js
@@ -552,14 +552,18 @@ test.describe('Errors', () => {
 		}
 	});
 
-	test('returns a lightweight 404 for subresource requests', async ({ request }) => {
-		const response = await request.get('/errors/does-not-exist-subresource', {
+	test('returns a lightweight 404 for subresource requests', async ({ request, read_errors }) => {
+		// distinct from the path used by the test below, which _does_ invoke the hook
+		const response = await request.get('/errors/does-not-exist-lightweight-subresource', {
 			headers: { 'sec-fetch-dest': 'image' }
 		});
 
 		expect(response.status()).toBe(404);
 		expect(await response.text()).toBe('Not Found');
 		expect(response.headers()['vary']).toContain('Sec-Fetch-Dest');
+
+		// lightweight 404s bypass the handleError hook
+		expect(read_errors('/errors/does-not-exist-lightweight-subresource')).toBe(undefined);
 	});
 
 	test('renders the error page for document and fetch requests', async ({ request }) => {
@@ -596,8 +600,10 @@ test.describe('Errors', () => {
 				}
 			});
 
-			const error = read_errors('/errors/endpoint-throw-error');
-			expect(error).toBe(undefined);
+			expect(read_errors('/errors/endpoint-throw-error')).toEqual({
+				kind: 'expected',
+				error: { status: 401, message: 'You shall not pass' }
+			});
 
 			expect(res.status()).toBe(401);
 			expect(await res.text()).toContain(
@@ -609,8 +615,10 @@ test.describe('Errors', () => {
 		{
 			const res = await request.get('/errors/endpoint-throw-error');
 
-			const error = read_errors('/errors/endpoint-throw-error');
-			expect(error).toBe(undefined);
+			expect(read_errors('/errors/endpoint-throw-error')).toEqual({
+				kind: 'expected',
+				error: { status: 401, message: 'You shall not pass' }
+			});
 
 			expect(res.status()).toBe(401);
 			expect(await res.json()).toEqual({
@@ -650,9 +658,7 @@ test.describe('Errors', () => {
 			type: 'error',
 			location: '/errors/missing-actions',
 			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)',
+				message: 'Method Not Allowed (405 Method Not Allowed)',
 				status: 405
 			}
 		});
diff --git a/packages/kit/test/apps/basics/test/setup.js b/packages/kit/test/apps/basics/test/setup.js
index 3e258a512b48..a64379f6b25b 100644
--- a/packages/kit/test/apps/basics/test/setup.js
+++ b/packages/kit/test/apps/basics/test/setup.js
@@ -7,6 +7,4 @@ if (process.platform !== 'win32') {
 	fs.symlinkSync('symlink-to', 'symlink-from', 'dir');
 }
 
-try {
-	fs.unlinkSync('test/errors.json');
-} catch {}
+fs.rmSync('test/errors.jsonl', { force: true });
diff --git a/packages/kit/test/apps/basics/test/test.js b/packages/kit/test/apps/basics/test/test.js
index 6a781fe8cc40..a7be4501972d 100644
--- a/packages/kit/test/apps/basics/test/test.js
+++ b/packages/kit/test/apps/basics/test/test.js
@@ -1451,9 +1451,7 @@ test.describe('Actions', () => {
 		});
 		const { type, error } = await response.json();
 		expect(type).toBe('error');
-		expect(error.message).toBe(
-			'Form actions expect form-encoded data — received application/json (415 Unsupported Media Type)'
-		);
+		expect(error.message).toBe('Unsupported Media Type (415 Unsupported Media Type)');
 		expect(response.status()).toBe(415);
 	});
 
@@ -1470,7 +1468,7 @@ test.describe('Actions', () => {
 		});
 		const { type, error } = await response.json();
 		expect(type).toBe('error');
-		expect(error.message).toBe("No action with name 'doesnt-exist' found (404 Not Found)");
+		expect(error.message).toBe('Not Found (404 Not Found)');
 		expect(response.status()).toBe(404);
 	});
 
@@ -1560,7 +1558,7 @@ test.describe('Actions', () => {
 			);
 			const { type, error } = await response.json();
 			expect(type).toBe('error');
-			expect(error.message).toBe(`No action with name '${name}' found (404 Not Found)`);
+			expect(error.message).toBe('Not Found (404 Not Found)');
 			expect(response.status()).toBe(404);
 		});
 	}
diff --git a/packages/kit/test/apps/dev-only/src/hooks.client.js b/packages/kit/test/apps/dev-only/src/hooks.client.js
index cbef70b0bf42..47b6221d307a 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.client.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.client.js
@@ -3,6 +3,7 @@ import cjs from 'e2e-test-dep-hooks-client';
 cjs.cjs();
 
 /** @type {import("@sveltejs/kit").HandleClientError} */
-export function handleError({ message }) {
-	return { message };
+export function handleError(input) {
+	if (input.kind !== 'unexpected') return input.error;
+	return { message: /**@type{any}*/ (input.error).message };
 }
diff --git a/packages/kit/test/apps/dev-only/src/hooks.server.js b/packages/kit/test/apps/dev-only/src/hooks.server.js
index b9bd53a8148a..461c390c390a 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.server.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.server.js
@@ -1,4 +1,5 @@
 /** @type {import("@sveltejs/kit").HandleServerError} */
-export function handleError({ error }) {
-	return { message: /**@type{any}*/ (error).message };
+export function handleError(input) {
+	if (input.kind !== 'unexpected') return input.error;
+	return { message: /**@type{any}*/ (input.error).message };
 }
diff --git a/packages/kit/test/types/app-error-enhanced/error.test.ts b/packages/kit/test/types/app-error-enhanced/error.test.ts
index 29877e626c60..7b27166fd1ba 100644
--- a/packages/kit/test/types/app-error-enhanced/error.test.ts
+++ b/packages/kit/test/types/app-error-enhanced/error.test.ts
@@ -27,9 +27,43 @@ const handle_error_hooks: [
 	() => ({ message: 'Unexpected error' })
 ];
 
+// `status` and `message` are optional in the return (they default to those of the
+// caught error), but augmented properties of `App.Error` remain required
+const handle_error_overrides: [HandleServerError, HandleClientError] = [
+	() => ({ additional: true }),
+	() => ({ additional: true })
+];
+
+const handle_error_kinds: HandleServerError = ({ kind, error }) => {
+	if (kind === 'expected') {
+		error satisfies App.Error;
+		return error;
+	}
+
+	if (kind === 'framework') {
+		// @ts-expect-error the framework error has no `additional` property
+		error satisfies App.Error;
+		return { ...error, additional: true };
+	}
+
+	return { additional: true };
+};
+
+// `App.Error` is augmented with a REQUIRED `additional` property, so unlike the default
+// case the hook cannot return nothing — it must supply the augmented properties
+const handle_error_without_return: [HandleServerError, HandleClientError] = [
+	// @ts-expect-error handleError must return the required properties of App.Error
+	() => {},
+	// @ts-expect-error handleError must return the required properties of App.Error
+	() => {}
+];
+
 void app_error;
 void app_error_without_status;
 void handle_error_hooks;
+void handle_error_overrides;
+void handle_error_kinds;
+void handle_error_without_return;
 
 function a() {
 	// @ts-expect-error App.Error requires additional
diff --git a/packages/kit/test/types/error.test.ts b/packages/kit/test/types/error.test.ts
index 8724a3cf1888..1f09bedc4173 100644
--- a/packages/kit/test/types/error.test.ts
+++ b/packages/kit/test/types/error.test.ts
@@ -6,13 +6,44 @@ const app_error: App.Error = { status: 500, message: 'Unexpected error' };
 const app_error_without_status: App.Error = { message: 'Unexpected error' };
 
 const handle_error_hooks: [HandleServerError, HandleClientError] = [
-	() => ({ message: 'Unexpected error' }),
+	({ kind, error }) => {
+		if (kind === 'expected') {
+			error satisfies App.Error;
+			return error;
+		}
+
+		if (kind === 'framework') {
+			error satisfies { status: number; message: string };
+			return error;
+		}
+
+		error satisfies unknown;
+		return { message: 'Unexpected error' };
+	},
 	() => ({ message: 'Unexpected error' })
 ];
 
+// `status` and `message` are optional in the return — they are only returned to
+// override the defaults inherited from the caught error
+const handle_error_overrides: [HandleServerError, HandleServerError, HandleClientError] = [
+	() => ({}),
+	() => ({ status: 404 }),
+	() => ({})
+];
+
+// with the default `App.Error`, returning nothing is valid — every property of the
+// return type is optional, so `void` and `{}` mean the same thing
+const handle_error_without_return: [HandleServerError, HandleClientError, HandleServerError] = [
+	() => {},
+	() => {},
+	async () => {}
+];
+
 void app_error;
 void app_error_without_status;
 void handle_error_hooks;
+void handle_error_overrides;
+void handle_error_without_return;
 
 function a() {
 	error(400, 'Bad request');
diff --git a/packages/kit/test/utils.js b/packages/kit/test/utils.js
index 18b2194d1c3e..d012fe6af77b 100644
--- a/packages/kit/test/utils.js
+++ b/packages/kit/test/utils.js
@@ -148,10 +148,19 @@ export const test = base.extend({
 	read_errors: async ({}, use) => {
 		/** @param {string} path */
 		function read_errors(path) {
-			const errors =
-				fs.existsSync('test/errors.json') &&
-				JSON.parse(fs.readFileSync('test/errors.json', 'utf8'));
-			return errors[path];
+			if (!fs.existsSync('test/errors.jsonl')) return;
+
+			const records = fs.readFileSync('test/errors.jsonl', 'utf8').split('\n');
+			records.pop(); // ignore a trailing partial record if this races an append
+
+			const match = records
+				.map((line) => JSON.parse(line))
+				.findLast((error) => error.path === path);
+
+			if (match) {
+				const { path: _, ...error } = match;
+				return error;
+			}
 		}
 
 		await use(read_errors);
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index a24ac0b7d9b0..26c8a3bae239 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -11,6 +11,21 @@ declare module '@sveltejs/kit' {
 
 	type AppErrorWithOptionalStatus = Omit<App.Error, 'status'> & { status?: App.Error['status'] };
 
+	type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
+		status?: App.Error['status'];
+		message?: App.Error['message'];
+	};
+
+	/**
+	 * `void` is only a valid `handleError` return when `App.Error` adds no required properties
+	 * beyond `status` and `message` — both of which are optional in the return, since they default
+	 * to those of the caught error. If `App.Error` is augmented with required properties, the hook
+	 * must return them, so returning nothing becomes a type error.
+	 */
+	type VoidIfNoRequiredAppErrorProperties = { status: number; message: string } extends App.Error
+		? void
+		: never;
+
 	/**
 	 * [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.
 	 */
@@ -923,20 +938,48 @@ declare module '@sveltejs/kit' {
 	}) => MaybePromise<Response>;
 
 	/**
-	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while responding to a request.
+	 * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
+	 * Use the `kind` discriminant to distinguish expected errors (thrown with the
+	 * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), unexpected errors
+	 * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
+	 * itself, such as 404s).
+	 */
+	export type CaughtError =
+		| {
+				/** An expected error, thrown with the `error` helper */
+				kind: 'expected';
+				/** The error body, as passed to `error(...)` */
+				error: App.Error;
+		  }
+		| {
+				/** An unexpected error, thrown by your app without the `error` helper */
+				kind: 'unexpected';
+				/** The thrown value. Contents may be unsafe to expose to users */
+				error: unknown;
+		  }
+		| {
+				/** An error generated by SvelteKit itself, such as a 404 */
+				kind: 'framework';
+				/** The status and a safe description of the error */
+				error: { status: number; message: string };
+		  };
+
+	/**
+	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
 	 *
-	 * 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 `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+	 *
+	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
+	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
 	 *
-	 * 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.
+	 * Make sure that this function _never_ throws an error.
 	 */
-	export type HandleServerError = (input: {
-		error: unknown;
-		event: RequestEvent;
-		status: number;
-		message: string;
-	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+	export type HandleServerError = (
+		input: CaughtError & { event: RequestEvent }
+	) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 	/**
 	 * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#handleValidationError) hook runs when the argument to a remote function fails validation.
@@ -947,20 +990,22 @@ declare module '@sveltejs/kit' {
 		(input: { issues: Issue[]; event: RequestEvent }) => MaybePromise<AppErrorWithOptionalStatus>;
 
 	/**
-	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while navigating.
+	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
+	 * Errors that were already transformed by the server-side hook are not passed to it a second time.
 	 *
-	 * 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 `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+	 *
+	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
+	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
 	 *
-	 * 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.
+	 * Make sure that this function _never_ throws an error.
 	 */
-	export type HandleClientError = (input: {
-		error: unknown;
-		event: NavigationEvent;
-		status: number;
-		message: string;
-	}) => MaybePromise<void | AppErrorWithOptionalStatus>;
+	export type HandleClientError = (
+		input: CaughtError & { event: NavigationEvent }
+	) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
 
 	/**
 	 * The [`handleFetch`](https://svelte.dev/docs/kit/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`.
@@ -2426,7 +2471,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * 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`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * 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 message The error message.
@@ -2440,7 +2485,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * 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`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * 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 message The error message.
@@ -2455,7 +2500,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * 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`.
+	 * return an error response; the error will be passed to `handleError` as an _expected_ error.
 	 * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
 	 * @deprecated Passing an `App.Error` body as the second argument is deprecated — pass the `message` as the second argument, and any additional properties as the third
 	 * @param 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.
@@ -3754,7 +3799,7 @@ declare module '$app/state' {
  */
 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.
+	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Every error passes through the `handleError` hooks, which must return this shape (with `status` and `message` optional, since they default to those of the caught error).
 	 */
 	export interface Error {
 		status: number;

From e8c5c108a915d752628e18792e0f8caf4d874097 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:47:25 -0600
Subject: [PATCH 02/22] Update 10-advanced-routing.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 documentation/docs/30-advanced/10-advanced-routing.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/30-advanced/10-advanced-routing.md b/documentation/docs/30-advanced/10-advanced-routing.md
index 5071d9336864..7048f9d6bc2b 100644
--- a/documentation/docs/30-advanced/10-advanced-routing.md
+++ b/documentation/docs/30-advanced/10-advanced-routing.md
@@ -61,7 +61,7 @@ export function load(event) {
 }
 ```
 
-> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError) as [framework errors](errors#Framework-errors), with a `kind` of `'framework'`. Otherwise, they will appear with a `kind` of `'expected'`.
+> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError) as [framework errors](errors#Framework-errors), with `kind: 'framework'`. Otherwise, they will appear with `kind: 'expected'`.
 
 ## Optional parameters
 

From 966fa100f1128a1876bb3cfc4b4fce447190b9f3 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:47:40 -0600
Subject: [PATCH 03/22] Update 60-remote-functions.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 documentation/docs/20-core-concepts/60-remote-functions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index d8582cc3b755..ef7420d9b2e5 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -1248,7 +1248,7 @@ export function handleValidationError({ event, issues }) {
 }
 ```
 
-The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with a `kind` of `'expected'`.
+The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with `kind: 'expected'`.
 
 If you know what you're doing and want to opt out of validation, you can pass the string `'unchecked'` in place of a schema:
 

From 759d302ae9871f2d13dad4c3d9aedd2027624e78 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:48:02 -0600
Subject: [PATCH 04/22] Update 20-hooks.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 documentation/docs/30-advanced/20-hooks.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 8100adc7f7a7..a709b838b058 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -177,7 +177,7 @@ export function handleValidationError({ issues }) {
 
 Be thoughtful about what information you expose here, as the most likely reason for validation to fail is that someone is sending malicious requests to your server.
 
-The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with a `kind` of `'expected'`.
+The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with `kind: 'expected'`.
 
 ## handleError
 

From 86223c8bb7f2605b269733f7d6e121d6cbf03b09 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:49:33 -0600
Subject: [PATCH 05/22] Update 20-hooks.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 documentation/docs/30-advanced/20-hooks.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index a709b838b058..36e36aefd577 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -196,7 +196,7 @@ Alongside the `event`, the hook receives a `kind` discriminant that tells you wh
 | `'unexpected'` | your code, or code it calls         | the thrown value, which may contain information unsafe to expose     | `{ status: 500, message: 'Internal Error' }` |
 | `'framework'`  | SvelteKit — 404s, 405s, 413s...     | `{ status, message }`, where `message` is safe text like `Not Found` | that same `{ status, message }`              |
 
-Errors from [`handleValidationError`](hooks#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
+Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
 
 The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are **optional** — return them only to override the defaults in the table above. Any property you omit is inherited from the caught error, so returning `{}` (or nothing at all) leaves the error untouched, while returning `{ status: 404 }` changes only the status.
 

From b283f0407c7b2b556e8886b27268c48e19a20a1a Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:51:05 -0600
Subject: [PATCH 06/22] Update 20-hooks.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 documentation/docs/30-advanced/20-hooks.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 36e36aefd577..9a5ed99b6053 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -198,7 +198,7 @@ Alongside the `event`, the hook receives a `kind` discriminant that tells you wh
 
 Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
 
-The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are **optional** — return them only to override the defaults in the table above. Any property you omit is inherited from the caught error, so returning `{}` (or nothing at all) leaves the error untouched, while returning `{ status: 404 }` changes only the status.
+The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are optional — return them only to override the defaults in the table above. Any property you omit is inherited from the caught error, so returning `{}` (or nothing at all) leaves the error untouched, while returning `{ status: 404 }` changes only the status.
 
 > [!NOTE] If you augment `App.Error` with additional _required_ properties, the hook must return them.
 

From 3d6672b265ef8d24d3156df54fd64f2241b236b2 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:52:19 -0600
Subject: [PATCH 07/22] Update 25-errors.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.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 68f293623321..ebd56058c53f 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -40,7 +40,7 @@ export async function load({ params }) {
 
 This throws an exception that SvelteKit catches, causing it to set the response status code to 404 and render an [`+error.svelte`](routing#error) component, where the `error` is an `App.Error` object with the provided `status` and `message`.
 
-On its way there, the error passes through the [`handleError`](hooks#handleError) hook with a `kind` of `'expected'`. Since the shape of an expected error is determined by you, it is considered safe to expose, and the hook can pass it through unchanged.
+On its way there, the error passes through the [`handleError`](hooks#handleError) hook with `kind: 'expected'`. Since the shape of an expected error is determined by you, it is considered safe to expose, and the hook can pass it through unchanged.
 
 ```svelte
 <!--- file: src/routes/+error.svelte --->

From ab1c7cc425c60d5129e471fdcea761ece23816fb Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:52:38 -0600
Subject: [PATCH 08/22] Update 25-errors.md

Co-authored-by: Rich Harris <richard.a.harris@gmail.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 ebd56058c53f..75923fa1a213 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -85,7 +85,7 @@ By default, unexpected errors are printed to the console (or, in production, you
 { "status": 500, "message": "Internal Error" }
 ```
 
-Like expected errors, unexpected errors go through the [`handleError`](hooks#handleError) hook — with a `kind` of `'unexpected'` — where you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. Unlike expected errors, the value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
+Like expected errors, unexpected errors go through the [`handleError`](hooks#handleError) hook — with `kind: 'unexpected'` — where you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. Unlike expected errors, the value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
 
 Anything you return overrides the defaults, so you can — for example — use the type of the thrown error to determine the HTTP status code used in the response:
 

From 63889ca7e04a32ccb0e327f7ae3f61da5c8ec6e5 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:53:07 -0600
Subject: [PATCH 09/22] Update errors.js

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 packages/kit/src/runtime/server/errors.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/kit/src/runtime/server/errors.js b/packages/kit/src/runtime/server/errors.js
index 087d990a045b..e877575f5747 100644
--- a/packages/kit/src/runtime/server/errors.js
+++ b/packages/kit/src/runtime/server/errors.js
@@ -56,11 +56,8 @@ export function handle_error_and_jsonify(event, state, options, error) {
 		caught = { kind: 'unexpected', error };
 	}
 
-	/** @type {App.Error} */
 	const fallback =
-		caught.kind === 'unexpected'
-			? /** @type {App.Error} */ ({ status: 500, message: 'Internal Error' })
-			: /** @type {App.Error} */ (caught.error);
+		caught.kind === 'unexpected' ? { status: 500, message: 'Internal Error' } : caught.error;
 
 	/**
 	 * The hook returns only the properties it wants to override; anything it omits

From 4ad379f27dd486cca33f9f68efb073acd756de32 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:54:04 -0600
Subject: [PATCH 10/22] Update client.js

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 packages/kit/src/runtime/client/client.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index a5639273f436..4531af040f39 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -2533,11 +2533,8 @@ export async function handle_error(error, event) {
 		console.warn('The next HMR update will cause the page to reload');
 	}
 
-	/** @type {App.Error} */
 	const fallback =
-		caught.kind === 'unexpected'
-			? /** @type {App.Error} */ ({ status: 500, message: 'Internal Error' })
-			: /** @type {App.Error} */ (caught.error);
+		caught.kind === 'unexpected' ? { status: 500, message: 'Internal Error' } : caught.error;
 
 	const app_error = await app.hooks.handleError({ ...caught, event });
 

From 31ee6f9f18add57a51c9bd38e42bd36eb1923e85 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello@ell.iott.dev>
Date: Wed, 5 Aug 2026 21:54:24 -0600
Subject: [PATCH 11/22] Update hooks.server.js

Co-authored-by: Rich Harris <richard.a.harris@gmail.com>
---
 packages/kit/test/apps/basics/src/hooks.server.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index c62f7a53b91e..71e8d852fe32 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -29,8 +29,7 @@ export function error_to_pojo(error) {
 }
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
-export const handleError = (input) => {
-	const { event, kind } = input;
+export const handleError = ({ event, kind, error }) => {
 
 	// TODO we do this because there's no other way (that i'm aware of)
 	// to communicate errors back to the test suite. even if we could

From 860a0ce7f4016ab074af3790ab48a9b36db3e0e3 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 11:46:15 -0600
Subject: [PATCH 12/22] misc feedback

---
 documentation/docs/30-advanced/20-hooks.md    |  2 +-
 .../runtime/app/server/remote/prerender.js    |  4 +--
 .../app/server/remote/prerender.spec.js       | 17 ++++++++--
 packages/kit/src/runtime/client/client.js     |  6 +++-
 packages/kit/src/runtime/server/errors.js     | 19 +++++++-----
 packages/kit/src/utils/error.js               | 31 +++++++++++++++++++
 packages/kit/src/utils/error.spec.js          | 23 ++++++++++++--
 .../test/apps/dev-only/src/hooks.client.js    |  6 ++--
 8 files changed, 90 insertions(+), 18 deletions(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 9a5ed99b6053..e120918504d5 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -198,7 +198,7 @@ Alongside the `event`, the hook receives a `kind` discriminant that tells you wh
 
 Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
 
-The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are optional — return them only to override the defaults in the table above. Any property you omit is inherited from the caught error, so returning `{}` (or nothing at all) leaves the error untouched, while returning `{ status: 404 }` changes only the status.
+The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are optional — return them only to override the defaults in the table above.
 
 > [!NOTE] If you augment `App.Error` with additional _required_ properties, the hook must return them.
 
diff --git a/packages/kit/src/runtime/app/server/remote/prerender.js b/packages/kit/src/runtime/app/server/remote/prerender.js
index 30f753250141..487ac75efa66 100644
--- a/packages/kit/src/runtime/app/server/remote/prerender.js
+++ b/packages/kit/src/runtime/app/server/remote/prerender.js
@@ -2,7 +2,7 @@
 /** @import { RemoteFunctionResponse, RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { json } from '@sveltejs/kit';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { stringify_remote_arg } from '../../../shared.js';
 import { parse, stringify } from '#app/internal/transport';
@@ -114,7 +114,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 
 				if (prerendered) {
 					if (prerendered.type === 'error') {
-						throw new HttpError(prerendered.error);
+						throw new HandledHttpError(prerendered.error);
 					}
 
 					return parse(prerendered.data)._;
diff --git a/packages/kit/src/runtime/app/server/remote/prerender.spec.js b/packages/kit/src/runtime/app/server/remote/prerender.spec.js
index af081f361357..23f9a69e9030 100644
--- a/packages/kit/src/runtime/app/server/remote/prerender.spec.js
+++ b/packages/kit/src/runtime/app/server/remote/prerender.spec.js
@@ -1,7 +1,7 @@
 /** @import { RequestEvent } from '@sveltejs/kit' */
 /** @import { RequestState } from 'types' */
 import { expect, test, vi } from 'vitest';
-import { HttpError } from '@sveltejs/kit/internal';
+import { HandledHttpError } from '@sveltejs/kit/internal';
 import { prerender } from './prerender.js';
 import { init_transport, stringify } from '#app/internal/transport';
 
@@ -19,6 +19,8 @@ vi.mock(import('@sveltejs/kit/internal/server'), async (actualPromise) => {
 
 vi.stubGlobal('__SVELTEKIT_DEV__', false);
 
+const { handle_error_and_jsonify } = await import('../../../server/errors.js');
+
 /**
  * Creates a prerender function whose self-fetch of the prerendered response
  * resolves as specified, mimicking the production SSR path
@@ -61,10 +63,21 @@ test('propagates an error response instead of running the function', async () =>
 
 	const rejection = await wrapper().catch((e) => e);
 
-	expect(rejection).toBeInstanceOf(HttpError);
+	expect(rejection).toBeInstanceOf(HandledHttpError);
 	expect(rejection.status).toBe(418);
 	expect(rejection.body).toEqual({ status: 418, message: 'teapot' });
 	expect(fn).not.toHaveBeenCalled();
+
+	const handleError = vi.fn();
+	const transformed = await handle_error_and_jsonify(
+		store.current.event,
+		store.current.state,
+		/** @type {any} */ ({ hooks: { handleError } }),
+		rejection
+	);
+
+	expect(transformed).toBe(rejection.body);
+	expect(handleError).not.toHaveBeenCalled();
 });
 
 test('parses a prerendered result without running the function', async () => {
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 4531af040f39..78a1440c2055 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -40,6 +40,7 @@ import {
 	restore_navigation_snapshot
 } from './snapshots.js';
 import { validate_page_exports } from '../../utils/exports.js';
+import { add_deprecated_handle_error_properties } from '../../utils/error.js';
 import { noop } from '../../utils/functions.js';
 import {
 	INVALIDATED_PARAM,
@@ -2536,7 +2537,10 @@ export async function handle_error(error, event) {
 	const fallback =
 		caught.kind === 'unexpected' ? { status: 500, message: 'Internal Error' } : caught.error;
 
-	const app_error = await app.hooks.handleError({ ...caught, event });
+	const input = { ...caught, event };
+	if (DEV) add_deprecated_handle_error_properties(input, fallback);
+
+	const app_error = await app.hooks.handleError(input);
 
 	// the hook returns only the properties it wants to override; anything it omits
 	// (including by returning nothing at all) is inherited from the caught error
diff --git a/packages/kit/src/runtime/server/errors.js b/packages/kit/src/runtime/server/errors.js
index e877575f5747..e8df88c0d431 100644
--- a/packages/kit/src/runtime/server/errors.js
+++ b/packages/kit/src/runtime/server/errors.js
@@ -1,7 +1,7 @@
 import { json, text } from '@sveltejs/kit';
-import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
+import { HandledHttpError, HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store } from '@sveltejs/kit/internal/server';
-import { coalesce_to_error } from '../../utils/error.js';
+import { add_deprecated_handle_error_properties, coalesce_to_error } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
 import { fix_stack_trace } from './internal.js';
 import { escape_html } from '../../utils/escape.js';
@@ -39,6 +39,10 @@ export async function handle_fatal_error(event, state, options, error) {
  * @returns {App.Error | Promise<App.Error>}
  */
 export function handle_error_and_jsonify(event, state, options, error) {
+	if (error instanceof HandledHttpError) {
+		return error.body;
+	}
+
 	/** @type {import('@sveltejs/kit').CaughtError} */
 	let caught;
 
@@ -47,13 +51,13 @@ export function handle_error_and_jsonify(event, state, options, error) {
 	} else if (error instanceof SvelteKitError) {
 		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
 	} else {
+		caught = { kind: 'unexpected', error };
+
 		let e = error;
 		while (e instanceof Error) {
 			fix_stack_trace(e);
 			e = e.cause;
 		}
-
-		caught = { kind: 'unexpected', error };
 	}
 
 	const fallback =
@@ -72,9 +76,10 @@ export function handle_error_and_jsonify(event, state, options, error) {
 	// TODO 4.0 await this, rather than handling the non-Promise case
 	let result;
 	try {
-		result = with_request_store({ event, state }, () =>
-			options.hooks.handleError({ ...caught, event })
-		);
+		const input = { ...caught, event };
+		if (__SVELTEKIT_DEV__) add_deprecated_handle_error_properties(input, fallback);
+
+		result = with_request_store({ event, state }, () => options.hooks.handleError(input));
 	} catch (hook_error) {
 		log_handle_error_hook_failure(error, hook_error);
 		return { status: fallback.status, message: 'Internal Error' };
diff --git a/packages/kit/src/utils/error.js b/packages/kit/src/utils/error.js
index f818898dadd3..4b77b7cd5985 100644
--- a/packages/kit/src/utils/error.js
+++ b/packages/kit/src/utils/error.js
@@ -41,3 +41,34 @@ export function normalize_error(error) {
 export function get_status(error) {
 	return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
 }
+
+/**
+ * Adds development-only compatibility accessors for the former top-level `status` and `message`
+ * properties of the `handleError` hook input.
+ * @template {object} T
+ * @param {T} input
+ * @param {{ status: number; message: string }} fallback
+ * @returns {T}
+ */
+export function add_deprecated_handle_error_properties(input, fallback) {
+	Object.defineProperties(input, {
+		status: {
+			get() {
+				console.warn(
+					'The `status` property of `handleError` is deprecated. Use `error.status` for expected and framework errors, or `500` for unexpected errors.'
+				);
+				return fallback.status;
+			}
+		},
+		message: {
+			get() {
+				console.warn(
+					"The `message` property of `handleError` is deprecated. Use `error.message` for expected and framework errors, or 'Internal Error' for unexpected errors."
+				);
+				return fallback.message;
+			}
+		}
+	});
+
+	return input;
+}
diff --git a/packages/kit/src/utils/error.spec.js b/packages/kit/src/utils/error.spec.js
index fc4291921f61..1d8147f4d33d 100644
--- a/packages/kit/src/utils/error.spec.js
+++ b/packages/kit/src/utils/error.spec.js
@@ -1,6 +1,6 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
-import { get_status } from './error.js';
+import { add_deprecated_handle_error_properties, get_status } from './error.js';
 
 describe('get_status', () => {
 	it('returns the status of an HttpError', () => {
@@ -20,3 +20,22 @@ describe('get_status', () => {
 		expect(get_status(undefined)).toBe(500);
 	});
 });
+
+describe('add_deprecated_handle_error_properties', () => {
+	it('adds non-enumerable accessors that warn and return the fallback values', () => {
+		const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+		const input = add_deprecated_handle_error_properties(
+			{ kind: 'unexpected', error: new Error('nope') },
+			{ status: 500, message: 'Internal Error' }
+		);
+
+		expect(Object.keys(input)).toEqual(['kind', 'error']);
+		expect(/** @type {any} */ (input).status).toBe(500);
+		expect(/** @type {any} */ (input).message).toBe('Internal Error');
+		expect(warn).toHaveBeenCalledTimes(2);
+		expect(warn.mock.calls[0][0]).toContain('Use `error.status`');
+		expect(warn.mock.calls[1][0]).toContain('Use `error.message`');
+
+		warn.mockRestore();
+	});
+});
diff --git a/packages/kit/test/apps/dev-only/src/hooks.client.js b/packages/kit/test/apps/dev-only/src/hooks.client.js
index 47b6221d307a..02c45be2102d 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.client.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.client.js
@@ -3,7 +3,7 @@ import cjs from 'e2e-test-dep-hooks-client';
 cjs.cjs();
 
 /** @type {import("@sveltejs/kit").HandleClientError} */
-export function handleError(input) {
-	if (input.kind !== 'unexpected') return input.error;
-	return { message: /**@type{any}*/ (input.error).message };
+export function handleError({ kind, error }) {
+	if (kind !== 'unexpected') return error;
+	return { message: /**@type{any}*/ (error).message };
 }

From 7e3f7f78ee06093480904b661705029300b8a233 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 11:47:47 -0600
Subject: [PATCH 13/22] docs

---
 documentation/docs/30-advanced/20-hooks.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index e120918504d5..141a4262b1a6 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -202,14 +202,13 @@ The hook returns an object matching [`App.Error`](types#Error), in which `status
 
 > [!NOTE] If you augment `App.Error` with additional _required_ properties, the hook must return them.
 
-To add more information to the `page.error` object in a type-safe way, you can customize the expected shape by declaring an `App.Error` interface (which must include `status: number` and `message: string`, to guarantee sensible fallback behavior). This allows you to — for example — append a tracking ID for users to quote in correspondence with your technical support staff:
+To add more information to the `page.error` object in a type-safe way, augment the existing `App.Error` interface with your additional properties. The built-in `status` and `message` properties are already present and do not need to be redeclared. For example, you can add a tracking ID for users to quote when contacting support:
 
 ```ts
 /// file: src/app.d.ts
 declare global {
 	namespace App {
 		interface Error {
-			message: string;
 			errorId: string;
 		}
 	}
@@ -251,7 +250,7 @@ export async function handleError({ kind, error, event }) {
 
 	// example integration with https://sentry.io/
 	Sentry.captureException(error, {
-		extra: { event, errorId, status }
+		extra: { event, errorId }
 	});
 
 	// `status` and `message` are optional — we only override `message`,

From 75302df52910517ac9a88c2ca86add46f4464641 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 11:48:57 -0600
Subject: [PATCH 14/22] misc

---
 packages/kit/test/apps/dev-only/src/hooks.server.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/kit/test/apps/dev-only/src/hooks.server.js b/packages/kit/test/apps/dev-only/src/hooks.server.js
index 461c390c390a..890c28788b65 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.server.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.server.js
@@ -1,5 +1,5 @@
 /** @type {import("@sveltejs/kit").HandleServerError} */
-export function handleError(input) {
-	if (input.kind !== 'unexpected') return input.error;
-	return { message: /**@type{any}*/ (input.error).message };
+export function handleError({ kind, error }) {
+	if (kind !== 'unexpected') return error;
+	return { message: /**@type{any}*/ (error).message };
 }

From d8088bef660cd703fc245427499704580cfd5551 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 11:50:08 -0600
Subject: [PATCH 15/22] references

---
 packages/kit/test/apps/basics/src/hooks.server.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index 71e8d852fe32..e0ce9d98277f 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -41,20 +41,20 @@ export const handleError = ({ event, kind, error }) => {
 			path: event.url.pathname,
 			kind,
 			error:
-				kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (input.error)) : input.error
+				kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (error)) : error
 		}) + '\n'
 	);
 
 	if (kind === 'expected') {
 		// so that `error(...)` bodies reach the page verbatim
-		return input.error;
+		return error;
 	}
 
-	const status = kind === 'framework' ? input.error.status : 500;
+	const status = kind === 'framework' ? error.status : 500;
 	const detail =
-		kind === 'framework' ? input.error.message : /** @type {Error} */ (input.error).message;
+		kind === 'framework' ? error.message : /** @type {Error} */ (error).message;
 
-	let message = kind === 'framework' ? input.error.message : 'Internal Error';
+	let message = kind === 'framework' ? error.message : 'Internal Error';
 
 	if (event.url.pathname.startsWith('/get-request-event/')) {
 		const ev = getRequestEvent();

From 2de710a9c145a4365134e8354ef2f654f5318be5 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 12:04:07 -0600
Subject: [PATCH 16/22] bah

---
 documentation/docs/30-advanced/20-hooks.md | 22 +++++++++------
 packages/kit/src/exports/public.d.ts       | 33 +++++++++-------------
 packages/kit/types/index.d.ts              | 33 +++++++++-------------
 3 files changed, 41 insertions(+), 47 deletions(-)

diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 141a4262b1a6..db4b0377374b 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -190,15 +190,19 @@ This function is called for _every_ error thrown while loading, rendering, or re
 
 Alongside the `event`, the hook receives a `kind` discriminant that tells you where the error came from, and the `error` itself:
 
-| `kind`         | thrown by                           | `error`                                                              | defaults to                                  |
-| -------------- | ----------------------------------- | -------------------------------------------------------------------- | -------------------------------------------- |
-| `'expected'`   | [`error(...)`](@sveltejs-kit#error) | the error body, which matches [`App.Error`](types#Error)             | the error body itself                        |
-| `'unexpected'` | your code, or code it calls         | the thrown value, which may contain information unsafe to expose     | `{ status: 500, message: 'Internal Error' }` |
-| `'framework'`  | SvelteKit — 404s, 405s, 413s...     | `{ status, message }`, where `message` is safe text like `Not Found` | that same `{ status, message }`              |
-
-Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
-
-The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are optional — return them only to override the defaults in the table above.
+- `'expected'` — thrown with [`error(...)`](@sveltejs-kit#error)
+  - `error` is the error body, which matches [`App.Error`](types#Error)
+  - defaults to the error body itself
+- `'unexpected'` — thrown by your code, or code it calls
+  - `error` is the thrown value, which may contain information unsafe to expose
+  - defaults to `{ status: 500, message: 'Internal Error' }`
+- `'framework'` — generated by SvelteKit, such as 404s, 405s and 413s
+  - `error` is `{ status, message }`, where `message` is safe text like `Not Found`
+  - defaults to that same `{ status, message }`
+
+The next section, [Errors](errors), explains these categories in more detail. Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
+
+The hook returns an object matching [`App.Error`](types#Error), in which `status` and `message` are optional — return them only to override the defaults in the list above.
 
 > [!NOTE] If you augment `App.Error` with additional _required_ properties, the hook must return them.
 
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index c42f04aa0922..9b2cbc64a685 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -961,6 +961,12 @@ export type Handle = (input: {
 	resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
 }) => MaybePromise<Response>;
 
+type CaughtErrorMap = {
+	expected: App.Error;
+	unexpected: unknown;
+	framework: { status: number; message: string };
+};
+
 /**
  * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
  * Use the `kind` discriminant to distinguish expected errors (thrown with the
@@ -968,25 +974,14 @@ export type Handle = (input: {
  * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
  * itself, such as 404s).
  */
-export type CaughtError =
-	| {
-			/** An expected error, thrown with the `error` helper */
-			kind: 'expected';
-			/** The error body, as passed to `error(...)` */
-			error: App.Error;
-	  }
-	| {
-			/** An unexpected error, thrown by your app without the `error` helper */
-			kind: 'unexpected';
-			/** The thrown value. Contents may be unsafe to expose to users */
-			error: unknown;
-	  }
-	| {
-			/** An error generated by SvelteKit itself, such as a 404 */
-			kind: 'framework';
-			/** The status and a safe description of the error */
-			error: { status: number; message: string };
-	  };
+export type CaughtError = {
+	[Kind in keyof CaughtErrorMap]: {
+		/** Identifies the category and origin of the error */
+		kind: Kind;
+		/** The caught error. Its type depends on `kind` */
+		error: CaughtErrorMap[Kind];
+	};
+}[keyof CaughtErrorMap];
 
 /**
  * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 26c8a3bae239..d47bc5df1b4d 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -937,6 +937,12 @@ declare module '@sveltejs/kit' {
 		resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
 	}) => MaybePromise<Response>;
 
+	type CaughtErrorMap = {
+		expected: App.Error;
+		unexpected: unknown;
+		framework: { status: number; message: string };
+	};
+
 	/**
 	 * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
 	 * Use the `kind` discriminant to distinguish expected errors (thrown with the
@@ -944,25 +950,14 @@ declare module '@sveltejs/kit' {
 	 * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
 	 * itself, such as 404s).
 	 */
-	export type CaughtError =
-		| {
-				/** An expected error, thrown with the `error` helper */
-				kind: 'expected';
-				/** The error body, as passed to `error(...)` */
-				error: App.Error;
-		  }
-		| {
-				/** An unexpected error, thrown by your app without the `error` helper */
-				kind: 'unexpected';
-				/** The thrown value. Contents may be unsafe to expose to users */
-				error: unknown;
-		  }
-		| {
-				/** An error generated by SvelteKit itself, such as a 404 */
-				kind: 'framework';
-				/** The status and a safe description of the error */
-				error: { status: number; message: string };
-		  };
+	export type CaughtError = {
+		[Kind in keyof CaughtErrorMap]: {
+			/** Identifies the category and origin of the error */
+			kind: Kind;
+			/** The caught error. Its type and safety depend on `kind`; narrow on `kind` before using it */
+			error: CaughtErrorMap[Kind];
+		};
+	}[keyof CaughtErrorMap];
 
 	/**
 	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.

From 796f10df8a17580c366378ec10808d4ab4e6b064 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 13:09:01 -0600
Subject: [PATCH 17/22] lint

---
 .../client/remote-functions/shared.transport.spec.js       | 4 +---
 packages/kit/test/apps/basics/src/hooks.server.js          | 7 ++-----
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js b/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
index 9052333b5645..cf6a58a6f879 100644
--- a/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
+++ b/packages/kit/src/runtime/client/remote-functions/shared.transport.spec.js
@@ -60,9 +60,7 @@ describe('remote_request transport error handling', () => {
 
 		await expect(remote_request('/x')).rejects.toSatisfy((e) => {
 			return (
-				e instanceof HandledHttpError &&
-				e.status === 401 &&
-				e.body?.message === 'unauthorized'
+				e instanceof HandledHttpError && e.status === 401 && e.body?.message === 'unauthorized'
 			);
 		});
 	});
diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index e0ce9d98277f..5006f96d273a 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -30,7 +30,6 @@ export function error_to_pojo(error) {
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
 export const handleError = ({ event, kind, error }) => {
-
 	// TODO we do this because there's no other way (that i'm aware of)
 	// to communicate errors back to the test suite. even if we could
 	// capture stderr, attributing an error to a specific request
@@ -40,8 +39,7 @@ export const handleError = ({ event, kind, error }) => {
 		JSON.stringify({
 			path: event.url.pathname,
 			kind,
-			error:
-				kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (error)) : error
+			error: kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (error)) : error
 		}) + '\n'
 	);
 
@@ -51,8 +49,7 @@ export const handleError = ({ event, kind, error }) => {
 	}
 
 	const status = kind === 'framework' ? error.status : 500;
-	const detail =
-		kind === 'framework' ? error.message : /** @type {Error} */ (error).message;
+	const detail = kind === 'framework' ? error.message : /** @type {Error} */ (error).message;
 
 	let message = kind === 'framework' ? error.message : 'Internal Error';
 

From e29e997c1440ff897d989c5ddd7c2a99692eb206 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 13:09:55 -0600
Subject: [PATCH 18/22] types

---
 packages/kit/types/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index d47bc5df1b4d..17db273e79d4 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -954,7 +954,7 @@ declare module '@sveltejs/kit' {
 		[Kind in keyof CaughtErrorMap]: {
 			/** Identifies the category and origin of the error */
 			kind: Kind;
-			/** The caught error. Its type and safety depend on `kind`; narrow on `kind` before using it */
+			/** The caught error. Its type depends on `kind` */
 			error: CaughtErrorMap[Kind];
 		};
 	}[keyof CaughtErrorMap];

From 21ba8e98f09968b16441032c446f9bfb5ffdfb54 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Thu, 6 Aug 2026 13:11:04 -0600
Subject: [PATCH 19/22] ugh

---
 packages/kit/src/runtime/server/index.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index 32aa03024e1b..c28173c4712f 100644
--- a/packages/kit/src/runtime/server/index.js
+++ b/packages/kit/src/runtime/server/index.js
@@ -5,11 +5,9 @@ import { create_request_state } from './state.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
 import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
 import { set_env } from '__sveltekit/env';
-import { SvelteKitError } from '@sveltejs/kit/internal';
 import { init_tracing } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
 import { init_transport } from '#app/internal/transport';
-import { set_app } from './app.js';
 
 /** @type {Promise<any>} */
 let init_promise;

From 495e1e7d856bf7c415b5e1c91782e94cef5018e1 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Fri, 7 Aug 2026 11:36:36 -0600
Subject: [PATCH 20/22] test: add handleError kind routes

---
 .../kit/test/apps/basics/src/routes/errors/kind/+page.svelte | 2 ++
 .../apps/basics/src/routes/errors/kind/expected/+page.js     | 5 +++++
 .../apps/basics/src/routes/errors/kind/unexpected/+page.js   | 3 +++
 3 files changed, 10 insertions(+)
 create mode 100644 packages/kit/test/apps/basics/src/routes/errors/kind/+page.svelte
 create mode 100644 packages/kit/test/apps/basics/src/routes/errors/kind/expected/+page.js
 create mode 100644 packages/kit/test/apps/basics/src/routes/errors/kind/unexpected/+page.js

diff --git a/packages/kit/test/apps/basics/src/routes/errors/kind/+page.svelte b/packages/kit/test/apps/basics/src/routes/errors/kind/+page.svelte
new file mode 100644
index 000000000000..9809a6234203
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/errors/kind/+page.svelte
@@ -0,0 +1,2 @@
+<a href="/errors/kind/expected">expected</a>
+<a href="/errors/kind/unexpected">unexpected</a>
diff --git a/packages/kit/test/apps/basics/src/routes/errors/kind/expected/+page.js b/packages/kit/test/apps/basics/src/routes/errors/kind/expected/+page.js
new file mode 100644
index 000000000000..627bd119fda8
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/errors/kind/expected/+page.js
@@ -0,0 +1,5 @@
+import { error } from '@sveltejs/kit';
+
+export function load() {
+	error(403, 'expected error');
+}
diff --git a/packages/kit/test/apps/basics/src/routes/errors/kind/unexpected/+page.js b/packages/kit/test/apps/basics/src/routes/errors/kind/unexpected/+page.js
new file mode 100644
index 000000000000..067deb872b8b
--- /dev/null
+++ b/packages/kit/test/apps/basics/src/routes/errors/kind/unexpected/+page.js
@@ -0,0 +1,3 @@
+export function load() {
+	throw new Error('unexpected error');
+}

From 51bcaa74a5c02e3a5f9ce8ec815572676764ea6a Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Mon, 10 Aug 2026 09:00:44 -0600
Subject: [PATCH 21/22] update names

---
 .../20-core-concepts/60-remote-functions.md   |  2 +-
 .../docs/30-advanced/10-advanced-routing.md   |  2 +-
 documentation/docs/30-advanced/20-hooks.md    | 16 +++++------
 documentation/docs/30-advanced/25-errors.md   | 12 ++++-----
 .../src/core/sync/write_client_manifest.js    |  2 +-
 packages/kit/src/exports/public.d.ts          | 27 +++++++++----------
 packages/kit/src/runtime/client/client.js     |  8 +++---
 packages/kit/src/runtime/server/errors.js     |  6 ++---
 packages/kit/src/runtime/server/index.js      |  2 +-
 packages/kit/src/utils/error.spec.js          |  2 +-
 .../kit/test/apps/async/src/hooks.client.js   |  2 +-
 .../kit/test/apps/async/src/hooks.server.js   |  2 +-
 .../kit/test/apps/basics/src/hooks.client.js  |  2 +-
 .../kit/test/apps/basics/src/hooks.server.js  |  4 +--
 .../basics/test/cross-platform/client.test.js |  4 +--
 .../apps/basics/test/cross-platform/test.js   | 20 +++++++-------
 .../kit/test/apps/basics/test/server.test.js  |  4 +--
 .../test/apps/dev-only/src/hooks.client.js    |  2 +-
 .../test/apps/dev-only/src/hooks.server.js    |  2 +-
 .../types/app-error-enhanced/error.test.ts    |  2 +-
 packages/kit/test/types/error.test.ts         |  2 +-
 packages/kit/types/index.d.ts                 | 27 +++++++++----------
 22 files changed, 75 insertions(+), 77 deletions(-)

diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index ef7420d9b2e5..132d82e54bdb 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -1248,7 +1248,7 @@ export function handleValidationError({ event, issues }) {
 }
 ```
 
-The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with `kind: 'expected'`.
+The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with `kind: 'app'`.
 
 If you know what you're doing and want to opt out of validation, you can pass the string `'unchecked'` in place of a schema:
 
diff --git a/documentation/docs/30-advanced/10-advanced-routing.md b/documentation/docs/30-advanced/10-advanced-routing.md
index 7048f9d6bc2b..e947b35e2017 100644
--- a/documentation/docs/30-advanced/10-advanced-routing.md
+++ b/documentation/docs/30-advanced/10-advanced-routing.md
@@ -61,7 +61,7 @@ export function load(event) {
 }
 ```
 
-> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError) as [framework errors](errors#Framework-errors), with `kind: 'framework'`. Otherwise, they will appear with `kind: 'expected'`.
+> [!NOTE] If you don't handle 404 cases, they will appear in [`handleError`](hooks#handleError) as [framework errors](errors#Framework-errors), with `kind: 'framework'`. Otherwise, they will appear with `kind: 'app'`.
 
 ## Optional parameters
 
diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index db4b0377374b..0fcc64944292 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -177,7 +177,7 @@ export function handleValidationError({ issues }) {
 
 Be thoughtful about what information you expose here, as the most likely reason for validation to fail is that someone is sending malicious requests to your server.
 
-The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with `kind: 'expected'`.
+The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with `kind: 'app'`.
 
 ## handleError
 
@@ -190,15 +190,15 @@ This function is called for _every_ error thrown while loading, rendering, or re
 
 Alongside the `event`, the hook receives a `kind` discriminant that tells you where the error came from, and the `error` itself:
 
-- `'expected'` — thrown with [`error(...)`](@sveltejs-kit#error)
+- `'app'` — the error came from your app via [`error(...)`](@sveltejs-kit#error)
   - `error` is the error body, which matches [`App.Error`](types#Error)
   - defaults to the error body itself
-- `'unexpected'` — thrown by your code, or code it calls
-  - `error` is the thrown value, which may contain information unsafe to expose
-  - defaults to `{ status: 500, message: 'Internal Error' }`
-- `'framework'` — generated by SvelteKit, such as 404s, 405s and 413s
+- `'framework'` — the error came from SvelteKit, such as a 404, 405 or 413
   - `error` is `{ status, message }`, where `message` is safe text like `Not Found`
   - defaults to that same `{ status, message }`
+- `'unknown'` — we don't know what went wrong; the error was thrown by your code, or code it calls
+  - `error` is the thrown value, which may contain information unsafe to expose
+  - defaults to `{ status: 500, message: 'Internal Error' }`
 
 The next section, [Errors](errors), explains these categories in more detail. Errors from [`handleValidationError`](#handleValidationError) arrive as _expected_ errors. Redirects are not errors, and never reach the hook.
 
@@ -238,7 +238,7 @@ Sentry.init({/*...*/})
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
 export async function handleError({ kind, error, event }) {
-	if (kind === 'expected') {
+	if (kind === 'app') {
 		// you created this error with `error(...)`, so it already
 		// matches `App.Error` — pass it through unchanged
 		return error;
@@ -283,7 +283,7 @@ Sentry.init({/*...*/})
 
 /** @type {import('@sveltejs/kit').HandleClientError} */
 export async function handleError({ kind, error, event }) {
-	if (kind === 'expected') {
+	if (kind === 'app') {
 		return error;
 	}
 
diff --git a/documentation/docs/30-advanced/25-errors.md b/documentation/docs/30-advanced/25-errors.md
index 75923fa1a213..bb001e9b9c13 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -6,7 +6,7 @@ Errors are an inevitable fact of software development. SvelteKit handles errors
 
 ## Error objects
 
-SvelteKit distinguishes between expected errors, unexpected errors, and errors generated by the framework itself, all of which are represented as simple `{ status: number, message: string }` objects by default. Whichever kind it is, every error passes through the [`handleError`](hooks#handleError) hook — which can log it, and customise it — before it is rendered.
+Every error passes through the [`handleError`](hooks#handleError) hook — which can log it and customise it — before it is rendered. The hook's `kind` property identifies where the error came from: your app (`'app'`), SvelteKit (`'framework'`) or an unknown source (`'unknown'`). By default, all are represented as simple `{ status: number, message: string }` objects.
 
 You can add additional properties, like a `code` or a tracking `id`, as shown in the examples below. (When using TypeScript this requires you to redefine the `Error` type as described in  [type safety](errors#Type-safety)).
 
@@ -40,7 +40,7 @@ export async function load({ params }) {
 
 This throws an exception that SvelteKit catches, causing it to set the response status code to 404 and render an [`+error.svelte`](routing#error) component, where the `error` is an `App.Error` object with the provided `status` and `message`.
 
-On its way there, the error passes through the [`handleError`](hooks#handleError) hook with `kind: 'expected'`. Since the shape of an expected error is determined by you, it is considered safe to expose, and the hook can pass it through unchanged.
+On its way there, the error passes through the [`handleError`](hooks#handleError) hook with `kind: 'app'`. Since the shape of the error is determined by your app, it is considered safe to expose, and the hook can pass it through unchanged.
 
 ```svelte
 <!--- file: src/routes/+error.svelte --->
@@ -85,7 +85,7 @@ By default, unexpected errors are printed to the console (or, in production, you
 { "status": 500, "message": "Internal Error" }
 ```
 
-Like expected errors, unexpected errors go through the [`handleError`](hooks#handleError) hook — with `kind: 'unexpected'` — where you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. Unlike expected errors, the value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
+Unexpected errors go through the [`handleError`](hooks#handleError) hook with `kind: 'unknown'`, because SvelteKit does not know what went wrong. There you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. The value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
 
 Anything you return overrides the defaults, so you can — for example — use the type of the thrown error to determine the HTTP status code used in the response:
 
@@ -96,7 +96,7 @@ class NotFound extends Error {}
 
 /** @type {import('@sveltejs/kit').HandleServerError} */
 export function handleError({ kind, error, event }) {
-	if (kind === 'unexpected') {
+	if (kind === 'unknown') {
 		// ... you can do this
 		if (error instanceof NotFound) {
 			return {
@@ -108,7 +108,7 @@ export function handleError({ kind, error, event }) {
 		return { message: 'Something went wrong' };
 	}
 
-	// expected and framework errors are already safe to expose
+	// app and framework errors are already safe to expose
 	return error;
 }
 ```
@@ -119,7 +119,7 @@ Some errors are generated by SvelteKit itself rather than by your code — a req
 
 These also go through `handleError`, with a `kind` of `'framework'`. The `error` you receive is a `{ status, message }` object whose `message` is a terse but safe description of what went wrong, such as `'Not Found'`, so it can be exposed to users as-is.
 
-If you log errors inside `handleError`, remember that 404s are routine — you will usually want to gate logging on `kind === 'unexpected'`.
+If you log errors inside `handleError`, remember that framework errors such as 404s are routine — you will usually want to gate logging on `kind === 'unknown'`.
 
 ## Error boundaries
 
diff --git a/packages/kit/src/core/sync/write_client_manifest.js b/packages/kit/src/core/sync/write_client_manifest.js
index 3d93a77b9318..a25ab6c2f522 100644
--- a/packages/kit/src/core/sync/write_client_manifest.js
+++ b/packages/kit/src/core/sync/write_client_manifest.js
@@ -155,7 +155,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			export const hooks = {
 				handleError: ${
 					client_hooks_file ? 'client_hooks.handleError || ' : ''
-				}(({ kind, error }) => { if (kind === 'unexpected') { console.error(error); } }),
+				}(({ kind, error }) => { if (kind === 'unknown') { console.error(error); } }),
 				${client_hooks_file ? 'init: client_hooks.init,' : ''}
 				reroute: ${universal_hooks_file ? 'universal_hooks.reroute || ' : ''}(() => {}),
 				transport: ${universal_hooks_file ? 'universal_hooks.transport || ' : ''}{}
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 9b2cbc64a685..3787996c32da 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -962,17 +962,16 @@ export type Handle = (input: {
 }) => MaybePromise<Response>;
 
 type CaughtErrorMap = {
-	expected: App.Error;
-	unexpected: unknown;
+	app: App.Error;
 	framework: { status: number; message: string };
+	unknown: unknown;
 };
 
 /**
  * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
- * Use the `kind` discriminant to distinguish expected errors (thrown with the
- * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), unexpected errors
- * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
- * itself, such as 404s).
+ * Use the `kind` discriminant to distinguish errors from your app (thrown with the
+ * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), errors generated by
+ * SvelteKit itself (such as 404s), and unknown errors (thrown by your code, or code it calls).
  */
 export type CaughtError = {
 	[Kind in keyof CaughtErrorMap]: {
@@ -986,12 +985,12 @@ export type CaughtError = {
 /**
  * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
  *
- * The `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
- * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
  *
  * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
- * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
- * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
  * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
  *
  * Make sure that this function _never_ throws an error.
@@ -1012,12 +1011,12 @@ export type HandleValidationError<Issue extends StandardSchemaV1.Issue = Standar
  * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
  * Errors that were already transformed by the server-side hook are not passed to it a second time.
  *
- * The `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
- * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
  *
  * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
- * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
- * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
  * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
  *
  * Make sure that this function _never_ throws an error.
diff --git a/packages/kit/src/runtime/client/client.js b/packages/kit/src/runtime/client/client.js
index 78a1440c2055..16a6dd83c9e0 100644
--- a/packages/kit/src/runtime/client/client.js
+++ b/packages/kit/src/runtime/client/client.js
@@ -2522,20 +2522,20 @@ export async function handle_error(error, event) {
 	let caught;
 
 	if (error instanceof HttpError) {
-		caught = { kind: 'expected', error: error.body };
+		caught = { kind: 'app', error: error.body };
 	} else if (error instanceof SvelteKitError) {
 		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
 	} else {
-		caught = { kind: 'unexpected', error };
+		caught = { kind: 'unknown', error };
 	}
 
-	if (DEV && caught.kind !== 'expected') {
+	if (DEV && caught.kind !== 'app') {
 		errored = true;
 		console.warn('The next HMR update will cause the page to reload');
 	}
 
 	const fallback =
-		caught.kind === 'unexpected' ? { status: 500, message: 'Internal Error' } : caught.error;
+		caught.kind === 'unknown' ? { status: 500, message: 'Internal Error' } : caught.error;
 
 	const input = { ...caught, event };
 	if (DEV) add_deprecated_handle_error_properties(input, fallback);
diff --git a/packages/kit/src/runtime/server/errors.js b/packages/kit/src/runtime/server/errors.js
index e8df88c0d431..096e00d2ee0e 100644
--- a/packages/kit/src/runtime/server/errors.js
+++ b/packages/kit/src/runtime/server/errors.js
@@ -47,11 +47,11 @@ export function handle_error_and_jsonify(event, state, options, error) {
 	let caught;
 
 	if (error instanceof HttpError) {
-		caught = { kind: 'expected', error: error.body };
+		caught = { kind: 'app', error: error.body };
 	} else if (error instanceof SvelteKitError) {
 		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
 	} else {
-		caught = { kind: 'unexpected', error };
+		caught = { kind: 'unknown', error };
 
 		let e = error;
 		while (e instanceof Error) {
@@ -61,7 +61,7 @@ export function handle_error_and_jsonify(event, state, options, error) {
 	}
 
 	const fallback =
-		caught.kind === 'unexpected' ? { status: 500, message: 'Internal Error' } : caught.error;
+		caught.kind === 'unknown' ? { status: 500, message: 'Internal Error' } : caught.error;
 
 	/**
 	 * The hook returns only the properties it wants to override; anything it omits
diff --git a/packages/kit/src/runtime/server/index.js b/packages/kit/src/runtime/server/index.js
index c28173c4712f..175c1965867a 100644
--- a/packages/kit/src/runtime/server/index.js
+++ b/packages/kit/src/runtime/server/index.js
@@ -130,7 +130,7 @@ export class Server {
 					handleError:
 						module.handleError ||
 						(({ kind, error }) => {
-							if (kind !== 'unexpected') {
+							if (kind !== 'unknown') {
 								// don't log stack traces for 404s etc, it's all internal gubbins
 								return;
 							}
diff --git a/packages/kit/src/utils/error.spec.js b/packages/kit/src/utils/error.spec.js
index 1d8147f4d33d..4514c2873f35 100644
--- a/packages/kit/src/utils/error.spec.js
+++ b/packages/kit/src/utils/error.spec.js
@@ -25,7 +25,7 @@ describe('add_deprecated_handle_error_properties', () => {
 	it('adds non-enumerable accessors that warn and return the fallback values', () => {
 		const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
 		const input = add_deprecated_handle_error_properties(
-			{ kind: 'unexpected', error: new Error('nope') },
+			{ kind: 'unknown', error: new Error('nope') },
 			{ status: 500, message: 'Internal Error' }
 		);
 
diff --git a/packages/kit/test/apps/async/src/hooks.client.js b/packages/kit/test/apps/async/src/hooks.client.js
index b5fbc37121d0..2207cfef3ac8 100644
--- a/packages/kit/test/apps/async/src/hooks.client.js
+++ b/packages/kit/test/apps/async/src/hooks.client.js
@@ -7,7 +7,7 @@ export const handleError = (input) => {
 		throw new Error("Redirects shouldn't trigger the handleError hook");
 	}
 
-	if (input.kind !== 'unexpected') return input.error;
+	if (input.kind !== 'unknown') return input.error;
 
 	const error = /** @type {Error} */ (input.error);
 
diff --git a/packages/kit/test/apps/async/src/hooks.server.js b/packages/kit/test/apps/async/src/hooks.server.js
index 25bc17ef5448..087f751ad80d 100644
--- a/packages/kit/test/apps/async/src/hooks.server.js
+++ b/packages/kit/test/apps/async/src/hooks.server.js
@@ -52,7 +52,7 @@ export const handleError = (input) => {
 		throw new Error("Redirects shouldn't trigger the handleError hook");
 	}
 
-	if (input.kind !== 'unexpected') return input.error;
+	if (input.kind !== 'unknown') return input.error;
 
 	const error = /** @type {Error} */ (input.error);
 
diff --git a/packages/kit/test/apps/basics/src/hooks.client.js b/packages/kit/test/apps/basics/src/hooks.client.js
index 55c801dd6b37..d9fc318f4a6c 100644
--- a/packages/kit/test/apps/basics/src/hooks.client.js
+++ b/packages/kit/test/apps/basics/src/hooks.client.js
@@ -10,7 +10,7 @@ export function handleError(input) {
 		return { message: `client ${kind}` };
 	}
 
-	if (kind === 'expected') {
+	if (kind === 'app') {
 		return input.error;
 	}
 
diff --git a/packages/kit/test/apps/basics/src/hooks.server.js b/packages/kit/test/apps/basics/src/hooks.server.js
index 5006f96d273a..cce84f3a929b 100644
--- a/packages/kit/test/apps/basics/src/hooks.server.js
+++ b/packages/kit/test/apps/basics/src/hooks.server.js
@@ -39,11 +39,11 @@ export const handleError = ({ event, kind, error }) => {
 		JSON.stringify({
 			path: event.url.pathname,
 			kind,
-			error: kind === 'unexpected' ? error_to_pojo(/** @type {Error} */ (error)) : error
+			error: kind === 'unknown' ? error_to_pojo(/** @type {Error} */ (error)) : error
 		}) + '\n'
 	);
 
-	if (kind === 'expected') {
+	if (kind === 'app') {
 		// so that `error(...)` bodies reach the page verbatim
 		return error;
 	}
diff --git a/packages/kit/test/apps/basics/test/cross-platform/client.test.js b/packages/kit/test/apps/basics/test/cross-platform/client.test.js
index 6b66714093c4..923240d4a6f2 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/client.test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/client.test.js
@@ -817,7 +817,7 @@ test.describe.serial('Errors', () => {
 		await clicknav('[href="/errors/kind/expected"]');
 
 		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "client expected"'
+			'This is your custom error page saying: "client app"'
 		);
 		expect(await page.textContent('h1')).toBe('403');
 	});
@@ -827,7 +827,7 @@ test.describe.serial('Errors', () => {
 		await clicknav('[href="/errors/kind/unexpected"]');
 
 		expect(await page.textContent('#message')).toBe(
-			'This is your custom error page saying: "client unexpected"'
+			'This is your custom error page saying: "client unknown"'
 		);
 		expect(await page.textContent('h1')).toBe('500');
 	});
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 39489c839519..7d9932a9b978 100644
--- a/packages/kit/test/apps/basics/test/cross-platform/test.js
+++ b/packages/kit/test/apps/basics/test/cross-platform/test.js
@@ -357,7 +357,7 @@ test.describe('Errors', () => {
 		const response = await page.goto('/errors/kind/expected');
 
 		expect(read_errors('/errors/kind/expected')).toEqual({
-			kind: 'expected',
+			kind: 'app',
 			error: { status: 403, message: 'expected error' }
 		});
 
@@ -371,7 +371,7 @@ test.describe('Errors', () => {
 		const response = await page.goto('/errors/kind/unexpected');
 
 		const { kind, error } = read_errors('/errors/kind/unexpected');
-		expect(kind).toBe('unexpected');
+		expect(kind).toBe('unknown');
 		expect(error.message).toBe('unexpected error');
 
 		expect(await page.textContent('#message')).toBe(
@@ -384,7 +384,7 @@ test.describe('Errors', () => {
 		const res = await page.goto('/errors/endpoint');
 
 		const { kind, error } = read_errors('/errors/endpoint.json');
-		expect(kind).toBe('unexpected');
+		expect(kind).toBe('unknown');
 
 		// should include stack trace
 		const lines = error.stack.split('\n');
@@ -404,7 +404,7 @@ test.describe('Errors', () => {
 		const res = await page.goto('/errors/endpoint-shadow');
 
 		const { kind, error } = read_errors('/errors/endpoint-shadow');
-		expect(kind).toBe('unexpected');
+		expect(kind).toBe('unknown');
 
 		// should include stack trace
 		const lines = error.stack.split('\n');
@@ -424,7 +424,7 @@ test.describe('Errors', () => {
 		const res = await page.goto('/errors/endpoint-shadow-not-ok');
 
 		expect(read_errors('/errors/endpoint-shadow-not-ok')).toEqual({
-			kind: 'expected',
+			kind: 'app',
 			error: { status: 555, message: 'Error: 555' }
 		});
 
@@ -458,7 +458,7 @@ test.describe('Errors', () => {
 		);
 
 		const { kind, error } = read_errors('/errors/page-endpoint/get-implicit');
-		expect(kind).toBe('unexpected');
+		expect(kind).toBe('unknown');
 
 		const { status, name, message, stack, fancy } = error;
 		expect(status).toBe(undefined);
@@ -484,7 +484,7 @@ test.describe('Errors', () => {
 		);
 
 		expect(read_errors('/errors/page-endpoint/get-explicit')).toEqual({
-			kind: 'expected',
+			kind: 'app',
 			error: { status: 400, message: 'oops' }
 		});
 	});
@@ -504,7 +504,7 @@ test.describe('Errors', () => {
 		);
 
 		const { kind, error } = read_errors('/errors/page-endpoint/post-implicit');
-		expect(kind).toBe('unexpected');
+		expect(kind).toBe('unknown');
 
 		const { status, name, message, stack, fancy } = error;
 
@@ -533,7 +533,7 @@ test.describe('Errors', () => {
 		);
 
 		expect(read_errors('/errors/page-endpoint/post-explicit')).toEqual({
-			kind: 'expected',
+			kind: 'app',
 			error: { status: 400, message: 'oops' }
 		});
 	});
@@ -604,7 +604,7 @@ test.describe('Redirects', () => {
 		if (!javaScriptEnabled) {
 			// handleError is not invoked for client-side navigation
 			const { kind, error } = read_errors('/redirect/missing-status/a');
-			expect(kind).toBe('unexpected');
+			expect(kind).toBe('unknown');
 			const lines = error.stack.split('\n');
 			expect(lines[0]).toBe(`Error: ${message}`);
 		}
diff --git a/packages/kit/test/apps/basics/test/server.test.js b/packages/kit/test/apps/basics/test/server.test.js
index 74b0fbef6cf5..0db26c52dacd 100644
--- a/packages/kit/test/apps/basics/test/server.test.js
+++ b/packages/kit/test/apps/basics/test/server.test.js
@@ -601,7 +601,7 @@ test.describe('Errors', () => {
 			});
 
 			expect(read_errors('/errors/endpoint-throw-error')).toEqual({
-				kind: 'expected',
+				kind: 'app',
 				error: { status: 401, message: 'You shall not pass' }
 			});
 
@@ -616,7 +616,7 @@ test.describe('Errors', () => {
 			const res = await request.get('/errors/endpoint-throw-error');
 
 			expect(read_errors('/errors/endpoint-throw-error')).toEqual({
-				kind: 'expected',
+				kind: 'app',
 				error: { status: 401, message: 'You shall not pass' }
 			});
 
diff --git a/packages/kit/test/apps/dev-only/src/hooks.client.js b/packages/kit/test/apps/dev-only/src/hooks.client.js
index 02c45be2102d..676f8a3f09db 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.client.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.client.js
@@ -4,6 +4,6 @@ cjs.cjs();
 
 /** @type {import("@sveltejs/kit").HandleClientError} */
 export function handleError({ kind, error }) {
-	if (kind !== 'unexpected') return error;
+	if (kind !== 'unknown') return error;
 	return { message: /**@type{any}*/ (error).message };
 }
diff --git a/packages/kit/test/apps/dev-only/src/hooks.server.js b/packages/kit/test/apps/dev-only/src/hooks.server.js
index 890c28788b65..391927e8cc4d 100644
--- a/packages/kit/test/apps/dev-only/src/hooks.server.js
+++ b/packages/kit/test/apps/dev-only/src/hooks.server.js
@@ -1,5 +1,5 @@
 /** @type {import("@sveltejs/kit").HandleServerError} */
 export function handleError({ kind, error }) {
-	if (kind !== 'unexpected') return error;
+	if (kind !== 'unknown') return error;
 	return { message: /**@type{any}*/ (error).message };
 }
diff --git a/packages/kit/test/types/app-error-enhanced/error.test.ts b/packages/kit/test/types/app-error-enhanced/error.test.ts
index 7b27166fd1ba..dd51cd42803e 100644
--- a/packages/kit/test/types/app-error-enhanced/error.test.ts
+++ b/packages/kit/test/types/app-error-enhanced/error.test.ts
@@ -35,7 +35,7 @@ const handle_error_overrides: [HandleServerError, HandleClientError] = [
 ];
 
 const handle_error_kinds: HandleServerError = ({ kind, error }) => {
-	if (kind === 'expected') {
+	if (kind === 'app') {
 		error satisfies App.Error;
 		return error;
 	}
diff --git a/packages/kit/test/types/error.test.ts b/packages/kit/test/types/error.test.ts
index 1f09bedc4173..c8dbe6044579 100644
--- a/packages/kit/test/types/error.test.ts
+++ b/packages/kit/test/types/error.test.ts
@@ -7,7 +7,7 @@ const app_error_without_status: App.Error = { message: 'Unexpected error' };
 
 const handle_error_hooks: [HandleServerError, HandleClientError] = [
 	({ kind, error }) => {
-		if (kind === 'expected') {
+		if (kind === 'app') {
 			error satisfies App.Error;
 			return error;
 		}
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index 17db273e79d4..a506ad528094 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -938,17 +938,16 @@ declare module '@sveltejs/kit' {
 	}) => MaybePromise<Response>;
 
 	type CaughtErrorMap = {
-		expected: App.Error;
-		unexpected: unknown;
+		app: App.Error;
 		framework: { status: number; message: string };
+		unknown: unknown;
 	};
 
 	/**
 	 * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
-	 * Use the `kind` discriminant to distinguish expected errors (thrown with the
-	 * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), unexpected errors
-	 * (thrown by your code, or code it calls), and framework errors (generated by SvelteKit
-	 * itself, such as 404s).
+	 * Use the `kind` discriminant to distinguish errors from your app (thrown with the
+	 * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), errors generated by
+	 * SvelteKit itself (such as 404s), and unknown errors (thrown by your code, or code it calls).
 	 */
 	export type CaughtError = {
 		[Kind in keyof CaughtErrorMap]: {
@@ -962,12 +961,12 @@ declare module '@sveltejs/kit' {
 	/**
 	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
 	 *
-	 * The `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
-	 * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
 	 *
 	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
-	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
-	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
 	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
 	 *
 	 * Make sure that this function _never_ throws an error.
@@ -988,12 +987,12 @@ declare module '@sveltejs/kit' {
 	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
 	 * Errors that were already transformed by the server-side hook are not passed to it a second time.
 	 *
-	 * The `kind` property discriminates between _expected_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
-	 * _unexpected_ errors (thrown by your code, or code it calls) and _framework_ errors (generated by SvelteKit itself, such as 404s).
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
 	 *
 	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
-	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for expected errors,
-	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unexpected errors. Return nothing to
+	 * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+	 * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
 	 * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
 	 *
 	 * Make sure that this function _never_ throws an error.

From 0841f3722b7ffd0c2658ed729af4824e89d1d025 Mon Sep 17 00:00:00 2001
From: Elliott Johnson <hello+git@ell.iott.dev>
Date: Mon, 10 Aug 2026 13:20:44 -0600
Subject: [PATCH 22/22] docs: rename error categories

---
 documentation/docs/20-core-concepts/20-load.md       |  4 ++--
 .../docs/20-core-concepts/60-remote-functions.md     |  2 +-
 documentation/docs/30-advanced/20-hooks.md           |  2 +-
 documentation/docs/30-advanced/25-errors.md          | 12 ++++++------
 packages/kit/src/exports/public.d.ts                 |  6 +++---
 packages/kit/types/index.d.ts                        |  6 +++---
 6 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/documentation/docs/20-core-concepts/20-load.md b/documentation/docs/20-core-concepts/20-load.md
index b947615029ae..52666999ba4b 100644
--- a/documentation/docs/20-core-concepts/20-load.md
+++ b/documentation/docs/20-core-concepts/20-load.md
@@ -421,7 +421,7 @@ export async function load({ params, parent }) {
 
 ## Errors
 
-If an error is thrown during `load`, the nearest [`+error.svelte`](routing#error) will be rendered. For [_expected_](errors#Expected-errors) errors, use the `error` helper from `@sveltejs/kit` to specify the HTTP status code and an optional message:
+If an error is thrown during `load`, the nearest [`+error.svelte`](routing#error) will be rendered. For [app errors](errors#App-errors), use the `error` helper from `@sveltejs/kit` to specify the HTTP status code and an optional message:
 
 ```js
 /// file: src/routes/admin/+layout.server.js
@@ -453,7 +453,7 @@ export function load({ locals }) {
 
 Calling `error(...)` will throw an exception, making it easy to stop execution from inside helper functions.
 
-Every error — expected or otherwise — is passed to the [`handleError`](hooks#handleError) hook. An [_unexpected_](errors#Unexpected-errors) error is treated as a 500 Internal Error unless the hook says otherwise.
+Every error is passed to the [`handleError`](hooks#handleError) hook. An [unknown error](errors#Unknown-errors) is treated as a 500 Internal Error unless the hook says otherwise.
 
 > [!NOTE] [In SvelteKit 1.x](migrating-to-sveltekit-2#redirect-and-error-are-no-longer-thrown-by-you) you had to `throw` the error yourself
 
diff --git a/documentation/docs/20-core-concepts/60-remote-functions.md b/documentation/docs/20-core-concepts/60-remote-functions.md
index 132d82e54bdb..61499df2a485 100644
--- a/documentation/docs/20-core-concepts/60-remote-functions.md
+++ b/documentation/docs/20-core-concepts/60-remote-functions.md
@@ -1248,7 +1248,7 @@ export function handleValidationError({ event, issues }) {
 }
 ```
 
-The object you return becomes the body of an [expected error](errors#Expected-errors), which then passes through [`handleError`](hooks#handleError) with `kind: 'app'`.
+The object you return becomes the body of an [app error](errors#App-errors), which then passes through [`handleError`](hooks#handleError) with `kind: 'app'`.
 
 If you know what you're doing and want to opt out of validation, you can pass the string `'unchecked'` in place of a schema:
 
diff --git a/documentation/docs/30-advanced/20-hooks.md b/documentation/docs/30-advanced/20-hooks.md
index 0fcc64944292..44672c6392dc 100644
--- a/documentation/docs/30-advanced/20-hooks.md
+++ b/documentation/docs/30-advanced/20-hooks.md
@@ -177,7 +177,7 @@ export function handleValidationError({ issues }) {
 
 Be thoughtful about what information you expose here, as the most likely reason for validation to fail is that someone is sending malicious requests to your server.
 
-The object you return here becomes the body of an [expected error](errors#Expected-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with `kind: 'app'`.
+The object you return here becomes the body of an [app error](errors#App-errors), which means it subsequently passes through [`handleError`](hooks#handleError) as an error with `kind: 'app'`.
 
 ## handleError
 
diff --git a/documentation/docs/30-advanced/25-errors.md b/documentation/docs/30-advanced/25-errors.md
index bb001e9b9c13..2538dfbea3fd 100644
--- a/documentation/docs/30-advanced/25-errors.md
+++ b/documentation/docs/30-advanced/25-errors.md
@@ -10,9 +10,9 @@ Every error passes through the [`handleError`](hooks#handleError) hook — which
 
 You can add additional properties, like a `code` or a tracking `id`, as shown in the examples below. (When using TypeScript this requires you to redefine the `Error` type as described in  [type safety](errors#Type-safety)).
 
-## Expected errors
+## App errors
 
-An _expected_ error is one created with the [`error`](@sveltejs-kit#error) helper imported from `@sveltejs/kit`:
+An _app_ error is one created with the [`error`](@sveltejs-kit#error) helper imported from `@sveltejs/kit`:
 
 ```js
 /// file: src/routes/blog/[slug]/+page.server.js
@@ -75,17 +75,17 @@ error(404, 'Not found', {
 
 > [!NOTE] [In SvelteKit 1.x](migrating-to-sveltekit-2#redirect-and-error-are-no-longer-thrown-by-you) you had to `throw` the `error` yourself
 
-## Unexpected errors
+## Unknown errors
 
-An _unexpected_ error is any other exception that occurs while handling a request. Since these can contain sensitive information, unexpected error messages and stack traces are not exposed to users.
+An _unknown_ error is any other exception that occurs while handling a request. Since these can contain sensitive information, unknown error messages and stack traces are not exposed to users.
 
-By default, unexpected errors are printed to the console (or, in production, your server logs), while the error that is exposed to the user has a generic shape:
+By default, unknown errors are printed to the console (or, in production, your server logs), while the error that is exposed to the user has a generic shape:
 
 ```json
 { "status": 500, "message": "Internal Error" }
 ```
 
-Unexpected errors go through the [`handleError`](hooks#handleError) hook with `kind: 'unknown'`, because SvelteKit does not know what went wrong. There you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. The value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
+Unknown errors go through the [`handleError`](hooks#handleError) hook with `kind: 'unknown'`, because SvelteKit does not know what went wrong. There you can add your own error handling, for example sending errors to a reporting service, or returning a custom error object which becomes the `error` prop passed to `+error.svelte`. The value you receive is the raw thrown value, and nothing about it is exposed unless you choose to expose it.
 
 Anything you return overrides the defaults, so you can — for example — use the type of the thrown error to determine the HTTP status code used in the response:
 
diff --git a/packages/kit/src/exports/public.d.ts b/packages/kit/src/exports/public.d.ts
index 3787996c32da..f29187ec24ca 100644
--- a/packages/kit/src/exports/public.d.ts
+++ b/packages/kit/src/exports/public.d.ts
@@ -970,7 +970,7 @@ type CaughtErrorMap = {
 /**
  * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
  * Use the `kind` discriminant to distinguish errors from your app (thrown with the
- * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), errors generated by
+ * [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper), errors generated by
  * SvelteKit itself (such as 404s), and unknown errors (thrown by your code, or code it calls).
  */
 export type CaughtError = {
@@ -985,7 +985,7 @@ export type CaughtError = {
 /**
  * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
  *
- * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
  * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
  *
  * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
@@ -1011,7 +1011,7 @@ export type HandleValidationError<Issue extends StandardSchemaV1.Issue = Standar
  * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
  * Errors that were already transformed by the server-side hook are not passed to it a second time.
  *
- * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
  * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
  *
  * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
diff --git a/packages/kit/types/index.d.ts b/packages/kit/types/index.d.ts
index a506ad528094..95fa07598082 100644
--- a/packages/kit/types/index.d.ts
+++ b/packages/kit/types/index.d.ts
@@ -946,7 +946,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
 	 * Use the `kind` discriminant to distinguish errors from your app (thrown with the
-	 * [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper), errors generated by
+	 * [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper), errors generated by
 	 * SvelteKit itself (such as 404s), and unknown errors (thrown by your code, or code it calls).
 	 */
 	export type CaughtError = {
@@ -961,7 +961,7 @@ declare module '@sveltejs/kit' {
 	/**
 	 * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
 	 *
-	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
 	 * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
 	 *
 	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
@@ -987,7 +987,7 @@ declare module '@sveltejs/kit' {
 	 * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
 	 * Errors that were already transformed by the server-side hook are not passed to it a second time.
 	 *
-	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#Expected-errors) helper),
+	 * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
 	 * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
 	 *
 	 * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to