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

package/src/runtime/server/respond.js

@@ -1,4 +1,4 @@
-/** @import { RequestState, SSRNode } from 'types' */
+/** @import { SSRNode } from 'types' */
 import { DEV } from 'esm-env';
 import { json, text } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
@@ -26,13 +26,15 @@ import { validate_server_exports } from '../../utils/exports.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 { resolve_route } from './page/server_routing.js';
+import { resolve_route, resolve_route_by_id } from './page/server_routing.js';
 import { validateHeaders } from './validate-headers.js';
 import {
 	add_data_suffix,
 	add_resolution_suffix,
+	extract_route_id,
 	has_data_suffix,
 	has_resolution_suffix,
+	is_route_id_resolution_path,
 	strip_data_suffix,
 	strip_resolution_suffix
 } from '../pathname.js';
@@ -82,7 +84,7 @@ export const respond = propagate_context(internal_respond);
  * @param {Request} request
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @param {import('types').SSRState} state
+ * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
 export async function internal_respond(request, options, manifest, state) {
@@ -138,12 +140,16 @@ export async function internal_respond(request, options, manifest, state) {
 
 	let skip_route_resolution = false;
 
+	/** Whether this is a `/${app_dir}/routes/<route_id>/__route.js` request, used by `preloadCode` */
+	let is_route_id_resolution_request = false;
+
 	if (is_route_resolution_request) {
 		/**
 		 * If the request is for a route resolution, first modify the URL, then continue as normal
 		 * for path resolution, then return the route object as a JS file.
 		 */
 		url.pathname = strip_resolution_suffix(url.pathname);
+		is_route_id_resolution_request = is_route_id_resolution_path(url.pathname, base, app_dir);
 	} else if (is_data_request) {
 		url.pathname =
 			strip_data_suffix(url.pathname) +
@@ -174,31 +180,6 @@ export async function internal_respond(request, options, manifest, state) {
 		url
 	);
 
-	/** @type {RequestState} */
-	const event_state = {
-		prerendering: state.prerendering,
-		transport: options.hooks.transport,
-		handleValidationError: options.hooks.handleValidationError,
-		tracing: {
-			record_span
-		},
-		remote: {
-			data: null,
-			explicit: null,
-			implicit: null,
-			forms: null,
-			requested: null,
-			batches: null,
-			live_iterators: null
-		},
-		is_in_remote_function: false,
-		is_in_remote_form_or_command: false,
-		is_in_remote_query: false,
-		is_in_remote_prerender: false,
-		is_in_render: false,
-		is_in_universal_load: false
-	};
-
 	/** @type {import('@sveltejs/kit').RequestEvent} */
 	const event = {
 		cookies,
@@ -213,7 +194,12 @@ export async function internal_respond(request, options, manifest, state) {
 			}),
 		locals: {},
 		params: {},
-		platform: state.platform,
+		platform: state.emulator?.platform
+			? await state.emulator.platform({
+					config: {},
+					prerender: !!state.prerendering?.fallback
+				})
+			: state.platform,
 		request,
 		route: { id: null },
 		setHeaders: (new_headers) => {
@@ -251,6 +237,7 @@ export async function internal_respond(request, options, manifest, state) {
 		isRemoteRequest: !!remote_id
 	};
 
+	// @ts-expect-error this has to be assigned lazily
 	event.fetch = create_fetch({
 		event,
 		options,
@@ -260,17 +247,11 @@ export async function internal_respond(request, options, manifest, state) {
 		set_internal
 	});
 
-	if (state.emulator?.platform) {
-		event.platform = await state.emulator.platform({
-			config: {},
-			prerender: !!state.prerendering?.fallback
-		});
-	}
-
 	/** @type {string | null} */
 	let resolved_path = url.pathname;
 
-	if (!remote_id) {
+	// `reroute` hooks receive pathnames, so they must not run for route-ID resolution requests
+	if (!remote_id && !is_route_id_resolution_request) {
 		const prerendering_reroute_state = state.prerendering?.inside_reroute;
 		try {
 			// For the duration or a reroute, disable the prerendering state as reroute could call API endpoints
@@ -339,7 +320,7 @@ export async function internal_respond(request, options, manifest, state) {
 				statusText: response.statusText
 			});
 		} catch (error) {
-			return await handle_fatal_error(event, event_state, options, error);
+			return await handle_fatal_error(event, state, options, error);
 		}
 	}
 
@@ -354,6 +335,14 @@ export async function internal_respond(request, options, manifest, state) {
 	}
 
 	if (is_route_resolution_request) {
+		if (is_route_id_resolution_request) {
+			return resolve_route_by_id(
+				extract_route_id(resolved_path, app_dir),
+				new URL(request.url),
+				manifest
+			);
+		}
+
 		return resolve_route(resolved_path, new URL(request.url), manifest);
 	}
 
@@ -375,11 +364,13 @@ export async function internal_respond(request, options, manifest, state) {
 
 			if (result) {
 				route = result.route;
+				// @ts-expect-error this has to be assigned lazily
 				event.route = { id: route.id };
+				// @ts-expect-error this has to be assigned lazily
 				event.params = result.params;
 			}
 		} catch (e) {
-			return await handle_fatal_error(event, event_state, options, e);
+			return await handle_fatal_error(event, state, options, e);
 		}
 	}
 
@@ -439,6 +430,7 @@ export async function internal_respond(request, options, manifest, state) {
 				}
 
 				if (state.emulator?.platform) {
+					// @ts-expect-error this has to be assigned lazily
 					event.platform = await state.emulator.platform({ config, prerender });
 				}
 
@@ -461,10 +453,10 @@ export async function internal_respond(request, options, manifest, state) {
 				add_cookies_to_headers(response.headers, new_cookies.values());
 				return response;
 			} catch (err) {
-				return await handle_fatal_error(event, event_state, options, err);
+				return await handle_fatal_error(event, state, options, err);
 			}
 		}
-		return await handle_fatal_error(event, event_state, options, e);
+		return await handle_fatal_error(event, state, options, e);
 	}
 
 	async function handle() {
@@ -493,7 +485,7 @@ export async function internal_respond(request, options, manifest, state) {
 					}
 				};
 
-				return await with_request_store({ event: traced_event, state: event_state }, () =>
+				return await with_request_store({ event: traced_event, state }, () =>
 					options.hooks.handle({
 						event: traced_event,
 						resolve: (event, opts) => {
@@ -600,10 +592,9 @@ export async function internal_respond(request, options, manifest, state) {
 			if (resolved_path === null) {
 				return await respond_with_error({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					error: new SvelteKitError(
 						400,
 						'Malformed URI',
@@ -616,10 +607,9 @@ export async function internal_respond(request, options, manifest, state) {
 			if (options.hash_routing || state.prerendering?.fallback) {
 				return await render_response({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					page_config: { ssr: false, csr: true },
 					status: 200,
 					error: null,
@@ -633,12 +623,12 @@ export async function internal_respond(request, options, manifest, state) {
 					],
 					fetched: [],
 					resolve_opts,
-					data_serializer: server_data_serializer(event, event_state, options)
+					data_serializer: server_data_serializer(event, state, options)
 				});
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, event_state, options, manifest, remote_id);
+				return await handle_remote_call(event, state, options, manifest, remote_id);
 			}
 
 			if (route) {
@@ -650,11 +640,10 @@ export async function internal_respond(request, options, manifest, state) {
 				if (is_data_request) {
 					response = await render_data(
 						event,
-						event_state,
+						state,
 						route,
 						options,
 						manifest,
-						state,
 						invalidated_data_nodes,
 						trailing_slash
 					);
@@ -679,18 +668,17 @@ export async function internal_respond(request, options, manifest, state) {
 					}
 
 					if (endpoint) {
-						response = await render_endpoint(event, event_state, endpoint, state);
+						response = await render_endpoint(event, state, endpoint);
 					} 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,
+								state,
 								route.page,
 								options,
 								manifest,
-								state,
 								page_nodes,
 								resolve_opts
 							);
@@ -776,10 +764,9 @@ export async function internal_respond(request, options, manifest, state) {
 
 				return await respond_with_error({
 					event,
-					event_state,
+					state,
 					options,
 					manifest,
-					state,
 					error: new SvelteKitError(404, 'Not Found', `Not found: ${event.url.pathname}`),
 					resolve_opts
 				});
@@ -800,12 +787,13 @@ export async function internal_respond(request, options, manifest, state) {
 			// and I don't even know how to describe it. need to investigate at some point
 
 			// HttpError from endpoint can end up here - TODO should it be handled there instead?
-			return await handle_fatal_error(event, event_state, options, e);
+			return await handle_fatal_error(event, state, options, e);
 		} finally {
 			event.cookies.set = () => {
 				throw new Error('Cannot use `cookies.set(...)` after the response has been generated');
 			};
 
+			// @ts-expect-error this has to be assigned lazily
 			event.setHeaders = () => {
 				throw new Error('Cannot use `setHeaders(...)` after the response has been generated');
 			};

package/src/runtime/server/state.js

@@ -0,0 +1,60 @@
+/** @import { InternalRequestOptions, RequestState, ServerHooks } from 'types' */
+import { record_span } from '../telemetry/record_span.js';
+
+/** Per-request caches and context flags — never carried into a fork. */
+function transient_fields() {
+	return {
+		remote: {
+			data: null,
+			explicit: null,
+			implicit: null,
+			forms: null,
+			requested: null,
+			batches: null,
+			live_iterators: null
+		},
+		is_in_remote_function: false,
+		is_in_remote_form_or_command: false,
+		is_in_remote_query: false,
+		is_in_remote_prerender: false,
+		is_in_render: false,
+		original_event: undefined
+	};
+}
+
+/**
+ * @param {InternalRequestOptions} options
+ * @param {ServerHooks} hooks
+ * @returns {RequestState}
+ */
+export function create_request_state(options, hooks) {
+	// every field is initialized up front so the object shape stays stable
+	return {
+		getClientAddress: options.getClientAddress,
+		platform: options.platform,
+		read: options.read,
+		before_handle: options.before_handle,
+		emulator: options.emulator,
+		prerendering: options.prerendering,
+		prerender_default: undefined,
+		error: false,
+		depth: 0,
+		handleValidationError: hooks.handleValidationError,
+		tracing: {
+			record_span
+		},
+		...transient_fields()
+	};
+}
+
+/**
+ * @param {RequestState} state
+ * @returns {RequestState}
+ */
+export function fork_state_for_subrequest(state) {
+	return {
+		...state,
+		...transient_fields(),
+		depth: state.depth + 1
+	};
+}

package/src/runtime/server/utils.js

@@ -1,5 +1,3 @@
-/** @import { ServerHooks } from 'types' */
-import * as devalue from 'devalue';
 import { text } from '@sveltejs/kit';
 import { ENDPOINT_METHODS } from '../../constants.js';
 
@@ -139,21 +137,3 @@ export function get_node_type(node_id) {
 export function count_non_ssi_comments(str) {
 	return (str.match(/<!--(?!#)/g) ?? []).length;
 }
-
-/**
- * Creates a serialiser for non-arbitrary POJOs using the app's transport hook
- * @param {ServerHooks['transport']} transport
- * @returns {(thing: unknown) => string | undefined}
- */
-export function create_replacer(transport) {
-	/** @param {unknown} thing */
-	const replacer = (thing) => {
-		for (const key in transport) {
-			const encoded = transport[key].encode(thing);
-			if (encoded) {
-				return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
-			}
-		}
-	};
-	return replacer;
-}

package/src/runtime/shared.js

@@ -1,6 +1,6 @@
-/** @import { Transport } from '@sveltejs/kit' */
 import * as devalue from 'devalue';
-import { base64_decode, base64_encode, text_encoder } from './utils.js';
+import { base64_decode, base64_encode, text_decoder, text_encoder } from './utils.js';
+import { decoders, encoders } from '#app/internal/transport';
 
 /**
  * @param {string} route_id
@@ -39,17 +39,6 @@ export function validate_load_response(data, location_description) {
 	}
 }
 
-/**
- * Try to `devalue.stringify` the data object using the provided transport encoders.
- * @param {any} data
- * @param {Transport} transport
- */
-export function stringify(data, transport) {
-	const encoders = Object.fromEntries(Object.entries(transport).map(([k, v]) => [k, v.encode]));
-
-	return devalue.stringify(data, encoders);
-}
-
 const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype)
 	.sort()
 	.join('\0');
@@ -102,11 +91,9 @@ const remote_regex_guard = '__skrag';
 const remote_arg_marker = Symbol(remote_object);
 
 /**
- * @param {Transport} transport
  * @param {boolean} sort
- * @param {Map<any, any>} remote_arg_clones
  */
-function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
+function create_remote_arg_reducers(sort) {
 	/** @type {Record<string, (value: unknown) => unknown>} */
 	const remote_fns_reducers = {
 		/** @param {unknown} value */
@@ -118,6 +105,8 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 	};
 
 	if (sort) {
+		const clones = new Map();
+
 		/** @type {(value: unknown) => Array<[unknown, unknown]> | undefined} */
 		remote_fns_reducers[remote_map] = (value) => {
 			if (!(value instanceof Map)) {
@@ -167,18 +156,15 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 				return;
 			}
 
-			if (remote_arg_clones.has(value)) {
-				return remote_arg_clones.get(value);
+			if (clones.has(value)) {
+				return clones.get(value);
 			}
 
-			return to_sorted(value, remote_arg_clones);
+			return to_sorted(value, clones);
 		};
 	}
 
-	const user_reducers = Object.fromEntries(
-		Object.entries(transport).map(([k, v]) => [k, v.encode])
-	);
-	const all_reducers = { ...user_reducers, ...remote_fns_reducers };
+	const all_reducers = { ...encoders, ...remote_fns_reducers };
 
 	/** @type {(value: unknown) => string} */
 	const stringify = (value) => devalue.stringify(value, all_reducers);
@@ -186,8 +172,7 @@ function create_remote_arg_reducers(transport, sort, remote_arg_clones) {
 	return all_reducers;
 }
 
-/** @param {Transport} transport */
-function create_remote_arg_revivers(transport) {
+function create_remote_arg_revivers() {
 	const remote_fns_revivers = {
 		/** @type {(value: unknown) => unknown} */
 		[remote_object]: (value) => value,
@@ -251,11 +236,7 @@ function create_remote_arg_revivers(transport) {
 		}
 	};
 
-	const user_revivers = Object.fromEntries(
-		Object.entries(transport).map(([k, v]) => [k, v.decode])
-	);
-
-	const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+	const all_revivers = { ...decoders, ...remote_fns_revivers };
 
 	/** @type {(data: string) => unknown} */
 	const parse = (data) => devalue.parse(data, all_revivers);
@@ -267,13 +248,12 @@ function create_remote_arg_revivers(transport) {
  * Stringifies the argument (if any) for a remote function in such a way that
  * it is both a valid URL and a valid file name (necessary for prerendering).
  * @param {any} value
- * @param {Transport} transport
  */
-export function stringify_remote_arg(value, transport) {
+export function stringify_remote_arg(value) {
 	if (value === undefined) return '';
 
 	// If people hit file/url size limits, we can look into using something like compress_and_encode_text from svelte.dev beyond a certain size
-	const json = devalue.stringify(value, create_remote_arg_reducers(transport, true, new Map()));
+	const json = devalue.stringify(value, create_remote_arg_reducers(true));
 
 	return url_friendly_base64_encode(json);
 }
@@ -281,12 +261,11 @@ export function stringify_remote_arg(value, transport) {
 /**
  * Stringifies command arguments, including `File` objects.
  * @param {any} value
- * @param {Transport} transport
  */
-export async function stringify_command_arg(value, transport) {
+export async function stringify_command_arg(value) {
 	if (value === undefined) return '';
 
-	const reducers = create_remote_arg_reducers(transport, false, new Map());
+	const reducers = create_remote_arg_reducers(false);
 
 	/** @type {Set<Promise<any>>} */
 	const allowed_promises = new Set();
@@ -331,23 +310,24 @@ export async function stringify_command_arg(value, transport) {
  */
 function url_friendly_base64_encode(string) {
 	const bytes = text_encoder.encode(string);
+	// TODO replace with `bytes.toBase64({ alphabet: 'base64url', omitPadding: true })` when we require Node >= 25
 	return base64_encode(bytes).replaceAll('=', '').replaceAll('+', '-').replaceAll('/', '_');
 }
 
 /**
  * Parses the argument (if any) for a remote function
  * @param {string} string
- * @param {Transport} transport
  */
-export function parse_remote_arg(string, transport) {
+export function parse_remote_arg(string) {
 	if (!string) return undefined;
 
-	const json_string = new TextDecoder().decode(
+	const json_string = text_decoder.decode(
+		// TODO replace with `Uint8Array.fromBase64(string, { alphabet: 'base64url' })` when we require Node >= 25
 		// no need to add back `=` characters, atob can handle it
 		base64_decode(string.replaceAll('-', '+').replaceAll('_', '/'))
 	);
 
-	return devalue.parse(json_string, create_remote_arg_revivers(transport));
+	return devalue.parse(json_string, create_remote_arg_revivers());
 }
 
 /**

package/src/runtime/utils.js

@@ -1,6 +1,7 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
+export const text_decoder = new TextDecoder();
 
 /**
  * Like node's path.relative, but without using node
@@ -28,6 +29,7 @@ export function get_relative_path(from, to) {
  * @returns {string}
  */
 export function base64_encode(bytes) {
+	// TODO replace with `bytes.toBase64()` when we require Node >= 25
 	// Using `Buffer` is faster than iterating
 	if (!BROWSER && globalThis.Buffer) {
 		return globalThis.Buffer.from(bytes).toString('base64');
@@ -47,6 +49,7 @@ export function base64_encode(bytes) {
  * @returns {Uint8Array}
  */
 export function base64_decode(encoded) {
+	// TODO replace with `Uint8Array.fromBase64(encoded)` when we require Node >= 25
 	// Using `Buffer` is faster than iterating
 	if (!BROWSER && globalThis.Buffer) {
 		const buffer = globalThis.Buffer.from(encoded, 'base64');

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

@@ -51,5 +51,5 @@ declare module '__sveltekit/manifest-data' {
 	export const immutable: Array<{ path: string }>;
 	export const assets: Array<{ path: string }>;
 	export const prerendered: Array<{ path: string }>;
-	export const routes: Array<{ id: string }>;
+	export const routes: Array<{ id: string; page: boolean; endpoint: boolean }>;
 }

package/src/types/ambient.d.ts

@@ -78,9 +78,41 @@ declare module '$app/manifest' {
 	 */
 	export const prerendered: Array<{ path: import('$app/types').Path }>;
 	/**
-	 * An array of objects with an `id` property representing the routes in your app.
-	 */
-	export const routes: Array<{ id: import('$app/types').RouteId }>;
+	 * A route in your app, along with its capabilities. `page` indicates the presence of a `+page`,
+	 * while `endpoint` indicates the presence of a `+server`. Both are `true` when both files exist.
+	 */
+	export type ManifestRoute =
+		| {
+				id: Exclude<import('$app/types').PageRouteId, import('$app/types').EndpointRouteId>;
+				page: true;
+				endpoint: false;
+		  }
+		| {
+				id: Exclude<import('$app/types').EndpointRouteId, import('$app/types').PageRouteId>;
+				page: false;
+				endpoint: true;
+		  }
+		| {
+				id: Extract<import('$app/types').PageRouteId, import('$app/types').EndpointRouteId>;
+				page: true;
+				endpoint: true;
+		  };
+	/**
+	 * An array of objects representing the routes in your app. Only routes that the router can match
+	 * are included — directories that merely hold a `+layout` are not routes of their own.
+	 *
+	 * Each object has an `id`, plus `page` and `endpoint` booleans describing whether the route has a
+	 * `+page` and/or a `+server`. Both are `true` for a route that has both, so the capabilities can
+	 * be filtered independently:
+	 *
+	 * ```js
+	 * import { routes } from '$app/manifest';
+	 *
+	 * const pages = routes.filter((route) => route.page);
+	 * const endpoints = routes.filter((route) => route.endpoint);
+	 * ```
+	 */
+	export const routes: ManifestRoute[];
 }
 
 /**
@@ -94,6 +126,8 @@ declare module '$app/types' {
 		// These are all functions so that we can leverage function overloads to get the correct type.
 		// Using the return types directly would error with a "not the same type" error.
 		// https://www.typescriptlang.org/docs/handbook/declaration-merging.html#merging-interfaces
+		PageRouteId(): string;
+		EndpointRouteId(): string;
 		RouteId(): string;
 		RouteParams(): Record<string, Record<string, string>>;
 		LayoutParams(): Record<string, Record<string, string>>;
@@ -103,7 +137,21 @@ declare module '$app/types' {
 	}
 
 	/**
-	 * A union of all the route IDs in your app. Used for `page.route.id` and `event.route.id`.
+	 * A union of the route IDs in your app that have a `+page`.
+	 *
+	 * A route ID can be in both `PageRouteId` and `EndpointRouteId`, if its directory contains both a `+page` and a `+server`.
+	 */
+	export type PageRouteId = ReturnType<AppTypes['PageRouteId']>;
+
+	/**
+	 * A union of the route IDs in your app that have a `+server`.
+	 *
+	 * A route ID can be in both `PageRouteId` and `EndpointRouteId`, if its directory contains both a `+page` and a `+server`.
+	 */
+	export type EndpointRouteId = ReturnType<AppTypes['EndpointRouteId']>;
+
+	/**
+	 * A union of all the route IDs in your app — the union of `PageRouteId` and `EndpointRouteId`. Used for `page.route.id` and `event.route.id`.
 	 */
 	export type RouteId = ReturnType<AppTypes['RouteId']>;
 
@@ -119,12 +167,15 @@ declare module '$app/types' {
 		? ReturnType<AppTypes['RouteParams']>[T]
 		: Record<string, never>;
 
+	/**
+	 * The route IDs accepted by `LayoutParams`. Like `RouteId`, these preserve route groups and `[param]` syntax, but they identify directories containing layouts rather than matchable routes.
+	 */
+	type LayoutParamsId = keyof ReturnType<AppTypes['LayoutParams']>;
+
 	/**
 	 * A utility for getting the parameters associated with a given layout, which is similar to `RouteParams` but also includes optional parameters for any child route.
 	 */
-	export type LayoutParams<T extends RouteId> = T extends keyof ReturnType<AppTypes['LayoutParams']>
-		? ReturnType<AppTypes['LayoutParams']>[T]
-		: Record<string, never>;
+	export type LayoutParams<T extends LayoutParamsId> = ReturnType<AppTypes['LayoutParams']>[T];
 
 	/**
 	 * A union of all valid paths in your app, relative to the `base` path.

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

@@ -53,7 +53,7 @@ declare global {
 	const __SVELTEKIT_MANIFEST_IMMUTABLE__: string[];
 	const __SVELTEKIT_MANIFEST_ASSETS__: string[];
 	const __SVELTEKIT_MANIFEST_PRERENDERED__: string[];
-	const __SVELTEKIT_MANIFEST_ROUTES__: { id: string }[];
+	const __SVELTEKIT_MANIFEST_ROUTES__: Array<{ id: string }>;
 	/**
 	 * This makes the use of specific features visible at both dev and build time, in such a
 	 * way that we can error when they are not supported by the target platform.