@sveltejs/kit 2.53.4 → 2.55.0

package/src/exports/vite/build/build_server.js

@@ -107,7 +107,7 @@ export function build_server_nodes(
 		let fonts = [];
 
 		/** @type {Set<string>} */
-		let eager_assets = new Set();
+		const eager_assets = new Set();
 
 		if (node.component && client_manifest) {
 			exports.push(
@@ -215,7 +215,7 @@ export function build_server_nodes(
 					const filename = basename(file);
 					const dest = `${out}/server/stylesheets/${filename}.js`;
 
-					let css = /** @type {string} */ (stylesheets_to_inline.get(file));
+					const css = /** @type {string} */ (stylesheets_to_inline.get(file));
 
 					fs.writeFileSync(
 						dest,

package/src/exports/vite/build/build_service_worker.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import process from 'node:process';
 import * as vite from 'vite';
 import { dedent } from '../../../core/sync/utils.js';
 import { s } from '../../../utils/misc.js';

package/src/exports/vite/index.js

@@ -367,7 +367,8 @@ async function kit({ svelte_config }) {
 				__SVELTEKIT_PATHS_RELATIVE__: s(kit.paths.relative),
 				__SVELTEKIT_CLIENT_ROUTING__: s(kit.router.resolution === 'client'),
 				__SVELTEKIT_HASH_ROUTING__: s(kit.router.type === 'hash'),
-				__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.tracing.server)
+				__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.tracing.server),
+				__SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__: s(kit.experimental.handleRenderingErrors)
 			};
 
 			if (is_build) {
@@ -979,7 +980,7 @@ async function kit({ svelte_config }) {
 					build: {
 						rollupOptions: {
 							// Vite dependency crawler needs an explicit JS entry point
-							// eventhough server otherwise works without it
+							// even though server otherwise works without it
 							input: `${runtime_directory}/client/entry.js`
 						}
 					},

package/src/runtime/app/paths/client.js

@@ -1,4 +1,4 @@
-/** @import { Asset, RouteId, Pathname, ResolvedPathname } from '$app/types' */
+/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types' */
 /** @import { ResolveArgs } from './types.js' */
 import { base, assets, hash_routing } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
@@ -47,7 +47,7 @@ const pathname_prefix = hash_routing ? '#' : '';
  * ```
  * @since 2.26
  *
- * @template {RouteId | Pathname} T
+ * @template {RouteIdWithSearchOrHash | PathnameWithSearchOrHash} T
  * @param {ResolveArgs<T>} args
  * @returns {ResolvedPathname}
  */

package/src/runtime/app/paths/public.d.ts

@@ -1,4 +1,4 @@
-import { RouteId, Pathname, ResolvedPathname } from '$app/types';
+import { RouteIdWithSearchOrHash, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types';
 import { ResolveArgs } from './types.js';
 
 export { resolve, asset, match } from './client.js';
@@ -24,6 +24,6 @@ export let assets: '' | `https://${string}` | `http://${string}` | '/_svelte_kit
 /**
  * @deprecated Use [`resolve(...)`](https://svelte.dev/docs/kit/$app-paths#resolve) instead
  */
-export function resolveRoute<T extends RouteId | Pathname>(
+export function resolveRoute<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash>(
 	...args: ResolveArgs<T>
 ): ResolvedPathname;

package/src/runtime/app/paths/server.js

@@ -35,7 +35,7 @@ export async function match(url) {
 	const store = try_get_request_store();
 
 	if (typeof url === 'string') {
-		const origin = store?.event.url.origin ?? 'http://internal';
+		const origin = store?.event.url.origin ?? 'a://a';
 		url = new URL(url, origin);
 	}
 

package/src/runtime/app/paths/types.d.ts

@@ -1,7 +1,23 @@
-import { Pathname, RouteId, RouteParams } from '$app/types';
+import {
+	PathnameWithSearchOrHash,
+	RouteId,
+	RouteIdWithSearchOrHash,
+	RouteParams
+} from '$app/types';
 
-export type ResolveArgs<T extends RouteId | Pathname> = T extends RouteId
-	? RouteParams<T> extends Record<string, never>
-		? [route: T]
-		: [route: T, params: RouteParams<T>]
-	: [route: T];
+type StripSearchOrHash<T extends string> = T extends `${infer Pathname}?${string}`
+	? Pathname
+	: T extends `${infer Pathname}#${string}`
+		? Pathname
+		: T;
+
+export type ResolveArgs<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash> =
+	T extends RouteId
+		? RouteParams<T> extends Record<string, never>
+			? [route: T]
+			: [route: T, params: RouteParams<T>]
+		: StripSearchOrHash<T> extends infer U extends RouteId
+			? RouteParams<U> extends Record<string, never>
+				? [route: T]
+				: [route: T, params: RouteParams<U>]
+			: [route: T];

package/src/runtime/app/state/server.js

@@ -11,7 +11,7 @@ function context_dev(name) {
 		return context();
 	} catch {
 		throw new Error(
-			`Can only read '${name}' on the server during rendering (not in e.g. \`load\` functions), as it is bound to the current request via component context. This prevents state from leaking between users.` +
+			`Can only read '${name}' on the server during rendering (not in e.g. \`load\` functions), as it is bound to the current request via component context. This prevents state from leaking between users. ` +
 				'For more information, see https://svelte.dev/docs/kit/state-management#avoid-shared-state-on-the-server'
 		);
 	}

package/src/runtime/client/client.js

@@ -56,6 +56,14 @@ export { load_css };
 const ICON_REL_ATTRIBUTES = new Set(['icon', 'shortcut icon', 'apple-touch-icon']);
 
 let errored = false;
+/**
+ * Set via transformError, reset and read at the end of navigate.
+ * Necessary because a navigation might succeed loading but during rendering
+ * an error occurs, at which point the navigation result needs to be overridden with the error result.
+ * TODO this is all very hacky, rethink for SvelteKit 3 where we can assume Svelte 5 and do an overhaul of client.js
+ * @type {{ error: App.Error, status: number } | null}
+ */
+let rendering_error = null;
 
 // We track the scroll position associated with each history entry in sessionStorage,
 // rather than on history.state itself, because when navigation is driven by
@@ -238,12 +246,14 @@ const on_navigate_callbacks = new Set();
 /** @type {Set<(navigation: import('@sveltejs/kit').AfterNavigate) => void>} */
 const after_navigate_callbacks = new Set();
 
-/** @type {import('./types.js').NavigationState} */
+/** @type {import('./types.js').NavigationState & { nav: import('@sveltejs/kit').NavigationEvent }} */
 let current = {
 	branch: [],
 	error: null,
 	// @ts-ignore - we need the initial value to be null
-	url: null
+	url: null,
+	// @ts-ignore - we need the initial value to be null
+	nav: null
 };
 
 /** this being true means we SSR'd */
@@ -415,7 +425,7 @@ async function _invalidate(include_load_functions = true, reset_page_state = tru
 			navigation_result.props.page.state = prev_state;
 		}
 		update(navigation_result.props.page);
-		current = navigation_result.state;
+		current = { ...navigation_result.state, nav: current.nav };
 		reset_invalidation();
 		root.$set(navigation_result.props);
 	} else {
@@ -581,7 +591,17 @@ async function _preload_code(url) {
 async function initialize(result, target, hydrate) {
 	if (DEV && result.state.error && document.querySelector('vite-error-overlay')) return;
 
-	current = result.state;
+	/** @type {import('@sveltejs/kit').NavigationEvent} */
+	const nav = {
+		params: current.params,
+		route: { id: current.route?.id ?? null },
+		url: new URL(location.href)
+	};
+
+	current = {
+		...result.state,
+		nav
+	};
 
 	const style = document.querySelector('style[data-sveltekit]');
 	if (style) style.remove();
@@ -593,7 +613,17 @@ async function initialize(result, target, hydrate) {
 		props: { ...result.props, stores, components },
 		hydrate,
 		// @ts-ignore Svelte 5 specific: asynchronously instantiate the component, i.e. don't call flushSync
-		sync: false
+		sync: false,
+		// @ts-ignore Svelte 5 specific: transformError allows to transform errors before they are passed to boundaries
+		transformError: __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__
+			? /** @param {unknown} e */ async (e) => {
+					const error = await handle_error(e, current.nav);
+					rendering_error = { error, status: get_status(e) };
+					page.error = error;
+					page.status = rendering_error.status;
+					return error;
+				}
+			: undefined
 	});
 
 	// Wait for a microtask in case svelte experimental async is enabled,
@@ -607,9 +637,7 @@ async function initialize(result, target, hydrate) {
 		const navigation = {
 			from: null,
 			to: {
-				params: current.params,
-				route: { id: current.route?.id ?? null },
-				url: new URL(location.href),
+				...nav,
 				scroll: scroll_positions[current_history_index] ?? scroll_state()
 			},
 			willUnload: false,
@@ -629,13 +657,23 @@ async function initialize(result, target, hydrate) {
  *   url: URL;
  *   params: Record<string, string>;
  *   branch: Array<import('./types.js').BranchNode | undefined>;
+ *   errors?: Array<import('types').CSRPageNodeLoader | undefined>;
  *   status: number;
  *   error: App.Error | null;
  *   route: import('types').CSRRoute | null;
  *   form?: Record<string, any> | null;
  * }} opts
  */
-function get_navigation_result_from_branch({ url, params, branch, status, error, route, form }) {
+async function get_navigation_result_from_branch({
+	url,
+	params,
+	branch,
+	errors,
+	status,
+	error,
+	route,
+	form
+}) {
 	/** @type {import('types').TrailingSlash} */
 	let slash = 'never';
 
@@ -670,6 +708,32 @@ function get_navigation_result_from_branch({ url, params, branch, status, error,
 		}
 	};
 
+	if (errors && __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__) {
+		let last_idx = -1;
+		result.props.errors = await Promise.all(
+			// eslint-disable-next-line @typescript-eslint/await-thenable
+			branch
+				.map((b, i) => {
+					if (i === 0) return undefined; // root layout wraps root error component, not the other way around
+					if (!b) return null;
+
+					i--;
+					// Find the closest error component up to the previous branch
+					while (i > last_idx + 1 && !errors[i]) i -= 1;
+					last_idx = i;
+					return errors[i]?.()
+						.then((e) => e.component)
+						.catch(() => undefined);
+				})
+				// filter out indexes where there was no branch, but keep indexes where there was a branch but no error component
+				.filter((e) => e !== null)
+		);
+	}
+
+	if (error && __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__) {
+		result.props.error = error;
+	}
+
 	if (form !== undefined) {
 		result.props.form = form;
 	}
@@ -1201,6 +1265,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 						url,
 						params,
 						branch: branch.slice(0, error_load.idx).concat(error_load.node),
+						errors,
 						status,
 						error,
 						route
@@ -1220,6 +1285,7 @@ async function load_route({ id, invalidating, url, params, route, preload }) {
 		url,
 		params,
 		branch,
+		errors,
 		status: 200,
 		error: null,
 		route,
@@ -1325,6 +1391,7 @@ async function load_root_error_page({ status, error, url, route }) {
 			branch: [root_layout, root_error],
 			status,
 			error,
+			errors: [],
 			route: null
 		});
 	} catch (error) {
@@ -1732,7 +1799,16 @@ async function navigate({
 			});
 		}
 
-		current = navigation_result.state;
+		// Type-casts are save because we know this resolved a proper SvelteKit route
+		const target = /** @type {import('@sveltejs/kit').NavigationTarget} */ (nav.navigation.to);
+		current = {
+			...navigation_result.state,
+			nav: {
+				params: /** @type {Record<string, any>} */ (target.params),
+				route: target.route,
+				url: target.url
+			}
+		};
 
 		// reset url before updating page store
 		if (navigation_result.props.page) {
@@ -1744,7 +1820,12 @@ async function navigate({
 		if (fork) {
 			commit_promise = fork.commit();
 		} else {
+			rendering_error = null; // TODO this can break with forks, rethink for SvelteKit 3 where we can assume Svelte 5
 			root.$set(navigation_result.props);
+			// Check for sync rendering error
+			if (rendering_error) {
+				Object.assign(navigation_result.props.page, rendering_error);
+			}
 			update(navigation_result.props.page);
 
 			commit_promise = svelte.settled?.();
@@ -1800,6 +1881,10 @@ async function navigate({
 	autoscroll = true;
 
 	if (navigation_result.props.page) {
+		// Check for async rendering error
+		if (rendering_error) {
+			Object.assign(navigation_result.props.page, rendering_error);
+		}
 		Object.assign(page, navigation_result.props.page);
 	}
 
@@ -2401,16 +2486,17 @@ export async function set_nearest_error_page(error, status = 500) {
 
 	const error_load = await load_nearest_error_page(current.branch.length, branch, route.errors);
 	if (error_load) {
-		const navigation_result = get_navigation_result_from_branch({
+		const navigation_result = await get_navigation_result_from_branch({
 			url,
 			params: current.params,
 			branch: branch.slice(0, error_load.idx).concat(error_load.node),
 			status,
 			error,
+			// do not set errors, we haven't changed the page so the previous ones are still current
 			route
 		});
 
-		current = navigation_result.state;
+		current = { ...navigation_result.state, nav: current.nav };
 
 		root.$set(navigation_result.props);
 		update(navigation_result.props.page);
@@ -2829,12 +2915,13 @@ async function _hydrate(
 			}
 		}
 
-		result = get_navigation_result_from_branch({
+		result = await get_navigation_result_from_branch({
 			url,
 			params,
 			branch,
 			status,
 			error,
+			errors: parsed_route?.errors, // TODO load earlier?
 			form,
 			route: parsed_route ?? null
 		});

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

@@ -298,6 +298,14 @@ export function form(id) {
 					return;
 				}
 
+				const target = event.submitter?.hasAttribute('formtarget')
+					? /** @type {HTMLButtonElement | HTMLInputElement} */ (event.submitter).formTarget
+					: clone(form).target;
+
+				if (target === '_blank') {
+					return;
+				}
+
 				event.preventDefault();
 
 				const form_data = new FormData(form, event.submitter);

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

@@ -14,6 +14,8 @@ export let updated;
 const is_legacy =
 	onMount.toString().includes('$$') || /function \w+\(\) \{\}/.test(onMount.toString());
 
+const placeholder_url = 'a:';
+
 if (is_legacy) {
 	page = {
 		data: {},
@@ -23,7 +25,7 @@ if (is_legacy) {
 		route: { id: null },
 		state: {},
 		status: -1,
-		url: new URL('https://example.com')
+		url: new URL(placeholder_url)
 	};
 	navigating = { current: null };
 	updated = { current: false };
@@ -36,7 +38,7 @@ if (is_legacy) {
 		route = $state.raw({ id: null });
 		state = $state.raw({});
 		status = $state.raw(-1);
-		url = $state.raw(new URL('https://example.com'));
+		url = $state.raw(new URL(placeholder_url));
 	})();
 
 	navigating = new (class Navigating {

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

@@ -85,9 +85,11 @@ export type NavigationFinished = {
 	state: NavigationState;
 	props: {
 		constructors: Array<typeof SvelteComponent>;
+		errors?: Array<typeof SvelteComponent | undefined>;
 		components?: SvelteComponent[];
 		page: Page;
 		form?: Record<string, any> | null;
+		error?: App.Error;
 		[key: `data_${number}`]: Record<string, any>;
 	};
 };

package/src/runtime/server/page/index.js

@@ -285,6 +285,11 @@ export async function render_page(
 
 							const layouts = compact(branch.slice(0, j + 1));
 							const nodes = new PageNodes(layouts.map((layout) => layout.node));
+							const error_branch = layouts.concat({
+								node,
+								data: null,
+								server_data: null
+							});
 
 							return await render_response({
 								event,
@@ -299,11 +304,14 @@ export async function render_page(
 								},
 								status,
 								error,
-								branch: layouts.concat({
-									node,
-									data: null,
-									server_data: null
-								}),
+								error_components: await load_error_components(
+									options,
+									ssr,
+									error_branch,
+									page,
+									manifest
+								),
+								branch: error_branch,
 								fetched,
 								data_serializer
 							});
@@ -350,11 +358,11 @@ export async function render_page(
 			},
 			status,
 			error: null,
-			branch: ssr === false ? [] : compact(branch),
+			branch: !ssr ? [] : compact(branch),
 			action_result,
 			fetched,
-			data_serializer:
-				ssr === false ? server_data_serializer(event, event_state, options) : data_serializer
+			data_serializer: !ssr ? server_data_serializer(event, event_state, options) : data_serializer,
+			error_components: await load_error_components(options, ssr, branch, page, manifest)
 		});
 	} catch (e) {
 		// a remote function could have thrown a redirect during render
@@ -376,3 +384,44 @@ export async function render_page(
 		});
 	}
 }
+
+/**
+ *
+ * @param {import('types').SSROptions} options
+ * @param {boolean} ssr
+ * @param {Array<import('./types.js').Loaded | null>} branch
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ */
+async function load_error_components(options, ssr, branch, page, manifest) {
+	/** @type {Array<import('types').SSRComponent | undefined> | undefined} */
+	let error_components;
+
+	if (options.server_error_boundaries && ssr) {
+		let last_idx = -1;
+		error_components = await Promise.all(
+			// eslint-disable-next-line @typescript-eslint/await-thenable
+			branch
+				.map((b, i) => {
+					if (i === 0) return undefined; // root layout wraps root error component, not the other way around
+					if (!b) return null;
+
+					i--;
+					// Find the closest error component up to the previous branch
+					while (i > last_idx + 1 && page.errors[i] === undefined) i -= 1;
+					last_idx = i;
+
+					const idx = page.errors[i];
+					if (idx == null) return undefined;
+
+					return manifest._.nodes[idx]?.()
+						.then((e) => e.component?.())
+						.catch(() => undefined);
+				})
+				// filter out indexes where there was no branch, but keep indexes where there was a branch but no error component
+				.filter((e) => e !== null)
+		);
+	}
+
+	return error_components;
+}

package/src/runtime/server/page/render.js

@@ -15,8 +15,9 @@ import { create_server_routing_response, generate_route_object } from './server_
 import { add_resolution_suffix } from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import { get_global_name } from '../utils.js';
+import { get_global_name, handle_error_and_jsonify } from '../utils.js';
 import { create_remote_key } from '../../shared.js';
+import { get_status } from '../../../utils/error.js';
 
 // TODO rename this function/module
 
@@ -40,7 +41,8 @@ const updated = {
  *   event_state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   action_result?: import('@sveltejs/kit').ActionResult;
- *   data_serializer: import('./types.js').ServerDataSerializer
+ *   data_serializer: import('./types.js').ServerDataSerializer;
+ *   error_components?: Array<import('types').SSRComponent | undefined>
  * }} opts
  */
 export async function render_response({
@@ -56,7 +58,8 @@ export async function render_response({
 	event_state,
 	resolve_opts,
 	action_result,
-	data_serializer
+	data_serializer,
+	error_components
 }) {
 	if (state.prerendering) {
 		if (options.csp.mode === 'nonce') {
@@ -147,6 +150,13 @@ export async function render_response({
 			form: form_value
 		};
 
+		if (error_components) {
+			if (error) {
+				props.error = error;
+			}
+			props.errors = error_components;
+		}
+
 		let data = {};
 
 		// props_n (instead of props[n]) makes it easy to avoid
@@ -176,7 +186,15 @@ export async function render_response({
 					}
 				]
 			]),
-			csp: csp.script_needs_nonce ? { nonce: csp.nonce } : { hash: csp.script_needs_hash }
+			csp: csp.script_needs_nonce ? { nonce: csp.nonce } : { hash: csp.script_needs_hash },
+			transformError: error_components
+				? /** @param {unknown} e */ async (e) => {
+						const transformed = await handle_error_and_jsonify(event, event_state, options, e);
+						props.page.error = props.error = error = transformed;
+						props.page.status = status = get_status(e);
+						return transformed;
+					}
+				: undefined
 		};
 
 		const fetch = globalThis.fetch;
@@ -494,7 +512,30 @@ export async function render_response({
 				if (!info.id) continue;
 
 				for (const key in cache) {
-					remote[create_remote_key(info.id, key)] = await cache[key];
+					const remote_key = create_remote_key(info.id, key);
+
+					if (event_state.refreshes?.[remote_key] !== undefined) {
+						// This entry was refreshed/set by a command or form action.
+						// Always await it so the mutation result is serialized.
+						remote[remote_key] = await cache[key];
+					} else {
+						// Don't block the response on pending remote data - if a query
+						// hasn't settled yet, it wasn't awaited in the template (or is behind a pending boundary).
+						const result = await Promise.race([
+							Promise.resolve(cache[key]).then(
+								(v) => /** @type {const} */ ({ settled: true, value: v }),
+								(e) => /** @type {const} */ ({ settled: true, error: e })
+							),
+							new Promise((resolve) => {
+								queueMicrotask(() => resolve(/** @type {const} */ ({ settled: false })));
+							})
+						]);
+
+						if (result.settled) {
+							if ('error' in result) throw result.error;
+							remote[remote_key] = result.value;
+						}
+					}
 				}
 			}
 

package/src/runtime/server/page/respond_with_error.js

@@ -101,6 +101,7 @@ export async function respond_with_error({
 			status,
 			error: await handle_error_and_jsonify(event, event_state, options, error),
 			branch,
+			error_components: [],
 			fetched,
 			event,
 			event_state,

package/src/runtime/server/page/serialize_data.js

@@ -6,7 +6,7 @@ import { hash } from '../../../utils/hash.js';
  *
  * The first closes the script element, so everything after is treated as raw HTML.
  * The second disables further parsing until `-->`, so the script element might be unexpectedly
- * kept open until until an unrelated HTML comment in the page.
+ * kept open up until an unrelated HTML comment in the page.
  *
  * U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR are escaped for the sake of pre-2018
  * browsers.

package/src/types/ambient.d.ts

@@ -104,6 +104,11 @@ declare module '$app/types' {
 	 */
 	export type RouteId = ReturnType<AppTypes['RouteId']>;
 
+	/**
+	 * `RouteId`, but possibly suffixed with a search string and/or hash.
+	 */
+	export type RouteIdWithSearchOrHash = RouteId | `${RouteId}?${string}` | `${RouteId}#${string}`;
+
 	/**
 	 * A utility for getting the parameters associated with a given route.
 	 */
@@ -123,6 +128,14 @@ declare module '$app/types' {
 	 */
 	export type Pathname = ReturnType<AppTypes['Pathname']>;
 
+	/**
+	 * `Pathname`, but possibly suffixed with a search string and/or hash.
+	 */
+	export type PathnameWithSearchOrHash =
+		| Pathname
+		| `${Pathname}?${string}`
+		| `${Pathname}#${string}`;
+
 	/**
 	 * `Pathname`, but possibly prefixed with a base path. Used for `page.url.pathname`.
 	 */

package/src/types/global-private.d.ts

@@ -57,6 +57,7 @@ declare global {
 	 * to throw an error if the feature would fail in production.
 	 */
 	var __SVELTEKIT_TRACK__: (label: string) => void;
+	var __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__: boolean;
 	var Bun: object;
 	var Deno: object;
 }

package/src/types/internal.d.ts

@@ -468,6 +468,7 @@ export interface SSROptions {
 	root: SSRComponent['default'];
 	service_worker: boolean;
 	service_worker_options: RegistrationOptions;
+	server_error_boundaries: boolean;
 	templates: {
 		app(values: {
 			head: string;