@sveltejs/kit 2.30.1 → 2.31.0

package/src/exports/vite/index.js

@@ -16,7 +16,13 @@ import { build_service_worker } from './build/build_service_worker.js';
 import { assets_base, find_deps, resolve_symlinks } from './build/utils.js';
 import { dev } from './dev/index.js';
 import { preview } from './preview/index.js';
-import { get_config_aliases, get_env, normalize_id, stackless } from './utils.js';
+import {
+	error_for_missing_config,
+	get_config_aliases,
+	get_env,
+	normalize_id,
+	stackless
+} from './utils.js';
 import { write_client_manifest } from '../../core/sync/write_client_manifest.js';
 import prerender from '../../core/postbuild/prerender.js';
 import analyse from '../../core/postbuild/analyse.js';
@@ -332,7 +338,8 @@ async function kit({ svelte_config }) {
 					__SVELTEKIT_DEV__: 'false',
 					__SVELTEKIT_EMBEDDED__: s(kit.embedded),
 					__SVELTEKIT_EXPERIMENTAL__REMOTE_FUNCTIONS__: s(kit.experimental.remoteFunctions),
-					__SVELTEKIT_CLIENT_ROUTING__: kit.router.resolution === 'client' ? 'true' : 'false',
+					__SVELTEKIT_CLIENT_ROUTING__: s(kit.router.resolution === 'client'),
+					__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.instrumentation.server),
 					__SVELTEKIT_PAYLOAD__: new_config.build.ssr
 						? '{}'
 						: `globalThis.__sveltekit_${version_hash}`
@@ -347,7 +354,8 @@ async function kit({ svelte_config }) {
 					__SVELTEKIT_DEV__: 'true',
 					__SVELTEKIT_EMBEDDED__: s(kit.embedded),
 					__SVELTEKIT_EXPERIMENTAL__REMOTE_FUNCTIONS__: s(kit.experimental.remoteFunctions),
-					__SVELTEKIT_CLIENT_ROUTING__: kit.router.resolution === 'client' ? 'true' : 'false',
+					__SVELTEKIT_CLIENT_ROUTING__: s(kit.router.resolution === 'client'),
+					__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.instrumentation.server),
 					__SVELTEKIT_PAYLOAD__: 'globalThis.__sveltekit_dev'
 				};
 
@@ -775,6 +783,25 @@ async function kit({ svelte_config }) {
 						input[name] = path.resolve(file);
 					});
 
+					// ...and the server instrumentation file
+					const server_instrumentation = resolve_entry(
+						path.join(kit.files.src, 'instrumentation.server')
+					);
+					if (server_instrumentation) {
+						const { adapter } = kit;
+						if (adapter && !adapter.supports?.instrumentation?.()) {
+							throw new Error(`${server_instrumentation} is unsupported in ${adapter.name}.`);
+						}
+						if (!kit.experimental.instrumentation.server) {
+							error_for_missing_config(
+								'instrumentation.server.js',
+								'kit.experimental.instrumentation.server',
+								'true'
+							);
+						}
+						input['instrumentation.server'] = server_instrumentation;
+					}
+
 					// ...and every .remote file
 					for (const remote of manifest_data.remotes) {
 						input[`remote/${remote.hash}`] = path.resolve(remote.file);

package/src/exports/vite/utils.js

@@ -4,6 +4,7 @@ import { posixify } from '../../utils/filesystem.js';
 import { negotiate } from '../../utils/http.js';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { escape_html } from '../../utils/escape.js';
+import { dedent } from '../../core/sync/utils.js';
 import {
 	app_server,
 	env_dynamic_private,
@@ -172,3 +173,46 @@ export function stackless(message) {
 }
 
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
+
+/**
+ * For `error_for_missing_config('instrumentation.server.js', 'kit.experimental.instrumentation.server', true)`,
+ * returns:
+ *
+ * ```
+ * To enable `instrumentation.server.js`, add the following to your `svelte.config.js`:
+ *
+ *\`\`\`js
+ *	kit:
+ *		experimental:
+ *			instrumentation:
+ *				server: true
+ *			}
+ *		}
+ *	}
+ *\`\`\`
+ *```
+ * @param {string} feature_name
+ * @param {string} path
+ * @param {string} value
+ * @returns {never}
+ */
+export function error_for_missing_config(feature_name, path, value) {
+	const hole = '__HOLE__';
+
+	const result = path.split('.').reduce((acc, part, i, parts) => {
+		const indent = '  '.repeat(i);
+		const rhs = i === parts.length - 1 ? value : `{\n${hole}\n${indent}}`;
+
+		return acc.replace(hole, `${indent}${part}: ${rhs}`);
+	}, hole);
+
+	throw new Error(
+		dedent`\
+			To enable \`${feature_name}\`, add the following to your \`svelte.config.js\`:
+
+			\`\`\`js
+			${result}
+			\`\`\`
+		`
+	);
+}

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

@@ -73,6 +73,6 @@ export function read(asset) {
 	throw new Error(`Asset does not exist: ${file}`);
 }
 
-export { getRequestEvent } from './event.js';
+export { getRequestEvent } from '@sveltejs/kit/internal/server';
 
 export { query, prerender, command, form } from './remote/index.js';

package/src/runtime/app/server/remote/command.js

@@ -1,9 +1,8 @@
 /** @import { RemoteCommand } from '@sveltejs/kit' */
 /** @import { RemoteInfo, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-import { getRequestEvent } from '../event.js';
+import { get_request_store } from '@sveltejs/kit/internal/server';
 import { check_experimental, create_validator, run_remote_function } from './shared.js';
-import { get_event_state } from '../../../server/event-state.js';
 
 /**
  * Creates a remote command. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -65,7 +64,7 @@ export function command(validate_or_fn, maybe_fn) {
 
 	/** @type {RemoteCommand<Input, Output> & { __: RemoteInfo }} */
 	const wrapper = (arg) => {
-		const event = getRequestEvent();
+		const { event, state } = get_request_store();
 
 		if (!event.isRemoteRequest) {
 			throw new Error(
@@ -73,9 +72,9 @@ export function command(validate_or_fn, maybe_fn) {
 			);
 		}
 
-		get_event_state(event).refreshes ??= {};
+		state.refreshes ??= {};
 
-		const promise = Promise.resolve(run_remote_function(event, true, arg, validate, fn));
+		const promise = Promise.resolve(run_remote_function(event, state, true, arg, validate, fn));
 
 		// @ts-expect-error
 		promise.updates = () => {

package/src/runtime/app/server/remote/form.js

@@ -1,8 +1,7 @@
 /** @import { RemoteForm } from '@sveltejs/kit' */
 /** @import { RemoteInfo, MaybePromise } from 'types' */
-import { getRequestEvent } from '../event.js';
+import { get_request_store } from '@sveltejs/kit/internal/server';
 import { check_experimental, run_remote_function } from './shared.js';
-import { get_event_state } from '../../../server/event-state.js';
 
 /**
  * Creates a form object that can be spread onto a `<form>` element.
@@ -57,12 +56,11 @@ export function form(fn) {
 			id: '',
 			/** @param {FormData} form_data */
 			fn: async (form_data) => {
-				const event = getRequestEvent();
-				const state = get_event_state(event);
+				const { event, state } = get_request_store();
 
 				state.refreshes ??= {};
 
-				const result = await run_remote_function(event, true, form_data, (d) => d, fn);
+				const result = await run_remote_function(event, state, true, form_data, (d) => d, fn);
 
 				// We don't need to care about args or deduplicating calls, because uneval results are only relevant in full page reloads
 				// where only one form submission is active at the same time
@@ -89,7 +87,7 @@ export function form(fn) {
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
-					const { remote_data } = get_event_state(getRequestEvent());
+					const { remote_data } = get_request_store().state;
 					return remote_data?.[__.id];
 				} catch {
 					return undefined;
@@ -111,7 +109,7 @@ export function form(fn) {
 			Object.defineProperty(instance, 'for', {
 				/** @type {RemoteForm<any>['for']} */
 				value: (key) => {
-					const state = get_event_state(getRequestEvent());
+					const { state } = get_request_store();
 					let instance = (state.form_instances ??= new Map()).get(key);
 
 					if (!instance) {

package/src/runtime/app/server/remote/prerender.js

@@ -3,7 +3,7 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { error, json } from '@sveltejs/kit';
 import { DEV } from 'esm-env';
-import { getRequestEvent } from '../event.js';
+import { get_request_store } from '@sveltejs/kit/internal/server';
 import { create_remote_cache_key, stringify, stringify_remote_arg } from '../../../shared.js';
 import { app_dir, base } from '__sveltekit/paths';
 import {
@@ -13,7 +13,6 @@ import {
 	parse_remote_response,
 	run_remote_function
 } from './shared.js';
-import { get_event_state } from '../../../server/event-state.js';
 
 /**
  * Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -93,15 +92,14 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 	const wrapper = (arg) => {
 		/** @type {Promise<Output> & Partial<RemoteResource<Output>>} */
 		const promise = (async () => {
-			const event = getRequestEvent();
-			const state = get_event_state(event);
+			const { event, state } = get_request_store();
 			const payload = stringify_remote_arg(arg, state.transport);
 			const id = __.id;
 			const url = `${base}/${app_dir}/remote/${id}${payload ? `/${payload}` : ''}`;
 
 			if (!state.prerendering && !DEV && !event.isRemoteRequest) {
 				try {
-					return await get_response(id, arg, event, async () => {
+					return await get_response(id, arg, state, async () => {
 						// TODO adapters can provide prerendered data more efficiently than
 						// fetching from the public internet
 						const response = await fetch(new URL(url, event.url.origin).href);
@@ -130,8 +128,8 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 				return /** @type {Promise<any>} */ (state.prerendering.remote_responses.get(url));
 			}
 
-			const promise = get_response(id, arg, event, () =>
-				run_remote_function(event, false, arg, validate, fn)
+			const promise = get_response(id, arg, state, () =>
+				run_remote_function(event, state, false, arg, validate, fn)
 			);
 
 			if (state.prerendering) {

package/src/runtime/app/server/remote/query.js

@@ -1,7 +1,7 @@
 /** @import { RemoteQuery, RemoteQueryFunction } from '@sveltejs/kit' */
 /** @import { RemoteInfo, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-import { getRequestEvent } from '../event.js';
+import { get_request_store } from '@sveltejs/kit/internal/server';
 import { create_remote_cache_key, stringify_remote_arg } from '../../../shared.js';
 import { prerendering } from '__sveltekit/environment';
 import {
@@ -10,7 +10,6 @@ import {
 	get_response,
 	run_remote_function
 } from './shared.js';
-import { get_event_state } from '../../../server/event-state.js';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -78,19 +77,18 @@ export function query(validate_or_fn, maybe_fn) {
 			);
 		}
 
-		const event = getRequestEvent();
+		const { event, state } = get_request_store();
 
 		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
-		const promise = get_response(__.id, arg, event, () =>
-			run_remote_function(event, false, arg, validate, fn)
+		const promise = get_response(__.id, arg, state, () =>
+			run_remote_function(event, state, false, arg, validate, fn)
 		);
 
 		promise.catch(() => {});
 
 		promise.refresh = async () => {
-			const event = getRequestEvent();
-			const state = get_event_state(event);
-			const refreshes = state?.refreshes;
+			const { state } = get_request_store();
+			const refreshes = state.refreshes;
 
 			if (!refreshes) {
 				throw new Error(

package/src/runtime/app/server/remote/shared.js

@@ -1,10 +1,9 @@
 /** @import { RequestEvent } from '@sveltejs/kit' */
-/** @import { ServerHooks, MaybePromise } from 'types' */
+/** @import { ServerHooks, MaybePromise, RequestState } from 'types' */
 import { parse } from 'devalue';
 import { error } from '@sveltejs/kit';
-import { getRequestEvent, with_event } from '../event.js';
+import { with_request_store, get_request_store } from '@sveltejs/kit/internal/server';
 import { create_remote_cache_key, stringify_remote_arg } from '../../../shared.js';
-import { EVENT_STATE, get_event_state } from '../../../server/event-state.js';
 
 /**
  * @param {any} validate_or_fn
@@ -30,8 +29,7 @@ export function create_validator(validate_or_fn, maybe_fn) {
 	if ('~standard' in validate_or_fn) {
 		return async (arg) => {
 			// Get event before async validation to ensure it's available in server environments without AsyncLocalStorage, too
-			const event = getRequestEvent();
-			const state = get_event_state(event);
+			const { event, state } = get_request_store();
 			const validate = validate_or_fn['~standard'].validate;
 
 			const result = await validate(arg);
@@ -66,12 +64,11 @@ export function create_validator(validate_or_fn, maybe_fn) {
  * @template {MaybePromise<any>} T
  * @param {string} id
  * @param {any} arg
- * @param {RequestEvent} event
+ * @param {RequestState} state
  * @param {() => Promise<T>} get_result
  * @returns {Promise<T>}
  */
-export function get_response(id, arg, event, get_result) {
-	const state = get_event_state(event);
+export function get_response(id, arg, state, get_result) {
 	const cache_key = create_remote_cache_key(id, stringify_remote_arg(arg, state.transport));
 
 	return ((state.remote_data ??= {})[cache_key] ??= get_result());
@@ -104,17 +101,16 @@ export function parse_remote_response(data, transport) {
  * Like `with_event` but removes things from `event` you cannot see/call in remote functions, such as `setHeaders`.
  * @template T
  * @param {RequestEvent} event
+ * @param {RequestState} state
  * @param {boolean} allow_cookies
  * @param {any} arg
  * @param {(arg: any) => any} validate
  * @param {(arg?: any) => T} fn
  */
-export async function run_remote_function(event, allow_cookies, arg, validate, fn) {
+export async function run_remote_function(event, state, allow_cookies, arg, validate, fn) {
 	/** @type {RequestEvent} */
 	const cleansed = {
 		...event,
-		// @ts-expect-error this isn't part of the public `RequestEvent` type
-		[EVENT_STATE]: event[EVENT_STATE],
 		setHeaders: () => {
 			throw new Error('setHeaders is not allowed in remote functions');
 		},
@@ -148,6 +144,6 @@ export async function run_remote_function(event, allow_cookies, arg, validate, f
 	};
 
 	// In two parts, each with_event, so that runtimes without async local storage can still get the event at the start of the function
-	const validated = await with_event(cleansed, () => validate(arg));
-	return with_event(cleansed, () => fn(validated));
+	const validated = await with_request_store({ event: cleansed, state }, () => validate(arg));
+	return with_request_store({ event: cleansed, state }, () => fn(validated));
 }

package/src/runtime/client/client.js

@@ -39,11 +39,17 @@ import {
 } from './constants.js';
 import { validate_page_exports } from '../../utils/exports.js';
 import { compact } from '../../utils/array.js';
-import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM, validate_depends } from '../shared.js';
+import {
+	INVALIDATED_PARAM,
+	TRAILING_SLASH_PARAM,
+	validate_depends,
+	validate_load_response
+} from '../shared.js';
 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_suffix } from '../pathname.js';
+import { noop_span } from '../telemetry/noop.js';
 import { text_decoder } from '../utils.js';
 
 export { load_css };
@@ -715,6 +721,7 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 
 		/** @type {import('@sveltejs/kit').LoadEvent} */
 		const load_input = {
+			tracing: { enabled: false, root: noop_span, current: noop_span },
 			route: new Proxy(route, {
 				get: (target, key) => {
 					if (is_tracking) {
@@ -807,19 +814,7 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 			try {
 				lock_fetch();
 				data = (await node.universal.load.call(null, load_input)) ?? null;
-				if (data != null && Object.getPrototypeOf(data) !== Object.prototype) {
-					throw new Error(
-						`a load function related to route '${route.id}' returned ${
-							typeof data !== 'object'
-								? `a ${typeof data}`
-								: data instanceof Response
-									? 'a Response object'
-									: Array.isArray(data)
-										? 'an array'
-										: 'a non-plain object'
-						}, but must return a plain object at the top level (i.e. \`return {...}\`)`
-					);
-				}
+				validate_load_response(data, `related to route '${route.id}'`);
 			} finally {
 				unlock_fetch();
 			}

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

@@ -11,6 +11,7 @@ import { text_encoder } from '../../utils.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
  * @param {import('types').SSRRoute} route
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
@@ -21,6 +22,7 @@ import { text_encoder } from '../../utils.js';
  */
 export async function render_data(
 	event,
+	event_state,
 	route,
 	options,
 	manifest,
@@ -60,6 +62,7 @@ export async function render_data(
 					// load this. for the child, return as is. for the final result, stream things
 					return load_server_data({
 						event: new_event,
+						event_state,
 						state,
 						node,
 						parent: async () => {
@@ -107,7 +110,7 @@ export async function render_data(
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
-						error: await handle_error_and_jsonify(event, options, error),
+						error: await handle_error_and_jsonify(event, event_state, options, error),
 						status:
 							error instanceof HttpError || error instanceof SvelteKitError
 								? error.status
@@ -117,7 +120,7 @@ export async function render_data(
 			)
 		);
 
-		const { data, chunks } = get_data_json(event, options, nodes);
+		const { data, chunks } = get_data_json(event, event_state, options, nodes);
 
 		if (!chunks) {
 			// use a normal JSON response where possible, so we get `content-length`
@@ -152,7 +155,7 @@ export async function render_data(
 		if (error instanceof Redirect) {
 			return redirect_json_response(error);
 		} else {
-			return json_response(await handle_error_and_jsonify(event, options, error), 500);
+			return json_response(await handle_error_and_jsonify(event, event_state, options, error), 500);
 		}
 	}
 }
@@ -187,11 +190,12 @@ export function redirect_json_response(redirect) {
  * If the serialized data contains promises, `chunks` will be an
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
  * @param {import('types').SSROptions} options
  * @param {Array<import('types').ServerDataSkippedNode | import('types').ServerDataNode | import('types').ServerErrorNode | null | undefined>} nodes
  *  @returns {{ data: string, chunks: AsyncIterable<string> | null }}
  */
-export function get_data_json(event, options, nodes) {
+export function get_data_json(event, event_state, options, nodes) {
 	let promise_id = 1;
 	let count = 0;
 
@@ -214,7 +218,7 @@ export function get_data_json(event, options, nodes) {
 					.catch(
 						/** @param {any} e */ async (e) => {
 							key = 'error';
-							return handle_error_and_jsonify(event, options, /** @type {any} */ (e));
+							return handle_error_and_jsonify(event, event_state, options, /** @type {any} */ (e));
 						}
 					)
 					.then(
@@ -226,6 +230,7 @@ export function get_data_json(event, options, nodes) {
 							} catch {
 								const error = await handle_error_and_jsonify(
 									event,
+									event_state,
 									options,
 									new Error(`Failed to serialize promise while rendering ${event.route.id}`)
 								);

package/src/runtime/server/endpoint.js

@@ -1,16 +1,17 @@
 import { Redirect } from '@sveltejs/kit/internal';
+import { with_request_store } from '@sveltejs/kit/internal/server';
 import { ENDPOINT_METHODS, PAGE_METHODS } from '../../constants.js';
 import { negotiate } from '../../utils/http.js';
-import { with_event } from '../app/server/event.js';
 import { method_not_allowed } from './utils.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
  * @param {import('types').SSREndpoint} mod
  * @param {import('types').SSRState} state
  * @returns {Promise<Response>}
  */
-export async function render_endpoint(event, mod, state) {
+export async function render_endpoint(event, event_state, mod, state) {
 	const method = /** @type {import('types').HttpMethod} */ (event.request.method);
 
 	let handler = mod[method] || mod.fallback;
@@ -41,7 +42,7 @@ export async function render_endpoint(event, mod, state) {
 	}
 
 	try {
-		const response = await with_event(event, () =>
+		const response = await with_request_store({ event, state: event_state }, () =>
 			handler(/** @type {import('@sveltejs/kit').RequestEvent<Record<string, any>>} */ (event))
 		);