@sveltejs/kit 3.0.0-next.4 → 3.0.0-next.7

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

@@ -2,7 +2,6 @@ import { Redirect } from '@sveltejs/kit/internal';
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
 import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
-import { get_status } from '../../../utils/error.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
 
@@ -90,6 +89,8 @@ export async function respond_with_error({
 			);
 		}
 
+		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+
 		return await render_response({
 			options,
 			manifest,
@@ -98,8 +99,8 @@ export async function respond_with_error({
 				ssr,
 				csr
 			},
-			status,
-			error: await handle_error_and_jsonify(event, event_state, options, error),
+			status: transformed.status,
+			error: transformed,
 			branch,
 			error_components: [],
 			fetched,
@@ -115,10 +116,8 @@ export async function respond_with_error({
 			return redirect_response(e.status, e.location);
 		}
 
-		return static_error_page(
-			options,
-			get_status(e),
-			(await handle_error_and_jsonify(event, event_state, options, e)).message
-		);
+		const transformed = await handle_error_and_jsonify(event, event_state, options, e);
+
+		return static_error_page(options, transformed.status, transformed.message);
 	}
 }

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

@@ -69,15 +69,19 @@ export async function resolve_route(resolved_path, url, manifest) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
-	const matchers = await manifest._.matchers();
-	const result = find_route(resolved_path, manifest._.client.routes, matchers);
-
-	return create_server_routing_response(
-		result?.route ?? null,
-		result?.params ?? {},
-		url,
-		manifest._.client
-	).response;
+	try {
+		const matchers = await manifest._.matchers();
+		const result = find_route(resolved_path, manifest._.client.routes, matchers);
+
+		return create_server_routing_response(
+			result?.route ?? null,
+			result?.params ?? {},
+			url,
+			manifest._.client
+		).response;
+	} catch {
+		return text('Error resolving route', { status: 500 });
+	}
 }
 
 /**

package/src/runtime/server/remote.js

@@ -2,7 +2,7 @@
 /** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, SSROptions } from 'types' */
 
 import { json, error } from '@sveltejs/kit';
-import { HttpError, Redirect, SvelteKitError } from '@sveltejs/kit/internal';
+import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
@@ -14,6 +14,13 @@ import { DEV } from 'esm-env';
 import { record_span } from '../telemetry/record_span.js';
 import { deserialize_binary_form } from '../form-utils.js';
 
+/**
+ * How long (in milliseconds) to wait after the last message was sent before
+ * sending a `: keep-alive` SSE comment, to prevent proxies/load balancers with
+ * an idle timeout from closing an otherwise-quiet `query.live` connection.
+ */
+const KEEP_ALIVE_INTERVAL = 30_000;
+
 /** @type {typeof handle_remote_call_internal} */
 export async function handle_remote_call(event, state, options, manifest, id) {
 	return record_span({
@@ -41,10 +48,10 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 	const [hash, name, additional_args] = id.split('/');
 	const remotes = manifest._.remotes;
 
-	if (!remotes[hash]) error(404);
+	if (!Object.hasOwn(remotes, hash)) error(404);
 
 	const module = await remotes[hash]();
-	const fn = module.default[name];
+	const fn = Object.hasOwn(module.default, name) ? module.default[name] : undefined;
 
 	if (!fn) error(404);
 
@@ -57,6 +64,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		'sveltekit.remote.call.name': internals.name
 	});
 
+	/** @type {HeadersInit | undefined} */
+	const headers = state.prerendering ? undefined : { 'cache-control': 'private, no-store' };
+
 	try {
 		/** @type {RemoteFunctionData} */
 		const data = {};
@@ -79,22 +89,43 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 				const encoder = new TextEncoder();
 
+				let closed = false;
+
+				/** @type {ReturnType<typeof setTimeout> | undefined} */
+				let keep_alive;
+
+				/**
+				 * (Re)schedule the keep-alive comment. Called whenever a message is sent, so
+				 * that a keep-alive is only emitted once `KEEP_ALIVE_INTERVAL` has elapsed
+				 * without any other activity.
+				 * @param {ReadableStreamDefaultController} controller
+				 */
+				function schedule_keep_alive(controller) {
+					clearTimeout(keep_alive);
+					keep_alive = setTimeout(() => {
+						if (closed || event.request.signal.aborted) return;
+						// SSE comments (lines starting with `:`) are ignored by the client
+						controller.enqueue(encoder.encode(': keep-alive\n\n'));
+						schedule_keep_alive(controller);
+					}, KEEP_ALIVE_INTERVAL);
+				}
+
 				/**
 				 * @param {ReadableStreamDefaultController} controller
 				 * @param {any} payload
 				 */
 				function send(controller, payload) {
 					controller.enqueue(encoder.encode('data: ' + JSON.stringify(payload) + '\n\n'));
+					schedule_keep_alive(controller);
 				}
 
-				let closed = false;
-
 				/** @type {string | undefined} */
 				let result = undefined;
 
 				async function cancel() {
 					if (closed) return;
 					closed = true;
+					clearTimeout(keep_alive);
 					await generator.return(undefined);
 				}
 
@@ -102,6 +133,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 				return new Response(
 					new ReadableStream({
+						start(controller) {
+							schedule_keep_alive(controller);
+						},
 						async pull(controller) {
 							if (event.request.signal.aborted) {
 								await cancel();
@@ -137,15 +171,16 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 											location: error.location
 										});
 									} else {
-										const status =
-											error instanceof HttpError || error instanceof SvelteKitError
-												? error.status
-												: 500;
+										const transformed = await handle_error_and_jsonify(
+											event,
+											state,
+											options,
+											error
+										);
 
 										send(controller, {
 											type: 'error',
-											error: await handle_error_and_jsonify(event, state, options, error),
-											status
+											error: transformed
 										});
 									}
 								}
@@ -226,7 +261,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 						/** @type {RemoteFunctionResponse} */ ({
 							type: 'result',
 							data: stringify(data, transport)
-						})
+						}),
+						{ headers }
 					);
 				}
 
@@ -275,7 +311,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'result',
 				data: stringify(data, transport)
-			})
+			}),
+			{ headers }
 		);
 	} catch (error) {
 		if (error instanceof Redirect) {
@@ -285,23 +322,22 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
 					data: stringify(data, transport)
-				})
+				}),
+				{ headers }
 			);
 		}
 
-		const status =
-			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
-				error: await handle_error_and_jsonify(event, state, options, error),
-				status
+				error: transformed
 			}),
 			{
 				// By setting a non-200 during prerendering we fail the prerender process (unless handleHttpError handles it).
 				// Errors at runtime will be passed to the client and are handled there
-				status: state.prerendering ? status : undefined,
+				status: state.prerendering ? transformed.status : undefined,
 				headers: {
 					'cache-control': 'private, no-store'
 				}
@@ -322,20 +358,17 @@ export async function collect_remote_data(data, event, state, options) {
 	/**
 	 *
 	 * @param {unknown} error
-	 * @returns {Promise<[status: number, error: App.Error]>}
+	 * @returns {Promise<App.Error>}
 	 */
-	async function convert_error(error) {
-		const status =
-			error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
-
-		return [status, await handle_error_and_jsonify(event, state, options, error)];
+	function convert_error(error) {
+		return handle_error_and_jsonify(event, state, options, error);
 	}
 
 	/** @type {Promise<any>[]} */
 	const promises = [];
 
 	if (state.remote.explicit) {
-		for (const [remote_key, { internals, promise }] of state.remote.explicit) {
+		for (const [remote_key, { internals, fn }] of state.remote.explicit) {
 			// there were explicit refreshes/reconnects (via `refresh()`/`set()`/`reconnect()`),
 			// so the client should apply these single-flight updates instead of calling `invalidateAll()`
 			data.r = true;
@@ -344,18 +377,27 @@ export async function collect_remote_data(data, event, state, options) {
 				internals.type === 'query_live' ? 'l' : internals.type[0]
 			);
 
-			await promise.then(
-				(v) => {
-					((data[type] ??= {})[remote_key] ??= {}).v = v;
-				},
-				async (e) => {
-					if (e instanceof Redirect) {
-						// already handled elsewhere
-						return;
-					}
+			// `fn` is deferred until now so the query runs after any state mutations
+			// in the command/form body. If the query was re-awaited in the meantime,
+			// `fn` returns the existing (fresh) cache entry rather than re-running.
+			// Kick off the query immediately and collect the promise so that multiple
+			// explicit refreshes run concurrently rather than serially.
+			const promise = fn();
+
+			promises.push(
+				promise.then(
+					(v) => {
+						((data[type] ??= {})[remote_key] ??= {}).v = v;
+					},
+					async (e) => {
+						if (e instanceof Redirect) {
+							// already handled elsewhere
+							return;
+						}
 
-					((data[type] ??= {})[remote_key] ??= {}).e = await convert_error(e);
-				}
+						((data[type] ??= {})[remote_key] ??= {}).e = await convert_error(e);
+					}
+				)
 			);
 		}
 	}
@@ -468,9 +510,11 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 	const [hash, name, ...rest] = id.split('/');
 	const action_id = rest.join('/');
 	const remotes = manifest._.remotes;
-	const module = await remotes[hash]?.();
+	const module = Object.hasOwn(remotes, hash) ? await remotes[hash]() : undefined;
 
-	let form = /** @type {RemoteForm<any, any>} */ (module?.default[name]);
+	let form = /** @type {RemoteForm<any, any>} */ (
+		module && Object.hasOwn(module.default, name) ? module.default[name] : undefined
+	);
 
 	if (!form) {
 		event.setHeaders({
@@ -480,6 +524,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 		});
 		return {
 			type: 'error',
+			// We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: new SvelteKitError(
 				405,
 				'Method Not Allowed',
@@ -526,6 +571,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 
 		return {
 			type: 'error',
+			// @ts-expect-error We're lying a bit with the types here; this will be transformed into a proper App.Error object later
 			error: check_incorrect_fail_use(err)
 		};
 	}

package/src/runtime/server/respond.js

@@ -8,7 +8,7 @@ import { is_endpoint_request, render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
-import { is_form_content_type } from '../../utils/http.js';
+import { get_self_origin, is_csrf_forbidden, is_remote_forbidden } from './csrf.js';
 import {
 	handle_fatal_error,
 	has_prerendered_path,
@@ -72,21 +72,26 @@ export async function internal_respond(request, options, manifest, state) {
 
 	if (!DEV) {
 		const request_origin = request.headers.get('origin');
+		const self_origin = get_self_origin(options.paths_origin, url.origin);
 
 		if (remote_id) {
-			if (request.method !== 'GET' && request_origin !== url.origin) {
+			if (
+				is_remote_forbidden({
+					request,
+					request_origin,
+					self_origin
+				})
+			) {
 				const message = 'Cross-site remote requests are forbidden';
 				return json({ message }, { status: 403 });
 			}
 		} else if (options.csrf_check_origin) {
-			const forbidden =
-				is_form_content_type(request) &&
-				(request.method === 'POST' ||
-					request.method === 'PUT' ||
-					request.method === 'PATCH' ||
-					request.method === 'DELETE') &&
-				request_origin !== url.origin &&
-				(!request_origin || !options.csrf_trusted_origins.includes(request_origin));
+			const forbidden = is_csrf_forbidden({
+				request,
+				request_origin,
+				self_origin,
+				trusted_origins: options.csrf_trusted_origins
+			});
 
 			if (forbidden) {
 				const message = `Cross-site ${request.method} form submissions are forbidden`;
@@ -319,7 +324,7 @@ export async function internal_respond(request, options, manifest, state) {
 		return resolve_route(resolved_path, new URL(request.url), manifest);
 	}
 
-	if (resolved_path === `/${app_dir}/env.js` || resolved_path === `/${app_dir}/env.script.js`) {
+	if (resolved_path === `/${app_dir}/env.js`) {
 		return get_public_env(request);
 	}
 
@@ -331,14 +336,17 @@ export async function internal_respond(request, options, manifest, state) {
 	}
 
 	if (!state.prerendering?.fallback) {
-		// TODO this could theoretically break — should probably be inside a try-catch
-		const matchers = await manifest._.matchers();
-		const result = find_route(resolved_path, manifest._.routes, matchers);
-
-		if (result) {
-			route = result.route;
-			event.route = { id: route.id };
-			event.params = result.params;
+		try {
+			const matchers = await manifest._.matchers();
+			const result = find_route(resolved_path, manifest._.routes, matchers);
+
+			if (result) {
+				route = result.route;
+				event.route = { id: route.id };
+				event.params = result.params;
+			}
+		} catch (e) {
+			return await handle_fatal_error(event, event_state, options, e);
 		}
 	}
 
@@ -619,54 +627,80 @@ export async function internal_respond(request, options, manifest, state) {
 						invalidated_data_nodes,
 						trailing_slash
 					);
-				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
-					response = await render_endpoint(event, event_state, await route.endpoint(), state);
-				} else if (route.page) {
-					if (!page_nodes) {
-						throw new Error('page_nodes not found. This should never happen');
-					} else if (page_methods.has(method)) {
-						response = await render_page(
-							event,
-							event_state,
-							route.page,
-							options,
-							manifest,
-							state,
-							page_nodes,
-							resolve_opts
-						);
-					} else {
-						const allowed_methods = new Set(allowed_page_methods);
-						const node = await manifest._.nodes[route.page.leaf]();
-						if (node?.server?.actions) {
-							allowed_methods.add('POST');
+				} else {
+					let endpoint;
+					if (
+						route.endpoint &&
+						(!route.page || (!state.prerendering && is_endpoint_request(event)))
+					) {
+						endpoint = await route.endpoint();
+
+						// Prefer rendering the page if the endpoint can't handle this GET or HEAD request
+						if (route.page && (method === 'GET' || method === 'HEAD')) {
+							const endpoint_can_handle = !!(
+								endpoint.GET ||
+								endpoint.fallback ||
+								(method === 'HEAD' && endpoint.HEAD)
+							);
+							if (!endpoint_can_handle) {
+								endpoint = undefined;
+							}
 						}
+					}
 
-						if (method === 'OPTIONS') {
-							// This will deny CORS preflight requests implicitly because we don't
-							// add the required CORS headers to the response.
-							response = new Response(null, {
-								status: 204,
-								headers: {
-									allow: Array.from(allowed_methods.values()).join(', ')
-								}
-							});
+					if (endpoint) {
+						response = await render_endpoint(event, event_state, endpoint, state);
+					} else if (route.page) {
+						if (!page_nodes) {
+							throw new Error('page_nodes not found. This should never happen');
+						} else if (page_methods.has(method)) {
+							response = await render_page(
+								event,
+								event_state,
+								route.page,
+								options,
+								manifest,
+								state,
+								page_nodes,
+								resolve_opts
+							);
 						} else {
-							const mod = [...allowed_methods].reduce((acc, curr) => {
-								acc[curr] = true;
-								return acc;
-							}, /** @type {Record<string, any>} */ ({}));
-							response = method_not_allowed(mod, method);
+							const allowed_methods = new Set(allowed_page_methods);
+							const node = await manifest._.nodes[route.page.leaf]();
+							if (node?.server?.actions) {
+								allowed_methods.add('POST');
+							}
+
+							if (method === 'OPTIONS') {
+								// This will deny CORS preflight requests implicitly because we don't
+								// add the required CORS headers to the response.
+								response = new Response(null, {
+									status: 204,
+									headers: {
+										allow: Array.from(allowed_methods.values()).join(', ')
+									}
+								});
+							} else {
+								const mod = [...allowed_methods].reduce((acc, curr) => {
+									acc[curr] = true;
+									return acc;
+								}, /** @type {Record<string, any>} */ ({}));
+								response = method_not_allowed(mod, method);
+							}
 						}
+					} else {
+						// a route will always have a page or an endpoint, but TypeScript doesn't know that
+						throw new Error('Route is neither page nor endpoint. This should never happen');
 					}
-				} else {
-					// a route will always have a page or an endpoint, but TypeScript doesn't know that
-					throw new Error('Route is neither page nor endpoint. This should never happen');
 				}
 
 				// If the route contains a page and an endpoint, we need to add a
 				// `Vary: Accept` header to the response because of browser caching
-				if (request.method === 'GET' && route.page && route.endpoint) {
+				if (
+					(request.method === 'GET' || request.method === 'HEAD') &&
+					route.page &&
+					route.endpoint
+				) {
 					const vary = response.headers
 						.get('vary')
 						?.split(',')

package/src/runtime/server/utils.js

@@ -75,8 +75,8 @@ export function static_error_page(options, status, message) {
  */
 export async function handle_fatal_error(event, state, options, error) {
 	error = error instanceof HttpError ? error : coalesce_to_error(error);
-	const status = get_status(error);
 	const body = await handle_error_and_jsonify(event, state, options, error);
+	const status = body.status;
 
 	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
 	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
@@ -113,11 +113,11 @@ export async function handle_error_and_jsonify(event, state, options, error) {
 	const status = get_status(error);
 	const message = get_message(error);
 
-	return (
-		(await with_request_store({ event, state }, () =>
-			options.hooks.handleError({ error, event, status, message })
-		)) ?? { message }
-	);
+	const body = (await with_request_store({ event, state }, () =>
+		options.hooks.handleError({ error, event, status, message })
+	)) ?? { message };
+
+	return { ...body, status: get_status(body, error) };
 }
 
 /**
@@ -228,7 +228,7 @@ export function clean_up_stack_trace(error) {
 		return line.replace(/\((.+)(:\d+:\d+)\)$/, (_, file, loc) => `(${relative(file)}${loc})`);
 	});
 
-	// progressive enhancement for people who haven't configured kit.files.src to something else
+	// progressive enhancement for people who haven't configured files.src to something else
 	const last_line_from_src_code = stack_trace.findLastIndex((line) => /\(src[\\/]/.test(line));
 
 	if (last_line_from_src_code === -1) {

package/src/runtime/telemetry/otel.js

@@ -15,7 +15,7 @@ if (__SVELTEKIT_SERVER_TRACING_ENABLED__) {
 		})
 		.catch(() => {
 			throw new Error(
-				'Tracing is enabled (see `config.kit.experimental.instrumentation.server` in your svelte.config.js), but `@opentelemetry/api` is not available. This error will likely resolve itself when you set up your tracing instrumentation in `instrumentation.server.js`. For more information, see https://svelte.dev/docs/kit/observability#opentelemetry-api'
+				'Tracing is enabled (see the SvelteKit plugin `tracing.server` option in your vite.config.js), but `@opentelemetry/api` is not available. This error will likely resolve itself when you set up your tracing instrumentation in `instrumentation.server.js`. For more information, see https://svelte.dev/docs/kit/observability#opentelemetry-api'
 			);
 		});
 }

package/src/types/ambient.d.ts

@@ -25,29 +25,34 @@ declare namespace App {
 	 * Defines the common shape of expected and unexpected errors. Expected errors are thrown using the `error` function. Unexpected errors are handled by the `handleError` hooks which should return this shape.
 	 */
 	export interface Error {
+		status: number;
 		message: string;
 	}
 
 	/**
 	 * The interface that defines `event.locals`, which can be accessed in server [hooks](https://svelte.dev/docs/kit/hooks) (`handle`, and `handleError`), server-only `load` functions, and `+server.js` files.
 	 */
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 	export interface Locals {}
 
 	/**
-	 * Defines the common shape of the [page.data state](https://svelte.dev/docs/kit/$app-state#page) and [$page.data store](https://svelte.dev/docs/kit/$app-stores#page) - that is, the data that is shared between all pages.
+	 * Defines the common shape of the [page.data state](https://svelte.dev/docs/kit/$app-state#page) - that is, the data that is shared between all pages.
 	 * The `Load` and `ServerLoad` functions in `./$types` will be narrowed accordingly.
 	 * Use optional properties for data that is only present on specific pages. Do not add an index signature (`[key: string]: any`).
 	 */
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 	export interface PageData {}
 
 	/**
 	 * The shape of the `page.state` object, which can be manipulated using the [`pushState`](https://svelte.dev/docs/kit/$app-navigation#pushState) and [`replaceState`](https://svelte.dev/docs/kit/$app-navigation#replaceState) functions from `$app/navigation`.
 	 */
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 	export interface PageState {}
 
 	/**
 	 * If your adapter provides [platform-specific context](https://svelte.dev/docs/kit/adapters#Platform-specific-context) via `event.platform`, you can specify it here.
 	 */
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 	export interface Platform {}
 }
 
@@ -56,8 +61,8 @@ declare namespace App {
  */
 declare module '$service-worker' {
 	/**
-	 * The `base` path of the deployment. Typically this is equivalent to `config.kit.paths.base`, but it is calculated from `location.pathname` meaning that it will continue to work correctly if the site is deployed to a subdirectory.
-	 * Note that there is a `base` but no `assets`, since service workers cannot be used if `config.kit.paths.assets` is specified.
+	 * The `base` path of the deployment. Typically this is equivalent to `config.paths.base`, but it is calculated from `location.pathname` meaning that it will continue to work correctly if the site is deployed to a subdirectory.
+	 * Note that there is a `base` but no `assets`, since service workers cannot be used if `config.paths.assets` is specified.
 	 */
 	export const base: string;
 	/**
@@ -66,7 +71,7 @@ declare module '$service-worker' {
 	 */
 	export const build: string[];
 	/**
-	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.kit.files.assets`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](https://svelte.dev/docs/kit/configuration#serviceWorker)
+	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.files.assets`. You can customize which files are included from `static` directory using [`config.serviceWorker.files`](https://svelte.dev/docs/kit/configuration#serviceWorker)
 	 */
 	export const files: string[];
 	/**
@@ -75,7 +80,7 @@ declare module '$service-worker' {
 	 */
 	export const prerendered: string[];
 	/**
-	 * See [`config.kit.version`](https://svelte.dev/docs/kit/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
+	 * See [`config.version`](https://svelte.dev/docs/kit/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
 	 */
 	export const version: string;
 }

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

@@ -15,13 +15,13 @@ declare global {
 	const __SVELTEKIT_PATHS_ASSETS__: string;
 	const __SVELTEKIT_PATHS_BASE__: string;
 	const __SVELTEKIT_PATHS_RELATIVE__: boolean;
-	/** True if `config.kit.experimental.instrumentation.server` is `true` */
+	/** True if `config.tracing.server` is `true` */
 	const __SVELTEKIT_SERVER_TRACING_ENABLED__: boolean;
-	/** True if `config.kit.experimental.forkPreloads` is `true` */
+	/** True if `config.experimental.forkPreloads` is `true` */
 	const __SVELTEKIT_FORK_PRELOADS__: boolean;
-	/** True if `config.kit.router.resolution === 'client'` */
+	/** True if `config.router.resolution === 'client'` */
 	const __SVELTEKIT_CLIENT_ROUTING__: boolean;
-	/** True if `config.kit.router.type === 'hash'` */
+	/** True if `config.router.type === 'hash'` */
 	const __SVELTEKIT_HASH_ROUTING__: boolean;
 	/**
 	 * True if any node in the manifest has a server load function.