@sveltejs/kit 3.0.0-next.18 → 3.0.0-next.19

package/src/runtime/client/remote-functions/form.svelte.js

@@ -1,9 +1,9 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 /** @import { RemoteFormInput, RemoteForm, RemoteQueryUpdate } from '@sveltejs/kit' */
 /** @import { InternalRemoteFormIssue } from 'types' */
-import { app_dir, base } from '$app/paths/internal/client';
+import { app_dir, base } from '#app/paths';
 import { DEV } from 'esm-env';
-import { HttpError } from '@sveltejs/kit/internal';
+
 import {
 	query_responses,
 	_goto,
@@ -222,82 +222,84 @@ export function form(id) {
 			/** @type {Error | undefined} */
 			let updates_error;
 
-			/** @type {Promise<boolean> & { updates: (...args: RemoteQueryUpdate[]) => Promise<boolean> }} */
-			const promise = (async () => {
-				try {
-					await Promise.resolve();
+			const promise =
+				/** @type {Promise<boolean> & { updates: (...args: RemoteQueryUpdate[]) => Promise<boolean> }} */ (
+					(async () => {
+						try {
+							await Promise.resolve();
 
-					if (updates_error) {
-						throw updates_error;
-					}
-
-					if (should_preflight) {
-						const valid = await preflight(form_data);
-						if (!valid) return false;
-					}
-
-					const { blob } = serialize_binary_form(convert(form_data), {
-						remote_refreshes: Array.from(refreshes ?? [])
-					});
-
-					const response = await remote_request(
-						`${base}/${app_dir}/remote/${action_id_without_key}`,
-						{
-							method: 'POST',
-							headers: {
-								'Content-Type': BINARY_FORM_CONTENT_TYPE,
-								// Forms cannot be called during rendering, so it's save to use location here
-								'x-sveltekit-pathname': location.pathname,
-								'x-sveltekit-search': location.search
-							},
-							body: blob
-						}
-					);
+							if (updates_error) {
+								throw updates_error;
+							}
 
-					({ issues: raw_issues = [], result } = response._ ?? {});
+							if (should_preflight) {
+								const valid = await preflight(form_data);
+								if (!valid) return false;
+							}
 
-					// if the developer took control of updates via `.updates(...)` (even with
-					// no arguments), or the server performed explicit refreshes, don't invalidateAll
-					const should_refresh = refreshes === null && !response.r;
+							const { blob } = serialize_binary_form(convert(form_data), {
+								remote_refreshes: Array.from(refreshes ?? [])
+							});
+
+							const response = await remote_request(
+								`${base}/${app_dir}/remote/${action_id_without_key}`,
+								{
+									method: 'POST',
+									headers: {
+										'Content-Type': BINARY_FORM_CONTENT_TYPE,
+										// Forms cannot be called during rendering, so it's save to use location here
+										'x-sveltekit-pathname': location.pathname,
+										'x-sveltekit-search': location.search
+									},
+									body: blob
+								}
+							);
 
-					if (response.redirect) {
-						// Use internal version to allow redirects to external URLs
-						void _goto(response.redirect, {
-							refreshAll: should_refresh
-						});
-						return true;
-					}
+							({ issues: raw_issues = [], result } = response._ ?? {});
 
-					const succeeded = raw_issues.length === 0;
+							// if the developer took control of updates via `.updates(...)` (even with
+							// no arguments), or the server performed explicit refreshes, don't invalidateAll
+							const should_refresh = refreshes === null && !response.r;
 
-					if (succeeded) {
-						if (should_refresh) {
-							void refreshAll();
-						}
-					} else {
-						if (DEV) {
-							warn_on_missing_issue_reads();
-						}
-					}
+							if (response.redirect) {
+								// Use internal version to allow redirects to external URLs
+								void _goto(response.redirect, {
+									refreshAll: should_refresh
+								});
+								return true;
+							}
 
-					return succeeded;
-				} catch (e) {
-					result = undefined;
-					raw_issues = [];
-					throw e;
-				} finally {
-					overrides?.forEach((fn) => fn());
+							const succeeded = raw_issues.length === 0;
 
-					void tick().then(() => {
-						if (entry) {
-							entry.count--;
-							if (entry.count === 0) {
-								instances.delete(key);
+							if (succeeded) {
+								if (should_refresh) {
+									void refreshAll();
+								}
+							} else {
+								if (DEV) {
+									warn_on_missing_issue_reads();
+								}
 							}
+
+							return succeeded;
+						} catch (e) {
+							result = undefined;
+							raw_issues = [];
+							throw e;
+						} finally {
+							overrides?.forEach((fn) => fn());
+
+							void tick().then(() => {
+								if (entry) {
+									entry.count--;
+									if (entry.count === 0) {
+										instances.delete(key);
+									}
+								}
+							});
 						}
-					});
-				}
-			})();
+					})()
+				);
 
 			let updates_called = false;
 			promise.updates = (...args) => {
@@ -376,8 +378,7 @@ export function form(id) {
 			return true;
 		}
 
-		/** @type {RemoteForm<T, U>} */
-		const instance = {};
+		const instance = /** @type {RemoteForm<T, U>} */ ({});
 
 		instance.method = 'POST';
 		Object.defineProperty(instance, 'action', {
@@ -477,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--;

package/src/runtime/client/remote-functions/prerender.svelte.js

@@ -1,12 +1,12 @@
 /** @import { RemotePrerenderFunction } from '@sveltejs/kit' */
-import { app_dir, base } from '$app/paths/internal/client';
+import { app_dir, base } from '#app/paths';
 import { version } from '$app/env';
 import * as devalue from 'devalue';
 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);
 			}
 		);
 

package/src/runtime/client/remote-functions/query/index.js

@@ -1,5 +1,5 @@
 /** @import { RemoteQueryFunction } from '@sveltejs/kit' */
-import { app_dir, base } from '$app/paths/internal/client';
+import { app_dir, base } from '#app/paths';
 import { _goto, query_map } from '../../client.js';
 import { QUERY_FUNCTION_ID, remote_request } from '../shared.svelte.js';
 import { DEV } from 'esm-env';

package/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;

package/src/runtime/client/remote-functions/query-batch.svelte.js

@@ -1,9 +1,9 @@
 /** @import { RemoteQueryFunction } from '@sveltejs/kit' */
-import { app_dir, base } from '$app/paths/internal/client';
+import { app_dir, base } from '#app/paths';
 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);
 								}

package/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]() {

package/src/runtime/client/remote-functions/query-live/iterator.js

@@ -1,10 +1,10 @@
 /** @import { RemoteFunctionResponse } from 'types' */
-import { app_dir, base } from '$app/paths/internal/client';
+import { app_dir, base } from '#app/paths';
 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')) {

package/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;

package/src/runtime/client/state.svelte.js

@@ -1,8 +1,10 @@
+/** @import { Navigation } from '$app/navigation' */
+/** @import { Page } from '$app/state' */
 import { version } from '$app/env';
-import { assets } from '$app/paths/internal/client';
+import { assets } from '#app/paths';
 import { BROWSER, DEV } from 'esm-env';
 
-/** @type {import('@sveltejs/kit').Page} */
+/** @type {Page} */
 export const page = new (class Page {
 	data = $state.raw({});
 	form = $state.raw(null);
@@ -16,7 +18,7 @@ export const page = new (class Page {
 })();
 
 export const navigating = new (class Navigating {
-	/** @type {import('@sveltejs/kit').Navigation | null} */
+	/** @type {Navigation | null} */
 	current = $state.raw(null);
 })();
 

package/src/runtime/client/types.d.ts

@@ -8,7 +8,8 @@ import {
 	TrailingSlash,
 	Uses
 } from 'types';
-import { Page, ParamMatcher } from '@sveltejs/kit';
+import { ParamMatcher } from '@sveltejs/kit/params';
+import { Page } from '$app/state';
 import { RenderNode } from '../props.svelte.js';
 
 export interface SvelteKitApp {

package/src/runtime/pathname.js

@@ -1,69 +1,17 @@
-const DATA_SUFFIX = '/__data.json';
-const HTML_DATA_SUFFIX = '.html__data.json';
+import { app_dir, base } from '#app/paths';
+import { add_resolution_suffix } from '../pathname.js';
 
-/** @param {string} pathname */
-export function has_data_suffix(pathname) {
-	return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
-}
-
-/** @param {string} pathname */
-export function add_data_suffix(pathname) {
-	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
-	return pathname.replace(/\/$/, '') + DATA_SUFFIX;
-}
-
-/** @param {string} pathname */
-export function strip_data_suffix(pathname) {
-	if (pathname.endsWith(HTML_DATA_SUFFIX)) {
-		return pathname.slice(0, -HTML_DATA_SUFFIX.length) + '.html';
-	}
-
-	return pathname.slice(0, -DATA_SUFFIX.length);
-}
-
-const ROUTE_SUFFIX = '/__route.js';
-const HTML_ROUTE_SUFFIX = '.html__route.js';
-
-/**
- * @param {string} pathname
- * @returns {boolean}
- */
-export function has_resolution_suffix(pathname) {
-	return pathname.endsWith(ROUTE_SUFFIX) || pathname.endsWith(HTML_ROUTE_SUFFIX);
-}
-
-/**
- * Convert a regular URL to a route to send to SvelteKit's server-side route resolution endpoint
- * @param {string} pathname
- * @returns {string}
- */
-export function add_resolution_suffix(pathname) {
-	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_ROUTE_SUFFIX);
-	return pathname.replace(/\/$/, '') + ROUTE_SUFFIX;
-}
-
-/**
- * @param {string} pathname
- * @returns {string}
- */
-export function strip_resolution_suffix(pathname) {
-	if (pathname.endsWith(HTML_ROUTE_SUFFIX)) {
-		return pathname.slice(0, -HTML_ROUTE_SUFFIX.length) + '.html';
-	}
-
-	return pathname.slice(0, -ROUTE_SUFFIX.length);
-}
+export * from '../pathname.js';
 
 const ROUTES_PREFIX = '/routes';
 
 /**
  * The pathname of the route-ID-keyed resolution module for a given route ID,
  * e.g. `/_app/routes/blog/[slug]/__route.js` (before prefixing with `base`).
- * @param {string} app_dir
  * @param {string} route_id
  * @returns {string}
  */
-export function route_id_resolution_pathname(app_dir, route_id) {
+export function route_id_resolution_pathname(route_id) {
 	return add_resolution_suffix(`/${app_dir}${ROUTES_PREFIX}${route_id === '/' ? '' : route_id}`);
 }
 
@@ -71,11 +19,9 @@ export function route_id_resolution_pathname(app_dir, route_id) {
  * Whether a pathname (with the `/__route.js` suffix already stripped, and `base` NOT yet stripped)
  * is a route-ID resolution request rather than a pathname resolution request.
  * @param {string} pathname
- * @param {string} base
- * @param {string} app_dir
  * @returns {boolean}
  */
-export function is_route_id_resolution_path(pathname, base, app_dir) {
+export function is_route_id_resolution_path(pathname) {
 	const prefix = `${base}/${app_dir}${ROUTES_PREFIX}`;
 	return pathname === prefix || pathname.startsWith(prefix + '/');
 }
@@ -84,9 +30,8 @@ export function is_route_id_resolution_path(pathname, base, app_dir) {
  * Extract the route ID from a decoded, base-stripped, suffix-stripped pathname,
  * e.g. `/_app/routes/blog/[slug]` -> `/blog/[slug]`, `/_app/routes` -> `/`.
  * @param {string} pathname
- * @param {string} app_dir
  * @returns {string}
  */
-export function extract_route_id(pathname, app_dir) {
+export function extract_route_id(pathname) {
 	return pathname.slice(`/${app_dir}${ROUTES_PREFIX}`.length) || '/';
 }

package/src/runtime/props.svelte.js

@@ -1,5 +1,5 @@
 /** @import { Component } from 'svelte'; */
-/** @import { Page } from '@sveltejs/kit'; */
+/** @import { Page } from '$app/state'; */
 
 import { noop } from '../utils/functions.js';
 

package/src/runtime/server/constants.js

@@ -1,4 +1 @@
 export const NULL_BODY_STATUS = [101, 103, 204, 205, 304];
-
-// eslint-disable-next-line n/prefer-global/process
-export const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;

package/src/runtime/server/errors.js

@@ -1,7 +1,12 @@
 import { json, text } from '@sveltejs/kit';
-import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
+import {
+	HandledHttpError,
+	HttpError,
+	SvelteKitError,
+	ValidationError
+} 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 { 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';
@@ -13,7 +18,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 +44,56 @@ 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 HttpError) {
-		// @ts-expect-error custom user errors may not have a message field if App.Error is overwritten
-		return { message: 'Unknown Error', ...error.body };
+	if (error instanceof HandledHttpError) {
+		return error.body;
 	}
 
-	let e = error;
-	while (e instanceof Error) {
-		fix_stack_trace(e);
-		e = e.cause;
+	/** @type {import('@sveltejs/kit').CaughtError} */
+	let caught;
+
+	if (error instanceof HttpError) {
+		caught = { kind: 'app', error: error.body };
+	} else if (error instanceof SvelteKitError) {
+		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
+	} else if (error instanceof ValidationError) {
+		caught = {
+			kind: 'validation',
+			error: { status: 400, message: 'Bad Request' },
+			issues: error.issues
+		};
+	} else {
+		caught = { kind: 'unknown', error };
+
+		let e = error;
+		while (e instanceof Error) {
+			fix_stack_trace(e);
+			e = e.cause;
+		}
 	}
 
-	const status = get_status(error);
-	const message = get_message(error);
+	const fallback =
+		caught.kind === 'unknown' ? { status: 500, message: 'Internal 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 };
+		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, message: 'Internal Error' };
+		return { status: fallback.status, message: 'Internal Error' };
 	}
 
 	if (result instanceof Promise) {
@@ -76,24 +107,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);
 }
 
 /**