@sveltejs/kit 3.0.0-next.13 → 3.0.0-next.14

package/src/runtime/client/client.js

@@ -21,7 +21,7 @@ import {
 	scroll_state,
 	load_css
 } from './utils.js';
-import { base, set_match_implementation } from '$app/paths/internal/client';
+import { base, app_dir, set_match_implementation } from '$app/paths/internal/client';
 import * as devalue from 'devalue';
 import {
 	HISTORY_INFO_KEY,
@@ -41,7 +41,11 @@ import {
 import { get_message, get_status } from '../../utils/error.js';
 import { page, navigating, updated, notify_version } from './state.svelte.js';
 import { payload } from './payload.js';
-import { add_data_suffix, add_resolution_suffix } from '../pathname.js';
+import {
+	add_data_suffix,
+	add_resolution_suffix,
+	route_id_resolution_pathname
+} from '../pathname.js';
 import { noop_span } from '../telemetry/noop.js';
 import { read_ndjson } from './ndjson.js';
 import Root from '../components/root.svelte';
@@ -294,6 +298,35 @@ function discard_load_cache() {
  */
 const reroute_cache = new Map();
 
+/**
+ * Sentinel for a route that exists but has no code to preload, i.e. a `+server.js` with no
+ * `+page`. Cached like a parsed route so that repeated `preloadCode(id)` calls for the same
+ * id don't re-request it.
+ */
+const ENDPOINT_ONLY = Symbol('endpoint only');
+
+/**
+ * Cache of route ID -> parsed route for server-side route resolution.
+ * Populated whenever a server route resolution occurs (`match`, link preloading,
+ * hydration), so that `preloadCode(id)` doesn't need an extra server round trip.
+ * Lives until full page reload.
+ * @type {Map<string, import('types').CSRRoute | typeof ENDPOINT_ONLY>}
+ */
+const route_id_cache = new Map();
+
+/**
+ * Parse a server-provided route and record it in `route_id_cache`, so that a subsequent
+ * `preloadCode(id)` for the same route doesn't need another server round trip. Always use
+ * this rather than calling `parse_server_route` directly.
+ * @param {import('types').CSRRouteServer} server_route
+ * @returns {import('types').CSRRoute}
+ */
+function parse_and_cache_server_route(server_route) {
+	const route = parse_server_route(server_route, app.nodes);
+	route_id_cache.set(route.id, route);
+	return route;
+}
+
 /**
  * Note on before_navigate_callbacks, on_navigate_callbacks and after_navigate_callbacks:
  * do not re-assign as some closures keep references to these Sets
@@ -661,13 +694,13 @@ function persist_state() {
 
 /**
  * @param {string | URL} url
- * @param {{ replace?: boolean; reset?: boolean; refreshAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any>; persistState?: boolean }} options
- * @param {number} redirect_count
+ * @param {{ type?: import('@sveltejs/kit').NavigationType; replace?: boolean; reset?: boolean; refreshAll?: boolean; invalidate?: Array<string | URL | ((url: URL) => boolean)>; state?: Record<string, any>; persistState?: boolean; event?: Event }} [options]
+ * @param {number} [redirect_count]
  * @param {{}} [nav_token]
  * @param {NavigationIntent | undefined} [intent] navigation intent, when already known by the caller (avoids recomputing it)
  * @returns {Promise<void>}
  */
-export async function _goto(url, options, redirect_count, nav_token, intent) {
+export async function _goto(url, options = {}, redirect_count = 0, nav_token = {}, intent) {
 	/** @type {Set<string>} */
 	let query_keys;
 	/** @type {Set<string>} */
@@ -680,12 +713,13 @@ export async function _goto(url, options, redirect_count, nav_token, intent) {
 	}
 
 	await navigate({
-		type: 'goto',
+		type: options.type ?? 'goto',
 		url: resolve_url(url),
 		reset: options.reset,
 		replace_state: options.replace,
 		state: options.state,
 		persist_state: options.persistState,
+		event: options.event,
 		redirect_count,
 		nav_token,
 		intent,
@@ -786,6 +820,53 @@ async function _preload_data(intent) {
 	return load_cache.promise;
 }
 
+/**
+ * Fetch and parse the route with the given ID from the server-side route resolution endpoint.
+ * Returns `ENDPOINT_ONLY` if the route exists but has no code to preload, or `undefined` if
+ * there is no such route. Only used when `router.resolution === 'server'`.
+ * @param {string} id
+ * @returns {Promise<import('types').CSRRoute | typeof ENDPOINT_ONLY | undefined>}
+ */
+async function load_route_by_id(id) {
+	/** @type {{ route?: import('types').CSRRouteServer, endpoint_only?: boolean }} */
+	let module;
+
+	try {
+		module = await import(
+			/* @vite-ignore */
+			base + route_id_resolution_pathname(app_dir, id)
+		);
+	} catch {
+		// if there's no module at that path the response is a 404 (or, on a static
+		// host, fallback HTML with the wrong MIME type) and the import rejects —
+		// treat it the same as an unknown route rather than surfacing a cryptic error
+		return;
+	}
+
+	if (module.endpoint_only) {
+		// The route exists, it just has no code to preload.
+		route_id_cache.set(id, ENDPOINT_ONLY);
+		return ENDPOINT_ONLY;
+	}
+
+	if (!module.route) return;
+
+	return parse_and_cache_server_route(module.route);
+}
+
+/**
+ * Import the modules for a route's layout and leaf nodes, without running `load` functions.
+ * @param {import('types').CSRRoute} route
+ * @returns {Promise<void>}
+ */
+async function load_route_nodes(route) {
+	await Promise.all(
+		/** @type {[has_server_load: boolean, node_loader: import('types').CSRPageNodeLoader][]} */ (
+			[...route.layouts, route.leaf].filter(Boolean)
+		).map(([, node_loader]) => node_loader())
+	);
+}
+
 /**
  * @param {URL} url
  * @returns {Promise<void>}
@@ -794,11 +875,7 @@ async function _preload_code(url) {
 	const route = (await get_navigation_intent(url, false))?.route;
 
 	if (route) {
-		await Promise.all(
-			/** @type {[has_server_load: boolean, node_loader: import('types').CSRPageNodeLoader][]} */ (
-				[...route.layouts, route.leaf].filter(Boolean)
-			).map((load) => load[1]())
-		);
+		await load_route_nodes(route);
 	}
 }
 
@@ -1607,7 +1684,7 @@ async function load_root_error_page({ error, url, route }) {
 		// client-side navigation if the root layout loader throws a redirect while
 		// rendering the default error page
 		if (error instanceof Redirect) {
-			await _goto(new URL(error.location, location.href), {}, 0);
+			await _goto(new URL(error.location, location.href));
 			return;
 		}
 
@@ -1729,7 +1806,7 @@ export async function get_navigation_intent(url, invalidating) {
 		return {
 			id: get_page_key(url),
 			invalidating,
-			route: parse_server_route(route, app.nodes),
+			route: parse_and_cache_server_route(route),
 			params,
 			url
 		};
@@ -2656,45 +2733,76 @@ export async function preloadData(href) {
  * Programmatically imports the code for routes that haven't yet been fetched.
  * Typically, you might call this to speed up subsequent navigation.
  *
- * You can specify routes by any matching pathname such as `/about` (to match `src/routes/about/+page.svelte`) or `/blog/*` (to match `src/routes/blog/[slug]/+page.svelte`).
+ * Takes a route ID such as `/about` or `/blog/[slug]`. Unlike pathnames, route IDs
+ * are never prefixed with the app's [base path](https://svelte.dev/docs/kit/configuration#paths).
+ * If you have a pathname rather than a route ID, you can convert it with
+ * [`match`](https://svelte.dev/docs/kit/$app-paths#match) from `$app/paths`:
+ *
+ * ```js
+ * import { match } from '$app/paths';
+ * import { preloadCode } from '$app/navigation';
+ *
+ * const matched = await match('/blog/hello-world');
+ * if (matched) await preloadCode(matched.id);
+ * ```
  *
  * Unlike `preloadData`, this won't call `load` functions.
  * Returns a Promise that resolves when the modules have been imported.
  *
- * @param {string} pathname
+ * @param {RouteId} id
  * @returns {Promise<void>}
  */
-export async function preloadCode(pathname) {
+export async function preloadCode(id) {
 	if (!BROWSER) {
 		throw new Error('Cannot call preloadCode(...) on the server');
 	}
 
-	// `current.url` is null until the first navigation/hydration completes, so fall back
-	// to `location` to support calling `preloadCode` during initial page load (#13297)
-	const url = new URL(pathname, current.url ?? location.href);
+	if (DEV && id[0] !== '/') {
+		throw new Error(
+			`argument passed to preloadCode must be a route ID (i.e. "/blog/[slug]" rather than "blog/[slug]")`
+		);
+	}
 
-	if (DEV) {
-		if (!pathname.startsWith('/')) {
-			throw new Error(
-				'argument passed to preloadCode must be a pathname (i.e. "/about" rather than "http://example.com/about"'
-			);
-		}
+	const route = __SVELTEKIT_CLIENT_ROUTING__
+		? routes.find((r) => r.id === id)
+		: (route_id_cache.get(id) ?? (await load_route_by_id(id)));
 
-		if (!pathname.startsWith(base)) {
-			throw new Error(
-				`pathname passed to preloadCode must start with \`paths.base\` (i.e. "${base}${pathname}" rather than "${pathname}")`
+	if (route === ENDPOINT_ONLY) {
+		if (DEV) {
+			console.warn(
+				`'${id}' has no \`+page\`, so there is no code to preload. If you meant to warm up an ` +
+					`endpoint, request it with \`fetch\` instead.`
 			);
 		}
 
-		if (__SVELTEKIT_CLIENT_ROUTING__) {
-			const rerouted = await get_rerouted_url(url);
-			if (!rerouted || !routes.find((route) => route.exec(get_url_path(rerouted)))) {
-				throw new Error(`'${pathname}' did not match any routes`);
+		return;
+	}
+
+	if (!route) {
+		if (DEV) {
+			// warn rather than throw, since under client routing an endpoint-only route id is
+			// indistinguishable from a typo — the client manifest only contains routes with a `+page`
+			let message = `'${id}' did not match any route`;
+
+			if (__SVELTEKIT_CLIENT_ROUTING__) {
+				message += ` (note that routes without a \`+page\` have no code to preload)`;
+
+				// the most common migration mistake is passing a pathname, which used to work
+				const candidates = [id];
+				if (base && id.startsWith(base)) candidates.push(id.slice(base.length) || '/');
+
+				if (candidates.some((path) => routes.some((r) => r.exec(path)))) {
+					message += `. It does match as a pathname — use \`match(...)\` from \`$app/paths\` to convert a pathname into a route ID`;
+				}
 			}
+
+			console.warn(message);
 		}
+
+		return;
 	}
 
-	return _preload_code(url);
+	await load_route_nodes(route);
 }
 
 /**
@@ -2892,7 +3000,7 @@ export async function applyAction(result) {
 	if (result.type === 'error') {
 		await set_nearest_error_page(result.error);
 	} else if (result.type === 'redirect') {
-		await _goto(result.location, { refreshAll: true }, 0);
+		await _goto(result.location, { refreshAll: true });
 	} else {
 		page.form = result.data;
 		page.status = result.status;
@@ -3108,11 +3216,13 @@ function _start_router() {
 			setTimeout(fulfil, 100); // fallback for edge case where rAF doesn't fire because e.g. tab was backgrounded
 		});
 
-		await navigate({
+		const changed = url.href !== location.href;
+
+		await _goto(url, {
 			type: 'link',
-			url,
 			reset: options.reset,
-			replace_state: options.replace_state ?? url.href === location.href,
+			replace: options.replace_state ?? !changed,
+			refreshAll: !changed,
 			event
 		});
 	});
@@ -3343,7 +3453,7 @@ async function _hydrate(
 	} else {
 		// undefined in case of 404
 		if (server_route) {
-			parsed_route = route = parse_server_route(server_route, app.nodes);
+			parsed_route = route = parse_and_cache_server_route(server_route);
 		} else {
 			route = { id: null };
 			params = {};

package/src/runtime/client/fetcher.js

@@ -1,6 +1,6 @@
 import { BROWSER, DEV } from 'esm-env';
 import { noop } from '../../utils/functions.js';
-import { hash } from '../../utils/hash.js';
+import { hash_request } from '../../utils/hash.js';
 import { base64_decode } from '../utils.js';
 
 let loading = 0;
@@ -172,18 +172,7 @@ function build_selector(resource, opts) {
 			return null;
 		}
 
-		/** @type {import('types').StrictBody[]} */
-		const values = [];
-
-		if (opts.headers) {
-			values.push([...new Headers(opts.headers)].join(','));
-		}
-
-		if (body) {
-			values.push(/** @type {import('types').StrictBody} */ (body));
-		}
-
-		selector += `[data-hash="${hash(...values)}"]`;
+		selector += `[data-hash="${hash_request(opts.headers, body)}"]`;
 	}
 
 	return selector;

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

@@ -262,13 +262,9 @@ export function form(id) {
 
 					if (response.redirect) {
 						// Use internal version to allow redirects to external URLs
-						void _goto(
-							response.redirect,
-							{
-								refreshAll: should_refresh
-							},
-							0
-						);
+						void _goto(response.redirect, {
+							refreshAll: should_refresh
+						});
 						return true;
 					}
 

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

@@ -100,7 +100,7 @@ export function prerender(id) {
 
 				if (result.redirect) {
 					// Use internal version to allow redirects to external URLs
-					void _goto(result.redirect, {}, 0);
+					void _goto(result.redirect);
 					return;
 				}
 

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

@@ -30,7 +30,7 @@ export function query(id) {
 
 			if (result.redirect) {
 				// Use internal version to allow redirects to external URLs
-				await _goto(result.redirect, {}, 0);
+				await _goto(result.redirect);
 			}
 		});
 	};

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

@@ -50,7 +50,7 @@ export function query_batch(id) {
 
 						if (response.redirect) {
 							// Use internal version to allow redirects to external URLs
-							await _goto(response.redirect, {}, 0);
+							await _goto(response.redirect);
 
 							// settle all batched promises (with `undefined`, like a redirect
 							// from a non-batched query) so that callers don't hang forever

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

@@ -74,16 +74,6 @@ export class LiveQueryProxy {
 		return this.#get_cached_query().done;
 	}
 
-	/**
-	 * @deprecated Use `for await (const value of liveQuery())` instead.
-	 * @returns {AsyncGenerator<T>}
-	 */
-	run() {
-		throw new Error(
-			'`.run()` has been removed from live queries. Use `for await (const value of liveQuery())` instead.'
-		);
-	}
-
 	reconnect() {
 		return this.#get_cached_query().reconnect();
 	}

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

@@ -197,7 +197,7 @@ export async function remote_request(url, init) {
 export async function handle_side_channel_response(response) {
 	if (response.type === 'redirect') {
 		// Use internal version to allow redirects to external URLs
-		await _goto(response.location, {}, 0);
+		await _goto(response.location);
 		throw new Redirect(307, response.location);
 	}
 

package/src/runtime/client/utils.js

@@ -122,6 +122,7 @@ export function get_link_info(a, base, uses_hash_router) {
 	/** @type {URL | undefined} */
 	let url;
 
+	// TODO replace the try/catch with `URL.parse` when browser support allows (Chrome 126, Firefox 126, Safari 18)
 	try {
 		url = new URL(a instanceof SVGAElement ? a.href.baseVal : a.href, document.baseURI);
 

package/src/runtime/form-utils.js

@@ -3,12 +3,10 @@
 
 import { DEV } from 'esm-env';
 import * as devalue from 'devalue';
-import { text_encoder } from './utils.js';
+import { text_decoder, text_encoder } from './utils.js';
 import { noop } from '../utils/functions.js';
 import { SvelteKitError } from '@sveltejs/kit/internal';
 
-const decoder = new TextDecoder();
-
 /**
  * Sets a parsed form field value in a nested object, mutating the original object.
  * @param {Record<string, any>} object
@@ -283,7 +281,7 @@ export async function deserialize_binary_form(request, form_id) {
 		const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
 		if (!file_offsets_buffer) throw deserialize_error('file offset table too short');
 
-		const parsed_offsets = JSON.parse(decoder.decode(file_offsets_buffer));
+		const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
 
 		if (
 			!Array.isArray(parsed_offsets) ||
@@ -298,7 +296,7 @@ export async function deserialize_binary_form(request, form_id) {
 
 	/** @type {Array<{ offset: number, size: number }>} */
 	const file_spans = [];
-	const [data, meta] = devalue.parse(decoder.decode(data_buffer), {
+	const [data, meta] = devalue.parse(text_decoder.decode(data_buffer), {
 		File: ([name, type, size, last_modified, index]) => {
 			if (
 				typeof name !== 'string' ||
@@ -488,7 +486,7 @@ class LazyFile {
 		});
 	}
 	async text() {
-		return decoder.decode(await this.arrayBuffer());
+		return text_decoder.decode(await this.arrayBuffer());
 	}
 }
 

package/src/runtime/pathname.js

@@ -47,3 +47,40 @@ export function add_resolution_suffix(pathname) {
 export function strip_resolution_suffix(pathname) {
 	return pathname.slice(0, -ROUTE_SUFFIX.length);
 }
+
+const ROUTES_PREFIX = '/routes';
+
+/**
+ * The pathname of the route-ID-keyed resolution module for a given route ID,
+ * e.g. `/_app/routes/blog/[slug]/__route.js` (before prefixing with `base`).
+ * @param {string} app_dir
+ * @param {string} route_id
+ * @returns {string}
+ */
+export function route_id_resolution_pathname(app_dir, route_id) {
+	return add_resolution_suffix(`/${app_dir}${ROUTES_PREFIX}${route_id === '/' ? '' : route_id}`);
+}
+
+/**
+ * Whether a pathname (with the `/__route.js` suffix already stripped, and `base` NOT yet stripped)
+ * is a route-ID resolution request rather than a pathname resolution request.
+ * @param {string} pathname
+ * @param {string} base
+ * @param {string} app_dir
+ * @returns {boolean}
+ */
+export function is_route_id_resolution_path(pathname, base, app_dir) {
+	const prefix = `${base}/${app_dir}${ROUTES_PREFIX}`;
+	return pathname === prefix || pathname.startsWith(prefix + '/');
+}
+
+/**
+ * Extract the route ID from a decoded, base-stripped, suffix-stripped pathname,
+ * e.g. `/_app/routes/blog/[slug]` -> `/blog/[slug]`, `/_app/routes` -> `/`.
+ * @param {string} pathname
+ * @param {string} app_dir
+ * @returns {string}
+ */
+export function extract_route_id(pathname, app_dir) {
+	return pathname.slice(`/${app_dir}${ROUTES_PREFIX}`.length) || '/';
+}

package/src/runtime/server/fetch.js

@@ -4,6 +4,7 @@ import { respond } from './respond.js';
 import * as paths from '$app/paths/internal/server';
 import { read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
+import { fork_state_for_subrequest } from './state.js';
 
 /**
  * @param {{
@@ -198,6 +199,8 @@ function normalize_fetch_input(info, init, url) {
  * @returns {Promise<Response>}
  */
 async function internal_fetch(request, options, manifest, state) {
+	const subrequest_state = fork_state_for_subrequest(state);
+
 	if (request.signal) {
 		if (request.signal.aborted) {
 			throw new DOMException('The operation was aborted.', 'AbortError');
@@ -214,18 +217,12 @@ async function internal_fetch(request, options, manifest, state) {
 		});
 
 		const result = await Promise.race([
-			respond(request, options, manifest, {
-				...state,
-				depth: state.depth + 1
-			}),
+			respond(request, options, manifest, subrequest_state),
 			abort_promise
 		]);
 		remove_abort_listener();
 		return result;
 	} else {
-		return await respond(request, options, manifest, {
-			...state,
-			depth: state.depth + 1
-		});
+		return await respond(request, options, manifest, subrequest_state);
 	}
 }

package/src/runtime/server/index.js

@@ -67,31 +67,17 @@ export class Server {
 				const result = read(file);
 				if (result instanceof ReadableStream) {
 					return result;
-				} else {
-					return new ReadableStream({
-						async start(controller) {
-							try {
-								const stream = await Promise.resolve(result);
-								if (!stream) {
-									controller.close();
-									return;
-								}
-
-								const reader = stream.getReader();
-
-								while (true) {
-									const { done, value } = await reader.read();
-									if (done) break;
-									controller.enqueue(value);
-								}
-
-								controller.close();
-							} catch (error) {
-								controller.error(error);
-							}
-						}
-					});
 				}
+
+				// TODO remove the cast once TypeScript's lib includes `ReadableStream.from`
+				return /** @type {ReadableStream} */ (
+					/** @type {any} */ (ReadableStream).from(
+						(async function* () {
+							const stream = await result;
+							if (stream) yield* stream;
+						})()
+					)
+				);
 			};
 
 			set_read_implementation(wrapped_read);

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

@@ -1,4 +1,4 @@
-import { text_encoder } from '../../utils.js';
+import { base64_encode, text_encoder } from '../../utils.js';
 
 /**
  * SHA-256 hashing function adapted from https://bitwiseshiftleft.github.io/sjcl
@@ -102,7 +102,7 @@ export function sha256(data) {
 	const bytes = new Uint8Array(out.buffer);
 	reverse_endianness(bytes);
 
-	return btoa(String.fromCharCode(...bytes));
+	return base64_encode(bytes);
 }
 
 /** The SHA-256 initialization vector */

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

@@ -1,11 +1,12 @@
 import { escape_html } from '../../../utils/escape.js';
+import { base64_encode } from '../../utils.js';
 import { sha256 } from './crypto.js';
 
 const array = new Uint8Array(16);
 
 function generate_nonce() {
 	crypto.getRandomValues(array);
-	return btoa(String.fromCharCode(...array));
+	return base64_encode(array);
 }
 
 const quoted = new Set([

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

@@ -336,7 +336,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 
 					const request_body =
 						input instanceof Request && cloned_body
-							? await stream_to_string(cloned_body)
+							? await new Response(cloned_body).text()
 							: init?.body;
 
 					if (
@@ -371,16 +371,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 					const [a, b] = response.body.tee();
 
 					void (async () => {
-						let result = new Uint8Array();
-
-						for await (const chunk of a) {
-							const combined = new Uint8Array(result.length + chunk.length);
-
-							combined.set(result, 0);
-							combined.set(chunk, result.length);
-
-							result = combined;
-						}
+						const result = new Uint8Array(await new Response(a).arrayBuffer());
 
 						if (dependency) {
 							dependency.body = new Uint8Array(result);
@@ -496,21 +487,3 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 		return response;
 	};
 }
-
-/**
- * @param {ReadableStream<Uint8Array>} stream
- */
-async function stream_to_string(stream) {
-	let result = '';
-	const reader = stream.getReader();
-	const decoder = new TextDecoder();
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) {
-			result += decoder.decode();
-			break;
-		}
-		result += decoder.decode(value, { stream: true });
-	}
-	return result;
-}