@sveltejs/kit 2.16.0 → 2.17.0

package/src/runtime/client/client.js

@@ -1,7 +1,6 @@
 import { BROWSER, DEV } from 'esm-env';
 import { onMount, tick } from 'svelte';
 import {
-	add_data_suffix,
 	decode_params,
 	decode_pathname,
 	strip_hash,
@@ -9,7 +8,7 @@ import {
 	normalize_path
 } from '../../utils/url.js';
 import { dev_fetch, initial_fetch, lock_fetch, subsequent_fetch, unlock_fetch } from './fetcher.js';
-import { parse } from './parse.js';
+import { parse, parse_server_route } from './parse.js';
 import * as storage from './session-storage.js';
 import {
 	find_anchor,
@@ -40,6 +39,7 @@ import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM, validate_depends } from '../sh
 import { get_message, get_status } from '../../utils/error.js';
 import { writable } from 'svelte/store';
 import { page, update, navigating } from './state.svelte.js';
+import { add_data_suffix, add_resolution_prefix } from '../pathname.js';
 
 const ICON_REL_ATTRIBUTES = new Set(['icon', 'shortcut icon', 'apple-touch-icon']);
 
@@ -158,7 +158,7 @@ async function update_service_worker() {
 
 function noop() {}
 
-/** @type {import('types').CSRRoute[]} */
+/** @type {import('types').CSRRoute[]} All routes of the app. Only available when kit.router.resolution=client */
 let routes;
 /** @type {import('types').CSRPageNodeLoader} */
 let default_layout_loader;
@@ -265,7 +265,7 @@ export async function start(_app, _target, hydrate) {
 
 	await _app.hooks.init?.();
 
-	routes = parse(_app);
+	routes = __SVELTEKIT_CLIENT_ROUTING__ ? parse(_app) : [];
 	container = __SVELTEKIT_EMBEDDED__ ? _target : document.documentElement;
 	target = _target;
 
@@ -322,7 +322,8 @@ async function _invalidate() {
 	if (!pending_invalidate) return;
 	pending_invalidate = null;
 
-	const intent = get_navigation_intent(current.url, true);
+	const nav_token = (token = {});
+	const intent = await get_navigation_intent(current.url, true);
 
 	// Clear preload, it might be affected by the invalidation.
 	// Also solves an edge case where a preload is triggered, the navigation for it
@@ -330,7 +331,6 @@ async function _invalidate() {
 	// at which point the invalidation should take over and "win".
 	load_cache = null;
 
-	const nav_token = (token = {});
 	const navigation_result = intent && (await load_route(intent));
 	if (!navigation_result || nav_token !== token) return;
 
@@ -433,10 +433,7 @@ async function _preload_data(intent) {
  * @returns {Promise<void>}
  */
 async function _preload_code(url) {
-	const rerouted = get_rerouted_url(url);
-	if (!rerouted) return;
-
-	const route = routes.find((route) => route.exec(get_url_path(rerouted)));
+	const route = (await get_navigation_intent(url, false))?.route;
 
 	if (route) {
 		await Promise.all([...route.layouts, route.leaf].map((load) => load?.[1]()));
@@ -587,8 +584,7 @@ function get_navigation_result_from_branch({ url, params, branch, status, error,
 }
 
 /**
- * Call the load function of the given node, if it exists.
- * If `server_data` is passed, this is treated as the initial run and the page endpoint is not requested.
+ * Call the universal load function of the given node, if it exists.
  *
  * @param {{
  *   loader: import('types').CSRPageNodeLoader;
@@ -1240,31 +1236,47 @@ function get_rerouted_url(url) {
  * returns undefined.
  * @param {URL | undefined} url
  * @param {boolean} invalidating
+ * @returns {Promise<import('./types.js').NavigationIntent | undefined>}
  */
-function get_navigation_intent(url, invalidating) {
+async function get_navigation_intent(url, invalidating) {
 	if (!url) return;
 	if (is_external_url(url, base, app.hash)) return;
 
-	const rerouted = get_rerouted_url(url);
-	if (!rerouted) return;
+	if (__SVELTEKIT_CLIENT_ROUTING__) {
+		const rerouted = get_rerouted_url(url);
+		if (!rerouted) return;
 
-	const path = get_url_path(rerouted);
+		const path = get_url_path(rerouted);
 
-	for (const route of routes) {
-		const params = route.exec(path);
+		for (const route of routes) {
+			const params = route.exec(path);
 
-		if (params) {
-			const id = get_page_key(url);
-			/** @type {import('./types.js').NavigationIntent} */
-			const intent = {
-				id,
-				invalidating,
-				route,
-				params: decode_params(params),
-				url
-			};
-			return intent;
+			if (params) {
+				return {
+					id: get_page_key(url),
+					invalidating,
+					route,
+					params: decode_params(params),
+					url
+				};
+			}
 		}
+	} else {
+		/** @type {{ route?: import('types').CSRRouteServer, params: Record<string, string>}} */
+		const { route, params } = await import(
+			/* @vite-ignore */
+			add_resolution_prefix(url.pathname)
+		);
+
+		if (!route) return;
+
+		return {
+			id: get_page_key(url),
+			invalidating,
+			route: parse_server_route(route, app.nodes),
+			params,
+			url
+		};
 	}
 }
 
@@ -1347,11 +1359,15 @@ async function navigate({
 	accept = noop,
 	block = noop
 }) {
-	const intent = get_navigation_intent(url, false);
+	const prev_token = token;
+	token = nav_token;
+
+	const intent = await get_navigation_intent(url, false);
 	const nav = _before_navigate({ url, type, delta: popped?.delta, intent });
 
 	if (!nav) {
 		block();
+		if (token === nav_token) token = prev_token;
 		return;
 	}
 
@@ -1367,7 +1383,6 @@ async function navigate({
 		stores.navigating.set((navigating.current = nav.navigation));
 	}
 
-	token = nav_token;
 	let navigation_result = intent && (await load_route(intent));
 
 	if (!navigation_result) {
@@ -1621,6 +1636,8 @@ if (import.meta.hot) {
 function setup_preload() {
 	/** @type {NodeJS.Timeout} */
 	let mousemove_timeout;
+	/** @type {Element} */
+	let current_a;
 
 	container.addEventListener('mousemove', (event) => {
 		const target = /** @type {Element} */ (event.target);
@@ -1656,9 +1673,11 @@ function setup_preload() {
 	 * @param {Element} element
 	 * @param {number} priority
 	 */
-	function preload(element, priority) {
+	async function preload(element, priority) {
 		const a = find_anchor(element, container);
-		if (!a) return;
+		if (!a || a === current_a) return;
+
+		current_a = a;
 
 		const { url, external, download } = get_link_info(a, base, app.hash);
 		if (external || download) return;
@@ -1670,7 +1689,7 @@ function setup_preload() {
 
 		if (!options.reload && !same_url) {
 			if (priority <= options.preload_data) {
-				const intent = get_navigation_intent(url, false);
+				const intent = await get_navigation_intent(url, false);
 				if (intent) {
 					if (DEV) {
 						_preload_data(intent).then((result) => {
@@ -1924,7 +1943,7 @@ export async function preloadData(href) {
 	}
 
 	const url = resolve_url(href);
-	const intent = get_navigation_intent(url, false);
+	const intent = await get_navigation_intent(url, false);
 
 	if (!intent) {
 		throw new Error(`Attempted to preload a URL that does not belong to this app: ${url}`);
@@ -1954,7 +1973,7 @@ export async function preloadData(href) {
  * @param {string} pathname
  * @returns {Promise<void>}
  */
-export function preloadCode(pathname) {
+export async function preloadCode(pathname) {
 	if (!BROWSER) {
 		throw new Error('Cannot call preloadCode(...) on the server');
 	}
@@ -1974,9 +1993,11 @@ export function preloadCode(pathname) {
 			);
 		}
 
-		const rerouted = get_rerouted_url(url);
-		if (!rerouted || !routes.find((route) => route.exec(get_url_path(rerouted)))) {
-			throw new Error(`'${pathname}' did not match any routes`);
+		if (__SVELTEKIT_CLIENT_ROUTING__) {
+			const rerouted = get_rerouted_url(url);
+			if (!rerouted || !routes.find((route) => route.exec(get_url_path(rerouted)))) {
+				throw new Error(`'${pathname}' did not match any routes`);
+			}
 		}
 	}
 
@@ -2474,16 +2495,31 @@ function _start_router() {
  */
 async function _hydrate(
 	target,
-	{ status = 200, error, node_ids, params, route, data: server_data_nodes, form }
+	{ status = 200, error, node_ids, params, route, server_route, data: server_data_nodes, form }
 ) {
 	hydrated = true;
 
 	const url = new URL(location.href);
 
-	if (!__SVELTEKIT_EMBEDDED__) {
-		// See https://github.com/sveltejs/kit/pull/4935#issuecomment-1328093358 for one motivation
-		// of determining the params on the client side.
-		({ params = {}, route = { id: null } } = get_navigation_intent(url, false) || {});
+	/** @type {import('types').CSRRoute | undefined} */
+	let parsed_route;
+
+	if (__SVELTEKIT_CLIENT_ROUTING__) {
+		if (!__SVELTEKIT_EMBEDDED__) {
+			// See https://github.com/sveltejs/kit/pull/4935#issuecomment-1328093358 for one motivation
+			// of determining the params on the client side.
+			({ params = {}, route = { id: null } } = (await get_navigation_intent(url, false)) || {});
+		}
+
+		parsed_route = routes.find(({ id }) => id === route.id);
+	} else {
+		// undefined in case of 404
+		if (server_route) {
+			parsed_route = route = parse_server_route(server_route, app.nodes);
+		} else {
+			route = { id: null };
+			params = {};
+		}
 	}
 
 	/** @type {import('./types.js').NavigationFinished | undefined} */
@@ -2517,8 +2553,6 @@ async function _hydrate(
 		/** @type {Array<import('./types.js').BranchNode | undefined>} */
 		const branch = await Promise.all(branch_promises);
 
-		const parsed_route = routes.find(({ id }) => id === route.id);
-
 		// server-side will have compacted the branch, reinstate empty slots
 		// so that error boundaries can be lined up correctly
 		if (parsed_route) {

package/src/runtime/client/parse.js

@@ -10,6 +10,7 @@ export function parse({ nodes, server_loads, dictionary, matchers }) {
 	return Object.entries(dictionary).map(([id, [leaf, layouts, errors]]) => {
 		const { pattern, params } = parse_route_id(id);
 
+		/** @type {import('types').CSRRoute} */
 		const route = {
 			id,
 			/** @param {string} path */
@@ -55,3 +56,22 @@ export function parse({ nodes, server_loads, dictionary, matchers }) {
 		return id === undefined ? id : [layouts_with_server_load.has(id), nodes[id]];
 	}
 }
+
+/**
+ * @param {import('types').CSRRouteServer} input
+ * @param {import('types').CSRPageNodeLoader[]} app_nodes Will be modified if a new node is loaded that's not already in the array
+ * @returns {import('types').CSRRoute}
+ */
+export function parse_server_route({ nodes, id, leaf, layouts, errors }, app_nodes) {
+	return {
+		id,
+		exec: () => ({}), // dummy function; exec already happened on the server
+		// By writing to app_nodes only when a loader at that index is not already defined,
+		// we ensure that loaders have referential equality when they load the same node.
+		// Code elsewhere in client.js relies on this referential equality to determine
+		// if a loader is different and should therefore (re-)run.
+		errors: errors.map((n) => (n ? (app_nodes[n] ||= nodes[n]) : undefined)),
+		layouts: layouts.map((n) => (n ? [n[0], (app_nodes[n[1]] ||= nodes[n[1]])] : undefined)),
+		leaf: [leaf[0], (app_nodes[leaf[1]] ||= nodes[leaf[1]])]
+	};
+}

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

@@ -4,6 +4,7 @@ import {
 	CSRPageNode,
 	CSRPageNodeLoader,
 	CSRRoute,
+	CSRRouteServer,
 	ServerDataNode,
 	TrailingSlash,
 	Uses
@@ -12,13 +13,18 @@ import { Page, ParamMatcher } from '@sveltejs/kit';
 
 export interface SvelteKitApp {
 	/**
-	 * A list of all the error/layout/page nodes used in the app
+	 * A list of all the error/layout/page nodes used in the app.
+	 * - In case of router.resolution=client, this is filled completely upfront.
+	 * - In case of router.resolution=server, this is filled with the root layout and root error page
+	 *   at the beginning and then filled up as the user navigates around the app, loading new nodes
 	 */
 	nodes: CSRPageNodeLoader[];
 
 	/**
 	 * A list of all layout node ids that have a server load function.
 	 * Pages are not present because it's shorter to encode it on the leaf itself.
+	 *
+	 * In case of router.resolution=server, this only contains one entry for the root layout.
 	 */
 	server_loads: number[];
 
@@ -27,9 +33,16 @@ export interface SvelteKitApp {
 	 * is parsed into an array of routes on startup. The numbers refer to the indices in `nodes`.
 	 * If the leaf number is negative, it means it does use a server load function and the complement is the node index.
 	 * The route layout and error nodes are not referenced, they are always number 0 and 1 and always apply.
+	 *
+	 * In case of router.resolution=server, this object is empty, as resolution happens on the server.
 	 */
 	dictionary: Record<string, [leaf: number, layouts: number[], errors?: number[]]>;
 
+	/**
+	 * A map of `[matcherName: string]: (..) => boolean`, which is used to match route parameters.
+	 *
+	 * In case of router.resolution=server, this object is empty, as resolution happens on the server.
+	 */
 	matchers: Record<string, ParamMatcher>;
 
 	hooks: ClientHooks;
@@ -108,6 +121,8 @@ export interface HydrateOptions {
 	node_ids: number[];
 	params: Record<string, string>;
 	route: { id: string | null };
+	/** Only used when `router.resolution=server`; can then still be undefined in case of 404 */
+	server_route?: CSRRouteServer;
 	data: Array<ServerDataNode | null>;
 	form: Record<string, any> | null;
 }

package/src/runtime/client/utils.js

@@ -130,6 +130,12 @@ export function get_link_info(a, base, uses_hash_router) {
 
 	try {
 		url = new URL(a instanceof SVGAElement ? a.href.baseVal : a.href, document.baseURI);
+
+		// if the hash doesn't start with `#/` then it's probably linking to an id on the current page
+		if (uses_hash_router && url.hash.match(/^#[^/]/)) {
+			const route = location.hash.split('#')[1] || '/';
+			url.hash = `#${route}${url.hash}`;
+		}
 	} catch {}
 
 	const target = a instanceof SVGAElement ? a.target.baseVal : a.target;

package/src/runtime/pathname.js

@@ -0,0 +1,54 @@
+import { base, app_dir } from '__sveltekit/paths';
+
+const DATA_SUFFIX = '/__data.json';
+const HTML_DATA_SUFFIX = '.html__data.json';
+
+/** @param {string} pathname */
+export function has_data_suffix(pathname) {
+	return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+
+/** @param {string} pathname */
+export function add_data_suffix(pathname) {
+	if (pathname.endsWith('.html')) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+	return pathname.replace(/\/$/, '') + DATA_SUFFIX;
+}
+
+/** @param {string} pathname */
+export function strip_data_suffix(pathname) {
+	if (pathname.endsWith(HTML_DATA_SUFFIX)) {
+		return pathname.slice(0, -HTML_DATA_SUFFIX.length) + '.html';
+	}
+
+	return pathname.slice(0, -DATA_SUFFIX.length);
+}
+
+const ROUTE_PREFIX = `${base}/${app_dir}/route`;
+
+/**
+ * @param {string} pathname
+ * @returns {boolean}
+ */
+export function has_resolution_prefix(pathname) {
+	return pathname === `${ROUTE_PREFIX}.js` || pathname.startsWith(`${ROUTE_PREFIX}/`);
+}
+
+/**
+ * Convert a regular URL to a route to send to SvelteKit's server-side route resolution endpoint
+ * @param {string} pathname
+ * @returns {string}
+ */
+export function add_resolution_prefix(pathname) {
+	let normalized = pathname.slice(base.length);
+	if (normalized.endsWith('/')) normalized = normalized.slice(0, -1);
+
+	return `${ROUTE_PREFIX}${normalized}.js`;
+}
+
+/**
+ * @param {string} pathname
+ * @returns {string}
+ */
+export function strip_resolution_prefix(pathname) {
+	return base + (pathname.slice(ROUTE_PREFIX.length, -3) || '/');
+}

package/src/runtime/server/cookie.js

@@ -1,5 +1,6 @@
 import { parse, serialize } from 'cookie';
-import { add_data_suffix, normalize_path, resolve } from '../../utils/url.js';
+import { normalize_path, resolve } from '../../utils/url.js';
+import { add_data_suffix } from '../pathname.js';
 
 // eslint-disable-next-line no-control-regex -- control characters are invalid in cookie names
 const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;

package/src/runtime/server/endpoint.js

@@ -1,4 +1,3 @@
-import { DEV } from 'esm-env';
 import { ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
 import { negotiate } from '../../utils/http.js';
 import { Redirect } from '../control.js';
@@ -11,10 +10,6 @@ import { method_not_allowed } from './utils.js';
  * @returns {Promise<Response>}
  */
 export async function render_endpoint(event, mod, state) {
-	if (DEV && event.request.headers.get('x-sveltekit-action') === 'true') {
-		throw new Error('use:enhance should only be used with SvelteKit form actions');
-	}
-
 	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
 
 	let handler = mod[method] || mod.fallback;

package/src/runtime/server/fetch.js

@@ -112,6 +112,18 @@ 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)))
+				) {
+					// 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
+					// each adapter, (except maybe for prerendered redirects)
+					// so we need to make an actual HTTP request.
+					return await fetch(request);
+				}
+
 				if (credentials !== 'omit') {
 					const cookie = get_cookie_header(url, request.headers.get('cookie'));
 					if (cookie) {

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

@@ -1,7 +1,7 @@
 import { text } from '../../../exports/index.js';
 import { compact } from '../../../utils/array.js';
 import { get_status, normalize_error } from '../../../utils/error.js';
-import { add_data_suffix } from '../../../utils/url.js';
+import { add_data_suffix } from '../../pathname.js';
 import { Redirect } from '../../control.js';
 import { redirect_response, static_error_page, handle_error_and_jsonify } from '../utils.js';
 import {

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

@@ -13,6 +13,8 @@ import { text } from '../../../exports/index.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { SCHEME } from '../../../utils/url.js';
+import { create_server_routing_response, generate_route_object } from './server_routing.js';
+import { add_resolution_prefix } from '../../pathname.js';
 
 // TODO rename this function/module
 
@@ -297,8 +299,10 @@ export async function render_response({
 	}
 
 	if (page_config.csr) {
+		const route = manifest._.client.routes?.find((r) => r.id === event.route.id) ?? null;
+
 		if (client.uses_env_dynamic_public && state.prerendering) {
-			modulepreloads.add(`${options.app_dir}/env.js`);
+			modulepreloads.add(`${paths.app_dir}/env.js`);
 		}
 
 		if (!client.inline) {
@@ -317,6 +321,16 @@ export async function render_response({
 			}
 		}
 
+		// prerender a `/_app/route/path/to/page.js` module
+		if (manifest._.client.routes && state.prerendering && !state.prerendering.fallback) {
+			const pathname = add_resolution_prefix(event.url.pathname);
+
+			state.prerendering.dependencies.set(
+				pathname,
+				create_server_routing_response(route, event.params, new URL(pathname, event.url), manifest)
+			);
+		}
+
 		const blocks = [];
 
 		// when serving a prerendered page in an app that uses $env/dynamic/public, we must
@@ -394,7 +408,15 @@ export async function render_response({
 				hydrate.push(`status: ${status}`);
 			}
 
-			if (options.embedded) {
+			if (manifest._.client.routes) {
+				if (route) {
+					const stringified = generate_route_object(route, event.url, manifest).replaceAll(
+						'\n',
+						'\n\t\t\t\t\t\t\t'
+					); // make output after it's put together with the rest more readable
+					hydrate.push(`params: ${devalue.uneval(event.params)}`, `server_route: ${stringified}`);
+				}
+			} else if (options.embedded) {
 				hydrate.push(`params: ${devalue.uneval(event.params)}`, `route: ${s(event.route)}`);
 			}
 
@@ -419,7 +441,7 @@ export async function render_response({
 					});`;
 
 		if (load_env_eagerly) {
-			blocks.push(`import(${s(`${base}/${options.app_dir}/env.js`)}).then(({ env }) => {
+			blocks.push(`import(${s(`${base}/${paths.app_dir}/env.js`)}).then(({ env }) => {
 						${global}.env = env;
 
 						${boot.replace(/\n/g, '\n\t')}

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

@@ -0,0 +1,110 @@
+import { base, assets } from '__sveltekit/paths';
+import { text } from '../../../exports/index.js';
+import { s } from '../../../utils/misc.js';
+import { exec } from '../../../utils/routing.js';
+import { decode_params } from '../../../utils/url.js';
+import { get_relative_path } from '../../utils.js';
+
+/**
+ * @param {import('types').SSRClientRoute} route
+ * @param {URL} url
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @returns {string}
+ */
+export function generate_route_object(route, url, manifest) {
+	const { errors, layouts, leaf } = route;
+
+	const nodes = [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]
+		.filter((n) => typeof n === 'number')
+		.map((n) => `'${n}': () => ${create_client_import(manifest._.client.nodes?.[n], url)}`)
+		.join(',\n\t\t');
+
+	// stringified version of
+	/** @type {import('types').CSRRouteServer} */
+	return [
+		`{\n\tid: ${s(route.id)}`,
+		`errors: ${s(route.errors)}`,
+		`layouts: ${s(route.layouts)}`,
+		`leaf: ${s(route.leaf)}`,
+		`nodes: {\n\t\t${nodes}\n\t}\n}`
+	].join(',\n\t');
+}
+
+/**
+ * @param {string | undefined} import_path
+ * @param {URL} url
+ */
+function create_client_import(import_path, url) {
+	if (!import_path) return 'Promise.resolve({})';
+
+	// During DEV, Vite will make the paths absolute (e.g. /@fs/...)
+	if (import_path[0] === '/') {
+		return `import('${import_path}')`;
+	}
+
+	// During PROD, they're root-relative
+	if (assets !== '') {
+		return `import('${assets}/${import_path}')`;
+	}
+
+	// Else we make them relative to the server-side route resolution request
+	// to support IPFS, the internet archive, etc.
+	let path = get_relative_path(url.pathname, `${base}/${import_path}`);
+	if (path[0] !== '.') path = `./${path}`;
+	return `import('${path}')`;
+}
+
+/**
+ * @param {string} resolved_path
+ * @param {URL} url
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @returns {Promise<Response>}
+ */
+export async function resolve_route(resolved_path, url, manifest) {
+	if (!manifest._.client.routes) {
+		return text('Server-side route resolution disabled', { status: 400 });
+	}
+
+	/** @type {import('types').SSRClientRoute | null} */
+	let route = null;
+	/** @type {Record<string, string>} */
+	let params = {};
+
+	const matchers = await manifest._.matchers();
+
+	for (const candidate of manifest._.client.routes) {
+		const match = candidate.pattern.exec(resolved_path);
+		if (!match) continue;
+
+		const matched = exec(match, candidate.params, matchers);
+		if (matched) {
+			route = candidate;
+			params = decode_params(matched);
+			break;
+		}
+	}
+
+	return create_server_routing_response(route, params, url, manifest).response;
+}
+
+/**
+ * @param {import('types').SSRClientRoute | null} route
+ * @param {Partial<Record<string, string>>} params
+ * @param {URL} url
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @returns {{response: Response, body: string}}
+ */
+export function create_server_routing_response(route, params, url, manifest) {
+	const headers = new Headers({
+		'content-type': 'application/javascript; charset=utf-8'
+	});
+
+	if (route) {
+		const csr_route = generate_route_object(route, url, manifest);
+		const body = `export const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
+
+		return { response: text(body, { headers }), body };
+	} else {
+		return { response: text('', { headers }), body: '' };
+	}
+}