@sveltejs/kit 2.30.0 → 2.31.0

package/src/exports/public.d.ts

@@ -17,14 +17,14 @@ import {
 	RouteSegment
 } from '../types/private.js';
 import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
-import type { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import {
 	RouteId as AppRouteId,
 	LayoutParams as AppLayoutParams,
 	ResolvedPathname
-	// @ts-ignore
 } from '$app/types';
+import { Span } from '@opentelemetry/api';
 
 export { PrerenderOption } from '../types/private.js';
 
@@ -50,6 +50,12 @@ export interface Adapter {
 		 * @param details.config The merged route config
 		 */
 		read?: (details: { config: any; route: { id: string } }) => boolean;
+
+		/**
+		 * Test support for `instrumentation.server.js`. To pass, the adapter must support running `instrumentation.server.js` prior to the application code.
+		 * @since 2.31.0
+		 */
+		instrumentation?: () => boolean;
 	};
 	/**
 	 * Creates an `Emulator`, which allows the adapter to influence the environment
@@ -187,6 +193,47 @@ export interface Builder {
 		}
 	) => string[];
 
+	/**
+	 * Check if the server instrumentation file exists.
+	 * @returns true if the server instrumentation file exists, false otherwise
+	 * @since 2.31.0
+	 */
+	hasServerInstrumentationFile: () => boolean;
+
+	/**
+	 * Instrument `entrypoint` with `instrumentation`.
+	 *
+	 * Renames `entrypoint` to `start` and creates a new module at
+	 * `entrypoint` which imports `instrumentation` and then dynamically imports `start`. This allows
+	 * the module hooks necessary for instrumentation libraries to be loaded prior to any application code.
+	 *
+	 * Caveats:
+	 * - "Live exports" will not work. If your adapter uses live exports, your users will need to manually import the server instrumentation on startup.
+	 * - If `tla` is `false`, OTEL auto-instrumentation may not work properly. Use it if your environment supports it.
+	 * - Use `hasServerInstrumentationFile` to check if the user has a server instrumentation file; if they don't, you shouldn't do this.
+	 *
+	 * @param options an object containing the following properties:
+	 * @param options.entrypoint the path to the entrypoint to trace.
+	 * @param options.instrumentation the path to the instrumentation file.
+	 * @param options.start the name of the start file. This is what `entrypoint` will be renamed to.
+	 * @param options.module configuration for the resulting entrypoint module.
+	 * @param options.module.exports
+	 * @param options.module.generateText a function that receives the relative paths to the instrumentation and start files, and generates the text of the module to be traced. If not provided, the default implementation will be used, which uses top-level await.
+	 * @since 2.31.0
+	 */
+	instrument: (args: {
+		entrypoint: string;
+		instrumentation: string;
+		start?: string;
+		module?:
+			| {
+					exports: string[];
+			  }
+			| {
+					generateText: (args: { instrumentation: string; start: string }) => string;
+			  };
+	}) => void;
+
 	/**
 	 * Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals.
 	 * @param {string} directory The directory containing the files to be compressed
@@ -408,10 +455,34 @@ export interface KitConfig {
 		 */
 		privatePrefix?: string;
 	};
-	/**
-	 * Experimental features which are exempt from semantic versioning. These features may be changed or removed at any time.
-	 */
+	/** Experimental features. Here be dragons. These are not subject to semantic versioning, so breaking changes or removal can happen in any release. */
 	experimental?: {
+		/**
+		 * Options for enabling server-side [OpenTelemetry](https://opentelemetry.io/) tracing for SvelteKit operations including the [`handle` hook](https://svelte.dev/docs/kit/hooks#Server-hooks-handle), [`load` functions](https://svelte.dev/docs/kit/load), [form actions](https://svelte.dev/docs/kit/form-actions), and [remote functions](https://svelte.dev/docs/kit/remote-functions).
+		 * @default { server: false, serverFile: false }
+		 * @since 2.31.0
+		 */
+		tracing?: {
+			/**
+			 * Enables server-side [OpenTelemetry](https://opentelemetry.io/) span emission for SvelteKit operations including the [`handle` hook](https://svelte.dev/docs/kit/hooks#Server-hooks-handle), [`load` functions](https://svelte.dev/docs/kit/load), [form actions](https://svelte.dev/docs/kit/form-actions), and [remote functions](https://svelte.dev/docs/kit/remote-functions).
+			 * @default false
+			 * @since 2.31.0
+			 */
+			server?: boolean;
+		};
+
+		/**
+		 * @since 2.31.0
+		 */
+		instrumentation?: {
+			/**
+			 * Enables `instrumentation.server.js` for tracing and observability instrumentation.
+			 * @default false
+			 * @since 2.31.0
+			 */
+			server?: boolean;
+		};
+
 		/**
 		 * Whether to enable the experimental remote functions feature. This feature is not yet stable and may be changed or removed at any time.
 		 * @default false
@@ -1027,6 +1098,19 @@ export interface LoadEvent<
 	 * ```
 	 */
 	untrack: <T>(fn: () => T) => T;
+
+	/**
+	 * Access to spans for tracing. If tracing is not enabled or the function is being run in the browser, these spans will do nothing.
+	 * @since 2.31.0
+	 */
+	tracing: {
+		/** Whether tracing is enabled. */
+		enabled: boolean;
+		/** The root span for the request. This span is named `sveltekit.handle.root`. */
+		root: Span;
+		/** The span associated with the current `load` function. */
+		current: Span;
+	};
 }
 
 export interface NavigationEvent<
@@ -1305,6 +1389,20 @@ export interface RequestEvent<
 	 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 	 */
 	isSubRequest: boolean;
+
+	/**
+	 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
+	 * @since 2.31.0
+	 */
+	tracing: {
+		/** Whether tracing is enabled. */
+		enabled: boolean;
+		/** The root span for the request. This span is named `sveltekit.handle.root`. */
+		root: Span;
+		/** The span associated with the current `handle` hook, `load` function, or form action. */
+		current: Span;
+	};
+
 	/**
 	 * `true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information
 	 * related to the data request in this case. Use this property instead if the distinction is important to you.
@@ -1468,6 +1566,19 @@ export interface ServerLoadEvent<
 	 * ```
 	 */
 	untrack: <T>(fn: () => T) => T;
+
+	/**
+	 * Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
+	 * @since 2.31.0
+	 */
+	tracing: {
+		/** Whether tracing is enabled. */
+		enabled: boolean;
+		/** The root span for the request. This span is named `sveltekit.handle.root`. */
+		root: Span;
+		/** The span associated with the current server `load` function. */
+		current: Span;
+	};
 }
 
 /**

package/src/exports/vite/dev/index.js

@@ -501,6 +501,14 @@ export async function dev(vite, vite_config, svelte_config) {
 					return;
 				}
 
+				const resolved_instrumentation = resolve_entry(
+					path.join(svelte_config.kit.files.src, 'instrumentation.server')
+				);
+
+				if (resolved_instrumentation) {
+					await vite.ssrLoadModule(resolved_instrumentation);
+				}
+
 				// we have to import `Server` before calling `set_assets`
 				const { Server } = /** @type {import('types').ServerModule} */ (
 					await vite.ssrLoadModule(`${runtime_base}/server/index.js`, { fixStacktrace: true })

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/paths/index.js

@@ -8,7 +8,9 @@ export function asset(file) {
 
 /** @type {import('./types.d.ts').resolve} */
 export function resolve(id, params) {
-	return base + resolve_route(id, params);
+	// The type error is correct here, and if someone doesn't pass params when they should there's a runtime error,
+	// but we don't want to adjust the internal resolve_route function to accept `undefined`, hence the type cast.
+	return base + resolve_route(id, /** @type {Record<string, string>} */ (params));
 }
 
 export { base, assets, resolve as resolveRoute };

package/src/runtime/app/paths/types.d.ts

@@ -1,4 +1,3 @@
-// @ts-ignore
 import { Asset, RouteId, RouteParams, Pathname, ResolvedPathname } from '$app/types';
 
 /**

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();
 			}