@sveltejs/kit 2.18.0 → 2.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.18.0",
+  "version": "2.19.1",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",

package/src/core/postbuild/analyse.js

@@ -1,22 +1,15 @@
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { get_option } from '../../utils/options.js';
-import {
-	validate_layout_exports,
-	validate_layout_server_exports,
-	validate_page_exports,
-	validate_page_server_exports,
-	validate_server_exports
-} from '../../utils/exports.js';
+import { validate_server_exports } from '../../utils/exports.js';
 import { load_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { has_server_load, resolve_route } from '../../utils/routing.js';
-import { get_page_config } from '../../utils/route_config.js';
 import { check_feature } from '../../utils/features.js';
 import { createReadableStream } from '@sveltejs/kit/node';
+import { PageNodes } from '../../utils/page_nodes.js';
 
 export default forked(import.meta.url, analyse);
 
@@ -190,25 +183,18 @@ function analyse_endpoint(route, mod) {
  * @param {import('types').SSRNode} leaf
  */
 function analyse_page(layouts, leaf) {
-	for (const layout of layouts) {
-		if (layout) {
-			validate_layout_server_exports(layout.server, layout.server_id);
-			validate_layout_exports(layout.universal, layout.universal_id);
-		}
-	}
-
 	/** @type {Array<'GET' | 'POST'>} */
 	const methods = ['GET'];
 	if (leaf.server?.actions) methods.push('POST');
 
-	validate_page_server_exports(leaf.server, leaf.server_id);
-	validate_page_exports(leaf.universal, leaf.universal_id);
+	const nodes = new PageNodes([...layouts, leaf]);
+	nodes.validate();
 
 	return {
-		config: get_page_config([...layouts, leaf]),
+		config: nodes.get_config(),
 		entries: leaf.universal?.entries ?? leaf.server?.entries,
 		methods,
-		prerender: get_option([...layouts, leaf], 'prerender') ?? false
+		prerender: nodes.prerender()
 	};
 }
 

package/src/exports/index.js

@@ -229,6 +229,7 @@ export function isActionFailure(e) {
  * ```
  * @param {URL | string} url
  * @returns {{ url: URL, wasNormalized: boolean, denormalize: (url?: string | URL) => URL }}
+ * @since 2.18.0
  */
 export function normalizeUrl(url) {
 	url = new URL(url, 'http://internal');

package/src/exports/public.d.ts

@@ -814,7 +814,7 @@ export type ClientInit = () => MaybePromise<void>;
  * The [`reroute`](https://svelte.dev/docs/kit/hooks#Universal-hooks-reroute) hook allows you to modify the URL before it is used to determine which route to render.
  * @since 2.3.0
  */
-export type Reroute = (event: { url: URL }) => MaybePromise<void | string>;
+export type Reroute = (event: { url: URL; fetch: typeof fetch }) => MaybePromise<void | string>;
 
 /**
  * The [`transport`](https://svelte.dev/docs/kit/hooks#Universal-hooks-transport) hook allows you to transport custom types across the server/client boundary.

package/src/runtime/client/client.js

@@ -188,6 +188,17 @@ const components = [];
 /** @type {{id: string, token: {}, promise: Promise<import('./types.js').NavigationResult>} | null} */
 let load_cache = null;
 
+/**
+ * @type {Map<string, Promise<URL>>}
+ * Cache for client-side rerouting, since it could contain async calls which we want to
+ * avoid running multiple times which would slow down navigations (e.g. else preloading
+ * wouldn't help because on navigation it would be called again). Since `reroute` should be
+ * a pure function (i.e. always return the same) value it's safe to cache across navigations.
+ * The server reroute calls don't need to be cached because they are called using `import(...)`
+ * which is cached per the JS spec.
+ */
+const reroute_cache = new Map();
+
 /**
  * Note on before_navigate_callbacks, on_navigate_callbacks and after_navigate_callbacks:
  * do not re-assign as some closures keep references to these Sets
@@ -679,12 +690,7 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 				app.hash
 			),
 			async fetch(resource, init) {
-				/** @type {URL | string} */
-				let requested;
-
 				if (resource instanceof Request) {
-					requested = resource.url;
-
 					// we're not allowed to modify the received `Request` object, so in order
 					// to fixup relative urls we create a new equivalent `init` object instead
 					init = {
@@ -709,25 +715,15 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 						signal: resource.signal,
 						...init
 					};
-				} else {
-					requested = resource;
 				}
 
-				// we must fixup relative urls so they are resolved from the target page
-				const resolved = new URL(requested, url);
+				const { resolved, promise } = resolve_fetch_url(resource, init, url);
+
 				if (is_tracking) {
 					depends(resolved.href);
 				}
 
-				// match ssr serialized data url, which is important to find cached responses
-				if (resolved.origin === url.origin) {
-					requested = resolved.href.slice(url.origin.length);
-				}
-
-				// prerendered pages may be served from any origin, so `initial_fetch` urls shouldn't be resolved
-				return started
-					? subsequent_fetch(requested, resolved.href, init)
-					: initial_fetch(requested, init);
+				return promise;
 			},
 			setHeaders: () => {}, // noop
 			depends,
@@ -782,6 +778,30 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 	};
 }
 
+/**
+ * @param {Request | string | URL} input
+ * @param {RequestInit | undefined} init
+ * @param {URL} url
+ */
+function resolve_fetch_url(input, init, url) {
+	let requested = input instanceof Request ? input.url : input;
+
+	// we must fixup relative urls so they are resolved from the target page
+	const resolved = new URL(requested, url);
+
+	// match ssr serialized data url, which is important to find cached responses
+	if (resolved.origin === url.origin) {
+		requested = resolved.href.slice(url.origin.length);
+	}
+
+	// prerendered pages may be served from any origin, so `initial_fetch` urls shouldn't be resolved
+	const promise = started
+		? subsequent_fetch(requested, resolved.href, init)
+		: initial_fetch(requested, init);
+
+	return { resolved, promise };
+}
+
 /**
  * @param {boolean} parent_changed
  * @param {boolean} route_changed
@@ -1201,23 +1221,44 @@ async function load_root_error_page({ status, error, url, route }) {
  * @returns {Promise<URL | undefined>}
  */
 async function get_rerouted_url(url) {
+	const href = url.href;
+
+	if (reroute_cache.has(href)) {
+		return reroute_cache.get(href);
+	}
+
 	let rerouted;
+
 	try {
-		// reroute could alter the given URL, so we pass a copy
-		rerouted = (await app.hooks.reroute({ url: new URL(url) })) ?? url;
+		const promise = (async () => {
+			// reroute could alter the given URL, so we pass a copy
+			let rerouted =
+				(await app.hooks.reroute({
+					url: new URL(url),
+					fetch: async (input, init) => {
+						return resolve_fetch_url(input, init, url).promise;
+					}
+				})) ?? url;
 
-		if (typeof rerouted === 'string') {
-			const tmp = new URL(url); // do not mutate the incoming URL
+			if (typeof rerouted === 'string') {
+				const tmp = new URL(url); // do not mutate the incoming URL
 
-			if (app.hash) {
-				tmp.hash = rerouted;
-			} else {
-				tmp.pathname = rerouted;
+				if (app.hash) {
+					tmp.hash = rerouted;
+				} else {
+					tmp.pathname = rerouted;
+				}
+
+				rerouted = tmp;
 			}
 
-			rerouted = tmp;
-		}
+			return rerouted;
+		})();
+
+		reroute_cache.set(href, promise);
+		rerouted = await promise;
 	} catch (e) {
+		reroute_cache.delete(href);
 		if (DEV) {
 			// in development, print the error...
 			console.error(e);

package/src/runtime/server/cookie.js

@@ -29,13 +29,13 @@ function validate_options(options) {
 /**
  * @param {Request} request
  * @param {URL} url
- * @param {import('types').TrailingSlash} trailing_slash
  */
-export function get_cookies(request, url, trailing_slash) {
+export function get_cookies(request, url) {
 	const header = request.headers.get('cookie') ?? '';
 	const initial_cookies = parse(header, { decode: (value) => value });
 
-	const normalized_url = normalize_path(url.pathname, trailing_slash);
+	/** @type {string | undefined} */
+	let normalized_url;
 
 	/** @type {Record<string, import('./page/types.js').Cookie>} */
 	const new_cookies = {};
@@ -149,6 +149,9 @@ export function get_cookies(request, url, trailing_slash) {
 			let path = options.path;
 
 			if (!options.domain || options.domain === url.hostname) {
+				if (!normalized_url) {
+					throw new Error('Cannot serialize cookies until after the route is determined');
+				}
 				path = resolve(normalized_url, path);
 			}
 
@@ -190,12 +193,20 @@ export function get_cookies(request, url, trailing_slash) {
 			.join('; ');
 	}
 
+	/** @type {Array<() => void>} */
+	const internal_queue = [];
+
 	/**
 	 * @param {string} name
 	 * @param {string} value
 	 * @param {import('./page/types.js').Cookie['options']} options
 	 */
 	function set_internal(name, value, options) {
+		if (!normalized_url) {
+			internal_queue.push(() => set_internal(name, value, options));
+			return;
+		}
+
 		let path = options.path;
 
 		if (!options.domain || options.domain === url.hostname) {
@@ -220,7 +231,15 @@ export function get_cookies(request, url, trailing_slash) {
 		}
 	}
 
-	return { cookies, new_cookies, get_cookie_header, set_internal };
+	/**
+	 * @param {import('types').TrailingSlash} trailing_slash
+	 */
+	function set_trailing_slash(trailing_slash) {
+		normalized_url = normalize_path(url.pathname, trailing_slash);
+		internal_queue.forEach((fn) => fn());
+	}
+
+	return { cookies, new_cookies, get_cookie_header, set_internal, set_trailing_slash };
 }
 
 /**

package/src/runtime/server/fetch.js

@@ -2,6 +2,7 @@ import * as set_cookie_parser from 'set-cookie-parser';
 import { respond } from './respond.js';
 import * as paths from '__sveltekit/paths';
 import { read_implementation } from '__sveltekit/server';
+import { has_prerendered_path } from './utils.js';
 
 /**
  * @param {{
@@ -112,10 +113,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					return await fetch(request);
 				}
 
-				if (
-					manifest._.prerendered_routes.has(decoded) ||
-					(decoded.at(-1) === '/' && manifest._.prerendered_routes.has(decoded.slice(0, -1)))
-				) {
+				if (has_prerendered_path(manifest, paths.base + decoded)) {
 					// The path of something prerendered could match a different route
 					// that is still in the manifest, leading to the wrong route being loaded.
 					// We therefore bail early here. The prerendered logic is different for

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

@@ -214,7 +214,7 @@ function check_named_default_separate(actions) {
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {NonNullable<import('types').SSRNode['server']['actions']>} actions
+ * @param {NonNullable<import('types').ServerNode['actions']>} actions
  * @throws {Redirect | HttpError | SvelteKitError | Error}
  */
 async function call_action(event, actions) {

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

@@ -13,9 +13,7 @@ import {
 import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
-import { get_option } from '../../../utils/options.js';
 import { get_data_json } from '../data/index.js';
-import { load_page_nodes } from './load_page_nodes.js';
 import { DEV } from 'esm-env';
 
 /**
@@ -29,10 +27,11 @@ const MAX_DEPTH = 10;
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').SSRState} state
+ * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {import('types').RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, page, options, manifest, state, resolve_opts) {
+export async function render_page(event, page, options, manifest, state, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -46,9 +45,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 	}
 
 	try {
-		const nodes = await load_page_nodes(page, manifest);
-
-		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
+		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.page());
 
 		let status = 200;
 
@@ -70,16 +67,10 @@ export async function render_page(event, page, options, manifest, state, resolve
 			}
 		}
 
-		const should_prerender_data = nodes.some(
-			// prerender in case of trailingSlash because the client retrieves that value from the server
-			(node) => node?.server?.load || node?.server?.trailingSlash !== undefined
-		);
-		const data_pathname = add_data_suffix(event.url.pathname);
-
 		// it's crucial that we do this before returning the non-SSR response, otherwise
 		// SvelteKit will erroneously believe that the path has been prerendered,
 		// causing functions to be omitted from the manifest generated later
-		const should_prerender = get_option(nodes, 'prerender') ?? false;
+		const should_prerender = nodes.prerender();
 		if (should_prerender) {
 			const mod = leaf_node.server;
 			if (mod?.actions) {
@@ -96,13 +87,16 @@ export async function render_page(event, page, options, manifest, state, resolve
 		// inherit the prerender option of the page
 		state.prerender_default = should_prerender;
 
+		const should_prerender_data = nodes.should_prerender_data();
+		const data_pathname = add_data_suffix(event.url.pathname);
+
 		/** @type {import('./types.js').Fetched[]} */
 		const fetched = [];
 
 		// renders an empty 'shell' page if SSR is turned off and if there is
 		// no server data to prerender. As a result, the load functions and rendering
 		// only occur client-side.
-		if (get_option(nodes, 'ssr') === false && !(state.prerendering && should_prerender_data)) {
+		if (nodes.ssr() === false && !(state.prerendering && should_prerender_data)) {
 			// if the user makes a request through a non-enhanced form, the returned value is lost
 			// because there is no SSR or client-side handling of the response
 			if (DEV && action_result && !event.request.headers.has('x-sveltekit-action')) {
@@ -123,7 +117,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 				fetched,
 				page_config: {
 					ssr: false,
-					csr: get_option(nodes, 'csr') ?? true
+					csr: nodes.csr()
 				},
 				status,
 				error: null,
@@ -142,7 +136,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 		let load_error = null;
 
 		/** @type {Array<Promise<import('types').ServerDataNode | null>>} */
-		const server_promises = nodes.map((node, i) => {
+		const server_promises = nodes.data.map((node, i) => {
 			if (load_error) {
 				// if an error happens immediately, don't bother with the rest of the nodes
 				throw load_error;
@@ -177,10 +171,10 @@ export async function render_page(event, page, options, manifest, state, resolve
 			});
 		});
 
-		const csr = get_option(nodes, 'csr') ?? true;
+		const csr = nodes.csr();
 
 		/** @type {Array<Promise<Record<string, any> | null>>} */
-		const load_promises = nodes.map((node, i) => {
+		const load_promises = nodes.data.map((node, i) => {
 			if (load_error) throw load_error;
 			return Promise.resolve().then(async () => {
 				try {
@@ -211,8 +205,8 @@ export async function render_page(event, page, options, manifest, state, resolve
 		for (const p of server_promises) p.catch(() => {});
 		for (const p of load_promises) p.catch(() => {});
 
-		for (let i = 0; i < nodes.length; i += 1) {
-			const node = nodes[i];
+		for (let i = 0; i < nodes.data.length; i += 1) {
+			const node = nodes.data[i];
 
 			if (node) {
 				try {
@@ -300,7 +294,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 			});
 		}
 
-		const ssr = get_option(nodes, 'ssr') ?? true;
+		const ssr = nodes.ssr();
 
 		return await render_response({
 			event,
@@ -309,7 +303,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 			state,
 			resolve_opts,
 			page_config: {
-				csr: get_option(nodes, 'csr') ?? true,
+				csr: nodes.csr(),
 				ssr
 			},
 			status,

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

@@ -116,11 +116,6 @@ export async function render_response({
 	}
 
 	if (page_config.ssr) {
-		if (__SVELTEKIT_DEV__ && !branch.at(-1)?.node.component) {
-			// Can only be the leaf, layouts have a fallback component generated
-			throw new Error(`Missing +page.svelte component for route ${event.route.id}`);
-		}
-
 		/** @type {Record<string, any>} */
 		const props = {
 			stores: {
@@ -128,7 +123,15 @@ export async function render_response({
 				navigating: writable(null),
 				updated
 			},
-			constructors: await Promise.all(branch.map(({ node }) => node.component())),
+			constructors: await Promise.all(
+				branch.map(({ node }) => {
+					if (!node.component) {
+						// Can only be the leaf, layouts have a fallback component generated
+						throw new Error(`Missing +page.svelte component for route ${event.route.id}`);
+					}
+					return node.component();
+				})
+			),
 			form: form_value
 		};
 

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

@@ -1,9 +1,9 @@
 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_option } from '../../../utils/options.js';
 import { Redirect } from '../../control.js';
 import { get_status } from '../../../utils/error.js';
+import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**
  * @typedef {import('./types.js').Loaded} Loaded
@@ -40,8 +40,9 @@ export async function respond_with_error({
 	try {
 		const branch = [];
 		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
-		const ssr = get_option([default_layout], 'ssr') ?? true;
-		const csr = get_option([default_layout], 'csr') ?? true;
+		const nodes = new PageNodes([default_layout]);
+		const ssr = nodes.ssr();
+		const csr = nodes.csr();
 
 		if (ssr) {
 			state.error = true;

package/src/runtime/server/respond.js

@@ -5,30 +5,29 @@ 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 { handle_fatal_error, method_not_allowed, redirect_response } from './utils.js';
+import {
+	handle_fatal_error,
+	has_prerendered_path,
+	method_not_allowed,
+	redirect_response
+} from './utils.js';
 import { decode_pathname, decode_params, disable_search, normalize_path } from '../../utils/url.js';
 import { exec } from '../../utils/routing.js';
 import { redirect_json_response, render_data } from './data/index.js';
 import { add_cookies_to_headers, get_cookies } from './cookie.js';
 import { create_fetch } from './fetch.js';
+import { PageNodes } from '../../utils/page_nodes.js';
 import { HttpError, Redirect, SvelteKitError } from '../control.js';
-import {
-	validate_layout_exports,
-	validate_layout_server_exports,
-	validate_page_exports,
-	validate_page_server_exports,
-	validate_server_exports
-} from '../../utils/exports.js';
-import { get_option } from '../../utils/options.js';
+import { validate_server_exports } from '../../utils/exports.js';
 import { json, text } from '../../exports/index.js';
 import { action_json_redirect, is_action_json_request } from './page/actions.js';
 import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM } from '../shared.js';
 import { get_public_env } from './env_module.js';
-import { load_page_nodes } from './page/load_page_nodes.js';
-import { get_page_config } from '../../utils/route_config.js';
 import { resolve_route } from './page/server_routing.js';
 import { validateHeaders } from './validate-headers.js';
 import {
+	add_data_suffix,
+	add_resolution_suffix,
 	has_data_suffix,
 	has_resolution_suffix,
 	strip_data_suffix,
@@ -111,11 +110,82 @@ export async function respond(request, options, manifest, state) {
 		url.searchParams.delete(INVALIDATED_PARAM);
 	}
 
+	/** @type {Record<string, string>} */
+	const headers = {};
+
+	const { cookies, new_cookies, get_cookie_header, set_internal, set_trailing_slash } = get_cookies(
+		request,
+		url
+	);
+
+	/** @type {import('@sveltejs/kit').RequestEvent} */
+	const event = {
+		cookies,
+		// @ts-expect-error `fetch` needs to be created after the `event` itself
+		fetch: null,
+		getClientAddress:
+			state.getClientAddress ||
+			(() => {
+				throw new Error(
+					`${__SVELTEKIT_ADAPTER_NAME__} does not specify getClientAddress. Please raise an issue`
+				);
+			}),
+		locals: {},
+		params: {},
+		platform: state.platform,
+		request,
+		route: { id: null },
+		setHeaders: (new_headers) => {
+			if (__SVELTEKIT_DEV__) {
+				validateHeaders(new_headers);
+			}
+
+			for (const key in new_headers) {
+				const lower = key.toLowerCase();
+				const value = new_headers[key];
+
+				if (lower === 'set-cookie') {
+					throw new Error(
+						'Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies'
+					);
+				} else if (lower in headers) {
+					throw new Error(`"${key}" header is already set`);
+				} else {
+					headers[lower] = value;
+
+					if (state.prerendering && lower === 'cache-control') {
+						state.prerendering.cache = /** @type {string} */ (value);
+					}
+				}
+			}
+		},
+		url,
+		isDataRequest: is_data_request,
+		isSubRequest: state.depth > 0
+	};
+
+	event.fetch = create_fetch({
+		event,
+		options,
+		manifest,
+		state,
+		get_cookie_header,
+		set_internal
+	});
+
+	if (state.emulator?.platform) {
+		event.platform = await state.emulator.platform({
+			config: {},
+			prerender: !!state.prerendering?.fallback
+		});
+	}
+
 	let resolved_path;
 
 	try {
 		// reroute could alter the given URL, so we pass a copy
-		resolved_path = (await options.hooks.reroute({ url: new URL(url) })) ?? url.pathname;
+		resolved_path =
+			(await options.hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
 	} catch {
 		return text('Internal Server Error', {
 			status: 500
@@ -128,12 +198,37 @@ export async function respond(request, options, manifest, state) {
 		return text('Malformed URI', { status: 400 });
 	}
 
+	if (
+		resolved_path !== url.pathname &&
+		!state.prerendering?.fallback &&
+		has_prerendered_path(manifest, resolved_path)
+	) {
+		const url = new URL(request.url);
+		url.pathname = is_data_request
+			? add_data_suffix(resolved_path)
+			: is_route_resolution_request
+				? add_resolution_suffix(resolved_path)
+				: resolved_path;
+
+		// `fetch` automatically decodes the body, so we need to delete the related headers to not break the response
+		// Also see https://github.com/sveltejs/kit/issues/12197 for more info (we should fix this more generally at some point)
+		const response = await fetch(url, request);
+		const headers = new Headers(response.headers);
+		if (headers.has('content-encoding')) {
+			headers.delete('content-encoding');
+			headers.delete('content-length');
+		}
+
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	}
+
 	/** @type {import('types').SSRRoute | null} */
 	let route = null;
 
-	/** @type {Record<string, string>} */
-	let params = {};
-
 	if (base && !state.prerendering?.fallback) {
 		if (!resolved_path.startsWith(base)) {
 			return text('Not found', { status: 404 });
@@ -167,68 +262,13 @@ export async function respond(request, options, manifest, state) {
 			const matched = exec(match, candidate.params, matchers);
 			if (matched) {
 				route = candidate;
-				params = decode_params(matched);
+				event.route = { id: route.id };
+				event.params = decode_params(matched);
 				break;
 			}
 		}
 	}
 
-	/** @type {import('types').TrailingSlash | void} */
-	let trailing_slash = undefined;
-
-	/** @type {Record<string, string>} */
-	const headers = {};
-
-	/** @type {Record<string, import('./page/types.js').Cookie>} */
-	let cookies_to_add = {};
-
-	/** @type {import('@sveltejs/kit').RequestEvent} */
-	const event = {
-		// @ts-expect-error `cookies` and `fetch` need to be created after the `event` itself
-		cookies: null,
-		// @ts-expect-error
-		fetch: null,
-		getClientAddress:
-			state.getClientAddress ||
-			(() => {
-				throw new Error(
-					`${__SVELTEKIT_ADAPTER_NAME__} does not specify getClientAddress. Please raise an issue`
-				);
-			}),
-		locals: {},
-		params,
-		platform: state.platform,
-		request,
-		route: { id: route?.id ?? null },
-		setHeaders: (new_headers) => {
-			if (__SVELTEKIT_DEV__) {
-				validateHeaders(new_headers);
-			}
-
-			for (const key in new_headers) {
-				const lower = key.toLowerCase();
-				const value = new_headers[key];
-
-				if (lower === 'set-cookie') {
-					throw new Error(
-						'Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies'
-					);
-				} else if (lower in headers) {
-					throw new Error(`"${key}" header is already set`);
-				} else {
-					headers[lower] = value;
-
-					if (state.prerendering && lower === 'cache-control') {
-						state.prerendering.cache = /** @type {string} */ (value);
-					}
-				}
-			}
-		},
-		url,
-		isDataRequest: is_data_request,
-		isSubRequest: state.depth > 0
-	};
-
 	/** @type {import('types').RequiredResolveOptions} */
 	let resolve_opts = {
 		transformPageChunk: default_transform,
@@ -236,51 +276,36 @@ export async function respond(request, options, manifest, state) {
 		preload: default_preload
 	};
 
+	/** @type {import('types').TrailingSlash} */
+	let trailing_slash = 'never';
+
 	try {
+		/** @type {PageNodes|undefined} */
+		const page_nodes = route?.page
+			? new PageNodes(await load_page_nodes(route.page, manifest))
+			: undefined;
+
 		// determine whether we need to redirect to add/remove a trailing slash
 		if (route) {
 			// if `paths.base === '/a/b/c`, then the root route is `/a/b/c/`,
 			// regardless of the `trailingSlash` route option
 			if (url.pathname === base || url.pathname === base + '/') {
 				trailing_slash = 'always';
-			} else if (route.page) {
-				const nodes = await load_page_nodes(route.page, manifest);
-
+			} else if (page_nodes) {
 				if (DEV) {
-					const layouts = nodes.slice(0, -1);
-					const page = nodes.at(-1);
-
-					for (const layout of layouts) {
-						if (layout) {
-							validate_layout_server_exports(
-								layout.server,
-								/** @type {string} */ (layout.server_id)
-							);
-							validate_layout_exports(
-								layout.universal,
-								/** @type {string} */ (layout.universal_id)
-							);
-						}
-					}
-
-					if (page) {
-						validate_page_server_exports(page.server, /** @type {string} */ (page.server_id));
-						validate_page_exports(page.universal, /** @type {string} */ (page.universal_id));
-					}
+					page_nodes.validate();
 				}
-
-				trailing_slash = get_option(nodes, 'trailingSlash');
+				trailing_slash = page_nodes.trailing_slash();
 			} else if (route.endpoint) {
 				const node = await route.endpoint();
-				trailing_slash = node.trailingSlash;
-
+				trailing_slash = node.trailingSlash ?? 'never';
 				if (DEV) {
 					validate_server_exports(node, /** @type {string} */ (route.endpoint_id));
 				}
 			}
 
 			if (!is_data_request) {
-				const normalized = normalize_path(url.pathname, trailing_slash ?? 'never');
+				const normalized = normalize_path(url.pathname, trailing_slash);
 
 				if (normalized !== url.pathname && !state.prerendering?.fallback) {
 					return new Response(undefined, {
@@ -306,10 +331,9 @@ export async function respond(request, options, manifest, state) {
 					const node = await route.endpoint();
 					config = node.config ?? config;
 					prerender = node.prerender ?? prerender;
-				} else if (route.page) {
-					const nodes = await load_page_nodes(route.page, manifest);
-					config = get_page_config(nodes) ?? config;
-					prerender = get_option(nodes, 'prerender') ?? false;
+				} else if (page_nodes) {
+					config = page_nodes.get_config() ?? config;
+					prerender = page_nodes.prerender();
 				}
 
 				if (state.before_handle) {
@@ -320,36 +344,16 @@ export async function respond(request, options, manifest, state) {
 					event.platform = await state.emulator.platform({ config, prerender });
 				}
 			}
-		} else if (state.emulator?.platform) {
-			event.platform = await state.emulator.platform({
-				config: {},
-				prerender: !!state.prerendering?.fallback
-			});
 		}
 
-		const { cookies, new_cookies, get_cookie_header, set_internal } = get_cookies(
-			request,
-			url,
-			trailing_slash ?? 'never'
-		);
-
-		cookies_to_add = new_cookies;
-		event.cookies = cookies;
-		event.fetch = create_fetch({
-			event,
-			options,
-			manifest,
-			state,
-			get_cookie_header,
-			set_internal
-		});
+		set_trailing_slash(trailing_slash);
 
 		if (state.prerendering && !state.prerendering.fallback) disable_search(url);
 
 		const response = await options.hooks.handle({
 			event,
 			resolve: (event, opts) =>
-				resolve(event, opts).then((response) => {
+				resolve(event, page_nodes, opts).then((response) => {
 					// add headers/cookies here, rather than inside `resolve`, so that we
 					// can do it once for all responses instead of once per `return`
 					for (const key in headers) {
@@ -357,7 +361,7 @@ export async function respond(request, options, manifest, state) {
 						response.headers.set(key, /** @type {string} */ (value));
 					}
 
-					add_cookies_to_headers(response.headers, Object.values(cookies_to_add));
+					add_cookies_to_headers(response.headers, Object.values(new_cookies));
 
 					if (state.prerendering && event.route.id !== null) {
 						response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
@@ -418,7 +422,7 @@ export async function respond(request, options, manifest, state) {
 				: route?.page && is_action_json_request(event)
 					? action_json_redirect(e)
 					: redirect_response(e.status, e.location);
-			add_cookies_to_headers(response.headers, Object.values(cookies_to_add));
+			add_cookies_to_headers(response.headers, Object.values(new_cookies));
 			return response;
 		}
 		return await handle_fatal_error(event, options, e);
@@ -426,9 +430,10 @@ export async function respond(request, options, manifest, state) {
 
 	/**
 	 * @param {import('@sveltejs/kit').RequestEvent} event
+	 * @param {PageNodes | undefined} page_nodes
 	 * @param {import('@sveltejs/kit').ResolveOptions} [opts]
 	 */
-	async function resolve(event, opts) {
+	async function resolve(event, page_nodes, opts) {
 		try {
 			if (opts) {
 				resolve_opts = {
@@ -467,13 +472,23 @@ export async function respond(request, options, manifest, state) {
 						manifest,
 						state,
 						invalidated_data_nodes,
-						trailing_slash ?? 'never'
+						trailing_slash
 					);
 				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
 					response = await render_endpoint(event, await route.endpoint(), state);
 				} else if (route.page) {
-					if (page_methods.has(method)) {
-						response = await render_page(event, route.page, options, manifest, state, resolve_opts);
+					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,
+							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]();
@@ -499,9 +514,8 @@ export async function respond(request, options, manifest, state) {
 						}
 					}
 				} else {
-					// a route will always have a page or an endpoint, but TypeScript
-					// doesn't know that
-					throw new Error('This should never happen');
+					// 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
@@ -578,3 +592,15 @@ export async function respond(request, options, manifest, state) {
 		}
 	}
 }
+
+/**
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ */
+export function load_page_nodes(page, manifest) {
+	return Promise.all([
+		// we use == here rather than === because [undefined] serializes as "[null]"
+		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
+		manifest._.nodes[page.leaf]()
+	]);
+}

package/src/runtime/server/utils.js

@@ -163,3 +163,15 @@ export function stringify_uses(node) {
 
 	return `"uses":{${uses.join(',')}}`;
 }
+
+/**
+ * Returns `true` if the given path was prerendered
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {string} pathname Should include the base and be decoded
+ */
+export function has_prerendered_path(manifest, pathname) {
+	return (
+		manifest._.prerendered_routes.has(pathname) ||
+		(pathname.at(-1) === '/' && manifest._.prerendered_routes.has(pathname.slice(0, -1)))
+	);
+}

package/src/types/internal.d.ts

@@ -364,8 +364,28 @@ export interface SSRComponent {
 
 export type SSRComponentLoader = () => Promise<SSRComponent>;
 
+export interface UniversalNode {
+	load?: Load;
+	prerender?: PrerenderOption;
+	ssr?: boolean;
+	csr?: boolean;
+	trailingSlash?: TrailingSlash;
+	config?: any;
+	entries?: PrerenderEntryGenerator;
+}
+
+export interface ServerNode {
+	load?: ServerLoad;
+	prerender?: PrerenderOption;
+	ssr?: boolean;
+	csr?: boolean;
+	trailingSlash?: TrailingSlash;
+	actions?: Actions;
+	config?: any;
+	entries?: PrerenderEntryGenerator;
+}
+
 export interface SSRNode {
-	component: SSRComponentLoader;
 	/** index into the `nodes` array in the generated `client/app.js`. */
 	index: number;
 	/** external JS files that are loaded on the client. `imports[0]` is the entry point (e.g. `client/nodes/0.js`) */
@@ -374,32 +394,18 @@ export interface SSRNode {
 	stylesheets: string[];
 	/** external font files that are loaded on the client */
 	fonts: string[];
-	/** inlined styles. */
-	inline_styles?(): MaybePromise<Record<string, string>>;
-
-	universal: {
-		load?: Load;
-		prerender?: PrerenderOption;
-		ssr?: boolean;
-		csr?: boolean;
-		trailingSlash?: TrailingSlash;
-		config?: any;
-		entries?: PrerenderEntryGenerator;
-	};
-
-	server: {
-		load?: ServerLoad;
-		prerender?: PrerenderOption;
-		ssr?: boolean;
-		csr?: boolean;
-		trailingSlash?: TrailingSlash;
-		actions?: Actions;
-		config?: any;
-		entries?: PrerenderEntryGenerator;
-	};
 
 	universal_id?: string;
 	server_id?: string;
+
+	/** inlined styles. */
+	inline_styles?(): MaybePromise<Record<string, string>>;
+	/** Svelte component */
+	component?: SSRComponentLoader;
+	/** +page.js or +layout.js */
+	universal?: UniversalNode;
+	/** +page.server.js, +layout.server.js, or +server.js */
+	server?: ServerNode;
 }
 
 export type SSRNodeLoader = () => Promise<SSRNode>;
@@ -482,6 +488,10 @@ export interface SSRState {
 	 */
 	prerender_default?: PrerenderOption;
 	read?: (file: string) => Buffer;
+	/**
+	 * Used to setup `__SVELTEKIT_TRACK__` which checks if a used feature is supported.
+	 * E.g. if `read` from `$app/server` is used, it checks whether the route's config is compatible.
+	 */
 	before_handle?: (event: RequestEvent, config: any, prerender: PrerenderOption) => void;
 	emulator?: Emulator;
 }

package/src/utils/page_nodes.js

@@ -0,0 +1,95 @@
+import {
+	validate_layout_exports,
+	validate_layout_server_exports,
+	validate_page_exports,
+	validate_page_server_exports
+} from './exports.js';
+
+export class PageNodes {
+	data;
+
+	/**
+	 * @param {Array<import('types').SSRNode | undefined>} nodes
+	 */
+	constructor(nodes) {
+		this.data = nodes;
+	}
+
+	layouts() {
+		return this.data.slice(0, -1);
+	}
+
+	page() {
+		return this.data.at(-1);
+	}
+
+	validate() {
+		for (const layout of this.layouts()) {
+			if (layout) {
+				validate_layout_server_exports(layout.server, /** @type {string} */ (layout.server_id));
+				validate_layout_exports(layout.universal, /** @type {string} */ (layout.universal_id));
+			}
+		}
+
+		const page = this.page();
+		if (page) {
+			validate_page_server_exports(page.server, /** @type {string} */ (page.server_id));
+			validate_page_exports(page.universal, /** @type {string} */ (page.universal_id));
+		}
+	}
+
+	/**
+	 * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash' | 'entries'} Option
+	 * @template {(import('types').UniversalNode | import('types').ServerNode)[Option]} Value
+	 * @param {Option} option
+	 * @returns {Value | undefined}
+	 */
+	#get_option(option) {
+		return this.data.reduce((value, node) => {
+			return /** @type {Value} TypeScript's too dumb to understand this */ (
+				node?.universal?.[option] ?? node?.server?.[option] ?? value
+			);
+		}, /** @type {Value | undefined} */ (undefined));
+	}
+
+	csr() {
+		return this.#get_option('csr') ?? true;
+	}
+
+	ssr() {
+		return this.#get_option('ssr') ?? true;
+	}
+
+	prerender() {
+		return this.#get_option('prerender') ?? false;
+	}
+
+	trailing_slash() {
+		return this.#get_option('trailingSlash') ?? 'never';
+	}
+
+	get_config() {
+		/** @type {any} */
+		let current = {};
+
+		for (const node of this.data) {
+			if (!node?.universal?.config && !node?.server?.config) continue;
+
+			current = {
+				...current,
+				...node?.universal?.config,
+				...node?.server?.config
+			};
+		}
+
+		// TODO 3.0 always return `current`? then we can get rid of `?? {}` in other places
+		return Object.keys(current).length ? current : undefined;
+	}
+
+	should_prerender_data() {
+		return this.data.some(
+			// prerender in case of trailingSlash because the client retrieves that value from the server
+			(node) => node?.server?.load || node?.server?.trailingSlash !== undefined
+		);
+	}
+}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.18.0';
+export const VERSION = '2.19.1';

package/types/index.d.ts

@@ -796,7 +796,7 @@ declare module '@sveltejs/kit' {
 	 * The [`reroute`](https://svelte.dev/docs/kit/hooks#Universal-hooks-reroute) hook allows you to modify the URL before it is used to determine which route to render.
 	 * @since 2.3.0
 	 */
-	export type Reroute = (event: { url: URL }) => MaybePromise<void | string>;
+	export type Reroute = (event: { url: URL; fetch: typeof fetch }) => MaybePromise<void | string>;
 
 	/**
 	 * The [`transport`](https://svelte.dev/docs/kit/hooks#Universal-hooks-transport) hook allows you to transport custom types across the server/client boundary.
@@ -1842,8 +1842,28 @@ declare module '@sveltejs/kit' {
 
 	type SSRComponentLoader = () => Promise<SSRComponent>;
 
+	interface UniversalNode {
+		load?: Load;
+		prerender?: PrerenderOption;
+		ssr?: boolean;
+		csr?: boolean;
+		trailingSlash?: TrailingSlash;
+		config?: any;
+		entries?: PrerenderEntryGenerator;
+	}
+
+	interface ServerNode {
+		load?: ServerLoad;
+		prerender?: PrerenderOption;
+		ssr?: boolean;
+		csr?: boolean;
+		trailingSlash?: TrailingSlash;
+		actions?: Actions;
+		config?: any;
+		entries?: PrerenderEntryGenerator;
+	}
+
 	interface SSRNode {
-		component: SSRComponentLoader;
 		/** index into the `nodes` array in the generated `client/app.js`. */
 		index: number;
 		/** external JS files that are loaded on the client. `imports[0]` is the entry point (e.g. `client/nodes/0.js`) */
@@ -1852,32 +1872,18 @@ declare module '@sveltejs/kit' {
 		stylesheets: string[];
 		/** external font files that are loaded on the client */
 		fonts: string[];
-		/** inlined styles. */
-		inline_styles?(): MaybePromise<Record<string, string>>;
-
-		universal: {
-			load?: Load;
-			prerender?: PrerenderOption;
-			ssr?: boolean;
-			csr?: boolean;
-			trailingSlash?: TrailingSlash;
-			config?: any;
-			entries?: PrerenderEntryGenerator;
-		};
-
-		server: {
-			load?: ServerLoad;
-			prerender?: PrerenderOption;
-			ssr?: boolean;
-			csr?: boolean;
-			trailingSlash?: TrailingSlash;
-			actions?: Actions;
-			config?: any;
-			entries?: PrerenderEntryGenerator;
-		};
 
 		universal_id?: string;
 		server_id?: string;
+
+		/** inlined styles. */
+		inline_styles?(): MaybePromise<Record<string, string>>;
+		/** Svelte component */
+		component?: SSRComponentLoader;
+		/** +page.js or +layout.js */
+		universal?: UniversalNode;
+		/** +page.server.js, +layout.server.js, or +server.js */
+		server?: ServerNode;
 	}
 
 	type SSRNodeLoader = () => Promise<SSRNode>;
@@ -2016,7 +2022,8 @@ declare module '@sveltejs/kit' {
 	 * console.log(url.pathname); // /blog/post
 	 * console.log(denormalize('/blog/post/a')); // /blog/post/a/__data.json
 	 * ```
-	 * */
+	 * @since 2.18.0
+	 */
 	export function normalizeUrl(url: URL | string): {
 		url: URL;
 		wasNormalized: boolean;

package/types/index.d.ts.map

@@ -73,6 +73,8 @@
 		"RouteData",
 		"SSRComponent",
 		"SSRComponentLoader",
+		"UniversalNode",
+		"ServerNode",
 		"SSRNode",
 		"SSRNodeLoader",
 		"PageNodeIndexes",
@@ -161,6 +163,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }

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

@@ -1,11 +0,0 @@
-/**
- * @param {import('types').PageNodeIndexes} page
- * @param {import('@sveltejs/kit').SSRManifest} manifest
- */
-export function load_page_nodes(page, manifest) {
-	return Promise.all([
-		// we use == here rather than === because [undefined] serializes as "[null]"
-		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-		manifest._.nodes[page.leaf]()
-	]);
-}

package/src/utils/options.js

@@ -1,16 +0,0 @@
-/**
- * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash' | 'entries'} Option
- * @template {(import('types').SSRNode['universal'] | import('types').SSRNode['server'])[Option]} Value
- *
- * @param {Array<import('types').SSRNode | undefined>} nodes
- * @param {Option} option
- *
- * @returns {Value | undefined}
- */
-export function get_option(nodes, option) {
-	return nodes.reduce((value, node) => {
-		return /** @type {Value} TypeScript's too dumb to understand this */ (
-			node?.universal?.[option] ?? node?.server?.[option] ?? value
-		);
-	}, /** @type {Value | undefined} */ (undefined));
-}

package/src/utils/route_config.js

@@ -1,21 +0,0 @@
-/**
- * Do a shallow merge (first level) of the config object
- * @param {Array<import('types').SSRNode | undefined>} nodes
- */
-export function get_page_config(nodes) {
-	/** @type {any} */
-	let current = {};
-
-	for (const node of nodes) {
-		if (!node?.universal?.config && !node?.server?.config) continue;
-
-		current = {
-			...current,
-			...node?.universal?.config,
-			...node?.server?.config
-		};
-	}
-
-	// TODO 3.0 always return `current`? then we can get rid of `?? {}` in other places
-	return Object.keys(current).length ? current : undefined;
-}