@sveltejs/kit 2.30.0 → 2.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.30.0",
+  "version": "2.31.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -33,6 +33,7 @@
     "sirv": "^3.0.0"
   },
   "devDependencies": {
+    "@opentelemetry/api": "^1.0.0",
     "@playwright/test": "^1.51.1",
     "@sveltejs/vite-plugin-svelte": "^6.0.0-next.3",
     "@types/connect": "^3.4.38",
@@ -48,9 +49,15 @@
   },
   "peerDependencies": {
     "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0 || ^6.0.0-next.0",
+    "@opentelemetry/api": "^1.0.0",
     "svelte": "^4.0.0 || ^5.0.0-next.0",
     "vite": "^5.0.3 || ^6.0.0 || ^7.0.0-beta.0"
   },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
   "bin": {
     "svelte-kit": "svelte-kit.js"
   },
@@ -72,6 +79,10 @@
       "types": "./types/index.d.ts",
       "import": "./src/exports/internal/index.js"
     },
+    "./internal/server": {
+      "types": "./types/index.d.ts",
+      "import": "./src/exports/internal/server.js"
+    },
     "./node": {
       "types": "./types/index.d.ts",
       "import": "./src/exports/node/index.js"

package/src/core/adapt/builder.js

@@ -1,6 +1,10 @@
+/** @import { Builder } from '@sveltejs/kit' */
+/** @import { ResolvedConfig } from 'vite' */
+/** @import { RouteDefinition } from '@sveltejs/kit' */
+/** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger } from 'types' */
 import colors from 'kleur';
 import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
-import { extname, resolve } from 'node:path';
+import { extname, resolve, join, dirname, relative } from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
@@ -12,6 +16,7 @@ import generate_fallback from '../postbuild/fallback.js';
 import { write } from '../sync/utils.js';
 import { list_files } from '../utils.js';
 import { find_server_assets } from '../generate_manifest/find_server_assets.js';
+import { reserved } from '../env.js';
 
 const pipe = promisify(pipeline);
 const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.wasm'];
@@ -19,16 +24,16 @@ const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.w
 /**
  * Creates the Builder which is passed to adapters for building the application.
  * @param {{
- *   config: import('types').ValidatedConfig;
- *   build_data: import('types').BuildData;
- *   server_metadata: import('types').ServerMetadata;
- *   route_data: import('types').RouteData[];
- *   prerendered: import('types').Prerendered;
- *   prerender_map: import('types').PrerenderMap;
- *   log: import('types').Logger;
- *   vite_config: import('vite').ResolvedConfig;
+ *   config: ValidatedConfig;
+ *   build_data: BuildData;
+ *   server_metadata: ServerMetadata;
+ *   route_data: RouteData[];
+ *   prerendered: Prerendered;
+ *   prerender_map: PrerenderMap;
+ *   log: Logger;
+ *   vite_config: ResolvedConfig;
  * }} opts
- * @returns {import('@sveltejs/kit').Builder}
+ * @returns {Builder}
  */
 export function create_builder({
 	config,
@@ -40,7 +45,7 @@ export function create_builder({
 	log,
 	vite_config
 }) {
-	/** @type {Map<import('@sveltejs/kit').RouteDefinition, import('types').RouteData>} */
+	/** @type {Map<RouteDefinition, RouteData>} */
 	const lookup = new Map();
 
 	/**
@@ -48,11 +53,11 @@ export function create_builder({
 	 * we expose a stable type that adapters can use to group/filter routes
 	 */
 	const routes = route_data.map((route) => {
-		const { config, methods, page, api } = /** @type {import('types').ServerMetadataRoute} */ (
+		const { config, methods, page, api } = /** @type {ServerMetadataRoute} */ (
 			server_metadata.routes.get(route.id)
 		);
 
-		/** @type {import('@sveltejs/kit').RouteDefinition} */
+		/** @type {RouteDefinition} */
 		const facade = {
 			id: route.id,
 			api,
@@ -229,6 +234,53 @@ export function create_builder({
 
 		writeServer(dest) {
 			return copy(`${config.kit.outDir}/output/server`, dest);
+		},
+
+		hasServerInstrumentationFile() {
+			return existsSync(`${config.kit.outDir}/output/server/instrumentation.server.js`);
+		},
+
+		instrument({
+			entrypoint,
+			instrumentation,
+			start = join(dirname(entrypoint), 'start.js'),
+			module = {
+				exports: ['default']
+			}
+		}) {
+			if (!existsSync(instrumentation)) {
+				throw new Error(
+					`Instrumentation file ${instrumentation} not found. This is probably a bug in your adapter.`
+				);
+			}
+			if (!existsSync(entrypoint)) {
+				throw new Error(
+					`Entrypoint file ${entrypoint} not found. This is probably a bug in your adapter.`
+				);
+			}
+
+			copy(entrypoint, start);
+			if (existsSync(`${entrypoint}.map`)) {
+				copy(`${entrypoint}.map`, `${start}.map`);
+			}
+
+			const relative_instrumentation = relative(dirname(entrypoint), instrumentation);
+			const relative_start = relative(dirname(entrypoint), start);
+
+			const facade =
+				'generateText' in module
+					? module.generateText({
+							instrumentation: relative_instrumentation,
+							start: relative_start
+						})
+					: create_instrumentation_facade({
+							instrumentation: relative_instrumentation,
+							start: relative_start,
+							exports: module.exports
+						});
+
+			rimraf(entrypoint);
+			write(entrypoint, facade);
 		}
 	};
 }
@@ -254,3 +306,60 @@ async function compress_file(file, format = 'gz') {
 
 	await pipe(source, compress, destination);
 }
+
+/**
+ * Given a list of exports, generate a facade that:
+ * - Imports the instrumentation file
+ * - Imports `exports` from the entrypoint (dynamically, if `tla` is true)
+ * - Re-exports `exports` from the entrypoint
+ *
+ * `default` receives special treatment: It will be imported as `default` and exported with `export default`.
+ *
+ * @param {{ instrumentation: string; start: string; exports: string[] }} opts
+ * @returns {string}
+ */
+function create_instrumentation_facade({ instrumentation, start, exports }) {
+	const import_instrumentation = `import './${instrumentation}';`;
+
+	let alias_index = 0;
+	const aliases = new Map();
+
+	for (const name of exports.filter((name) => reserved.has(name))) {
+		/*
+		 * you can do evil things like `export { c as class }`.
+		 * in order to import these, you need to alias them, and then un-alias them when re-exporting
+		 * this map will allow us to generate the following:
+		 * import { class as _1 } from 'entrypoint';
+		 * export { _1 as class };
+		 */
+		let alias = `_${alias_index++}`;
+		while (exports.includes(alias)) {
+			alias = `_${alias_index++}`;
+		}
+
+		aliases.set(name, alias);
+	}
+
+	const import_statements = [];
+	const export_statements = [];
+
+	for (const name of exports) {
+		const alias = aliases.get(name);
+		if (alias) {
+			import_statements.push(`${name}: ${alias}`);
+			export_statements.push(`${alias} as ${name}`);
+		} else {
+			import_statements.push(`${name}`);
+			export_statements.push(`${name}`);
+		}
+	}
+
+	const entrypoint_facade = [
+		`const { ${import_statements.join(', ')} } = await import('./${start}');`,
+		export_statements.length > 0 ? `export { ${export_statements.join(', ')} };` : ''
+	]
+		.filter(Boolean)
+		.join('\n');
+
+	return `${import_instrumentation}\n${entrypoint_facade}`;
+}

package/src/core/config/options.js

@@ -120,6 +120,12 @@ const options = object(
 			}),
 
 			experimental: object({
+				tracing: object({
+					server: boolean(false)
+				}),
+				instrumentation: object({
+					server: boolean(false)
+				}),
 				remoteFunctions: boolean(false)
 			}),
 

package/src/core/sync/sync.js

@@ -9,14 +9,13 @@ import { write_non_ambient } from './write_non_ambient.js';
 import { write_server } from './write_server.js';
 
 /**
- * Initialize SvelteKit's generated files.
+ * Initialize SvelteKit's generated files that only depend on the config and mode.
  * @param {import('types').ValidatedConfig} config
  * @param {string} mode
  */
 export function init(config, mode) {
 	write_tsconfig(config.kit);
 	write_ambient(config.kit, mode);
-	write_non_ambient(config.kit);
 }
 
 /**
@@ -32,6 +31,7 @@ export function create(config) {
 	write_server(config, output);
 	write_root(manifest_data, output);
 	write_all_types(config, manifest_data);
+	write_non_ambient(config.kit, manifest_data);
 
 	return { manifest_data };
 }
@@ -67,6 +67,7 @@ export function all_types(config, mode) {
 	init(config, mode);
 	const manifest_data = create_manifest_data({ config });
 	write_all_types(config, manifest_data);
+	write_non_ambient(config.kit, manifest_data);
 }
 
 /**

package/src/core/sync/write_non_ambient.js

@@ -1,6 +1,17 @@
 import path from 'node:path';
 import { GENERATED_COMMENT } from '../../constants.js';
 import { write_if_changed } from './utils.js';
+import { s } from '../../utils/misc.js';
+import { get_route_segments } from '../../utils/routing.js';
+
+const replace_optional_params = (/** @type {string} */ id) =>
+	id.replace(/\/\[\[[^\]]+\]\]/g, '${string}');
+const replace_required_params = (/** @type {string} */ id) =>
+	id.replace(/\/\[[^\]]+\]/g, '/${string}');
+/** Convert route ID to pathname by removing layout groups */
+const remove_group_segments = (/** @type {string} */ id) => {
+	return '/' + get_route_segments(id).join('/');
+};
 
 // `declare module "svelte/elements"` needs to happen in a non-ambient module, and dts-buddy generates one big ambient module,
 // so we can't add it there - therefore generate the typings ourselves here.
@@ -33,10 +44,75 @@ declare module "svelte/elements" {
 export {};
 `;
 
+/**
+ * Generate app types interface extension
+ * @param {import('types').ManifestData} manifest_data
+ */
+function generate_app_types(manifest_data) {
+	/** @type {Set<string>} */
+	const pathnames = new Set();
+
+	/** @type {string[]} */
+	const dynamic_routes = [];
+
+	/** @type {string[]} */
+	const layouts = [];
+
+	for (const route of manifest_data.routes) {
+		if (route.params.length > 0) {
+			const params = route.params.map((p) => `${p.name}${p.optional ? '?:' : ':'} string`);
+			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
+
+			dynamic_routes.push(route_type);
+
+			const pathname = remove_group_segments(route.id);
+			pathnames.add(`\`${replace_required_params(replace_optional_params(pathname))}\` & {}`);
+		} else {
+			const pathname = remove_group_segments(route.id);
+			pathnames.add(s(pathname));
+		}
+
+		/** @type {Map<string, boolean>} */
+		const child_params = new Map(route.params.map((p) => [p.name, p.optional]));
+
+		for (const child of manifest_data.routes.filter((r) => r.id.startsWith(route.id))) {
+			for (const p of child.params) {
+				if (!child_params.has(p.name)) {
+					child_params.set(p.name, true); // always optional
+				}
+			}
+		}
+
+		const layout_params = Array.from(child_params)
+			.map(([name, optional]) => `${name}${optional ? '?:' : ':'} string`)
+			.join('; ');
+
+		const layout_type = `${s(route.id)}: ${layout_params.length > 0 ? `{ ${layout_params} }` : 'Record<string, never>'}`;
+		layouts.push(layout_type);
+	}
+
+	return [
+		'declare module "$app/types" {',
+		'\texport interface AppTypes {',
+		`\t\tRouteId(): ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
+		`\t\tRouteParams(): {\n\t\t\t${dynamic_routes.join(';\n\t\t\t')}\n\t\t};`,
+		`\t\tLayoutParams(): {\n\t\t\t${layouts.join(';\n\t\t\t')}\n\t\t};`,
+		`\t\tPathname(): ${Array.from(pathnames).join(' | ')};`,
+		'\t\tResolvedPathname(): `${"" | `/${string}`}${ReturnType<AppTypes[\'Pathname\']>}`;',
+		`\t\tAsset(): ${manifest_data.assets.map((asset) => s('/' + asset.file)).join(' | ') || 'never'};`,
+		'\t}',
+		'}'
+	].join('\n');
+}
+
 /**
  * Writes non-ambient declarations to the output directory
  * @param {import('types').ValidatedKitConfig} config
+ * @param {import('types').ManifestData} manifest_data
  */
-export function write_non_ambient(config) {
-	write_if_changed(path.join(config.outDir, 'non-ambient.d.ts'), template);
+export function write_non_ambient(config, manifest_data) {
+	const app_types = generate_app_types(manifest_data);
+	const content = [template, app_types].join('\n\n');
+
+	write_if_changed(path.join(config.outDir, 'non-ambient.d.ts'), content);
 }

package/src/core/sync/write_types/index.js

@@ -5,19 +5,8 @@ import MagicString from 'magic-string';
 import { posixify, rimraf, walk } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { ts } from '../ts.js';
-import { s } from '../../../utils/misc.js';
-import { get_route_segments } from '../../../utils/routing.js';
-
 const remove_relative_parent_traversals = (/** @type {string} */ path) =>
 	path.replace(/\.\.\//g, '');
-const replace_optional_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[\[[^\]]+\]\]/g, '${string}');
-const replace_required_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[[^\]]+\]/g, '/${string}');
-/** Convert route ID to pathname by removing layout groups */
-const remove_group_segments = (/** @type {string} */ id) => {
-	return '/' + get_route_segments(id).join('/');
-};
 const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
 
 /**
@@ -65,67 +54,6 @@ export function write_all_types(config, manifest_data) {
 		}
 	}
 
-	/** @type {Set<string>} */
-	const pathnames = new Set();
-
-	/** @type {string[]} */
-	const dynamic_routes = [];
-
-	/** @type {string[]} */
-	const layouts = [];
-
-	for (const route of manifest_data.routes) {
-		if (route.params.length > 0) {
-			const params = route.params.map((p) => `${p.name}${p.optional ? '?:' : ':'} string`);
-			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
-
-			dynamic_routes.push(route_type);
-
-			const pathname = remove_group_segments(route.id);
-			pathnames.add(`\`${replace_required_params(replace_optional_params(pathname))}\` & {}`);
-		} else {
-			const pathname = remove_group_segments(route.id);
-			pathnames.add(s(pathname));
-		}
-
-		/** @type {Map<string, boolean>} */
-		const child_params = new Map(route.params.map((p) => [p.name, p.optional]));
-
-		for (const child of manifest_data.routes.filter((r) => r.id.startsWith(route.id))) {
-			for (const p of child.params) {
-				if (!child_params.has(p.name)) {
-					child_params.set(p.name, true); // always optional
-				}
-			}
-		}
-
-		const layout_params = Array.from(child_params)
-			.map(([name, optional]) => `${name}${optional ? '?:' : ':'} string`)
-			.join('; ');
-
-		const layout_type = `${s(route.id)}: ${layout_params.length > 0 ? `{ ${layout_params} }` : 'undefined'}`;
-		layouts.push(layout_type);
-	}
-
-	try {
-		fs.mkdirSync(types_dir, { recursive: true });
-	} catch {}
-
-	fs.writeFileSync(
-		`${types_dir}/index.d.ts`,
-		[
-			`type DynamicRoutes = {\n\t${dynamic_routes.join(';\n\t')}\n};`,
-			`type Layouts = {\n\t${layouts.join(';\n\t')}\n};`,
-			// we enumerate these rather than doing `keyof Routes` so that the list is visible on hover
-			`export type RouteId = ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
-			'export type RouteParams<T extends RouteId> = T extends keyof DynamicRoutes ? DynamicRoutes[T] : Record<string, never>;',
-			'export type LayoutParams<T extends RouteId> = Layouts[T] | Record<string, never>;',
-			`export type Pathname = ${Array.from(pathnames).join(' | ')};`,
-			'export type ResolvedPathname = `${"" | `/${string}`}${Pathname}`;',
-			`export type Asset = ${manifest_data.assets.map((asset) => s('/' + asset.file)).join(' | ') || 'never'};`
-		].join('\n\n')
-	);
-
 	// Read/write meta data on each invocation, not once per node process,
 	// it could be invoked by another process in the meantime.
 	const meta_data_file = `${types_dir}/route_meta_data.json`;

package/src/exports/hooks/sequence.js

@@ -1,3 +1,11 @@
+/** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
+/** @import { MaybePromise } from 'types' */
+import {
+	merge_tracing,
+	get_request_store,
+	with_request_store
+} from '@sveltejs/kit/internal/server';
+
 /**
  * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
  * The behavior for the `handle` options is as follows:
@@ -66,56 +74,70 @@
  * first post-processing
  * ```
  *
- * @param {...import('@sveltejs/kit').Handle} handlers The chain of `handle` functions
- * @returns {import('@sveltejs/kit').Handle}
+ * @param {...Handle} handlers The chain of `handle` functions
+ * @returns {Handle}
  */
 export function sequence(...handlers) {
 	const length = handlers.length;
 	if (!length) return ({ event, resolve }) => resolve(event);
 
 	return ({ event, resolve }) => {
+		const { state } = get_request_store();
 		return apply_handle(0, event, {});
 
 		/**
 		 * @param {number} i
-		 * @param {import('@sveltejs/kit').RequestEvent} event
-		 * @param {import('@sveltejs/kit').ResolveOptions | undefined} parent_options
-		 * @returns {import('types').MaybePromise<Response>}
+		 * @param {RequestEvent} event
+		 * @param {ResolveOptions | undefined} parent_options
+		 * @returns {MaybePromise<Response>}
 		 */
 		function apply_handle(i, event, parent_options) {
 			const handle = handlers[i];
 
-			return handle({
-				event,
-				resolve: (event, options) => {
-					/** @type {import('@sveltejs/kit').ResolveOptions['transformPageChunk']} */
-					const transformPageChunk = async ({ html, done }) => {
-						if (options?.transformPageChunk) {
-							html = (await options.transformPageChunk({ html, done })) ?? '';
-						}
+			return state.tracing.record_span({
+				name: `sveltekit.handle.sequenced.${handle.name ? handle.name : i}`,
+				attributes: {},
+				fn: async (current) => {
+					const traced_event = merge_tracing(event, current);
+					return await with_request_store({ event: traced_event, state }, () =>
+						handle({
+							event: traced_event,
+							resolve: (event, options) => {
+								/** @type {ResolveOptions['transformPageChunk']} */
+								const transformPageChunk = async ({ html, done }) => {
+									if (options?.transformPageChunk) {
+										html = (await options.transformPageChunk({ html, done })) ?? '';
+									}
 
-						if (parent_options?.transformPageChunk) {
-							html = (await parent_options.transformPageChunk({ html, done })) ?? '';
-						}
+									if (parent_options?.transformPageChunk) {
+										html = (await parent_options.transformPageChunk({ html, done })) ?? '';
+									}
 
-						return html;
-					};
+									return html;
+								};
 
-					/** @type {import('@sveltejs/kit').ResolveOptions['filterSerializedResponseHeaders']} */
-					const filterSerializedResponseHeaders =
-						parent_options?.filterSerializedResponseHeaders ??
-						options?.filterSerializedResponseHeaders;
+								/** @type {ResolveOptions['filterSerializedResponseHeaders']} */
+								const filterSerializedResponseHeaders =
+									parent_options?.filterSerializedResponseHeaders ??
+									options?.filterSerializedResponseHeaders;
 
-					/** @type {import('@sveltejs/kit').ResolveOptions['preload']} */
-					const preload = parent_options?.preload ?? options?.preload;
+								/** @type {ResolveOptions['preload']} */
+								const preload = parent_options?.preload ?? options?.preload;
 
-					return i < length - 1
-						? apply_handle(i + 1, event, {
-								transformPageChunk,
-								filterSerializedResponseHeaders,
-								preload
-							})
-						: resolve(event, { transformPageChunk, filterSerializedResponseHeaders, preload });
+								return i < length - 1
+									? apply_handle(i + 1, event, {
+											transformPageChunk,
+											filterSerializedResponseHeaders,
+											preload
+										})
+									: resolve(event, {
+											transformPageChunk,
+											filterSerializedResponseHeaders,
+											preload
+										});
+							}
+						})
+					);
 				}
 			});
 		}

package/src/{runtime/app/server → exports/internal}/event.js

@@ -1,9 +1,11 @@
 /** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
 
-/** @type {RequestEvent | null} */
-let request_event = null;
+/** @type {RequestStore | null} */
+let sync_store = null;
 
-/** @type {import('node:async_hooks').AsyncLocalStorage<RequestEvent | null>} */
+/** @type {AsyncLocalStorage<RequestStore | null> | null} */
 let als;
 
 import('node:async_hooks')
@@ -19,10 +21,11 @@ import('node:async_hooks')
  *
  * In environments without [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html#class-asynclocalstorage), this must be called synchronously (i.e. not after an `await`).
  * @since 2.20.0
+ *
  * @returns {RequestEvent}
  */
 export function getRequestEvent() {
-	const event = request_event ?? als?.getStore();
+	const event = try_get_request_store()?.event;
 
 	if (!event) {
 		let message =
@@ -39,16 +42,28 @@ export function getRequestEvent() {
 	return event;
 }
 
+export function get_request_store() {
+	const result = try_get_request_store();
+	if (!result) {
+		throw new Error('Could not get the request store. This is an internal error.');
+	}
+	return result;
+}
+
+export function try_get_request_store() {
+	return sync_store ?? als?.getStore() ?? null;
+}
+
 /**
  * @template T
- * @param {RequestEvent | null} event
+ * @param {RequestStore | null} store
  * @param {() => T} fn
  */
-export function with_event(event, fn) {
+export function with_request_store(store, fn) {
 	try {
-		request_event = event;
-		return als ? als.run(event, fn) : fn();
+		sync_store = store;
+		return als ? als.run(store, fn) : fn();
 	} finally {
-		request_event = null;
+		sync_store = null;
 	}
 }

package/src/exports/internal/server.js

@@ -0,0 +1,22 @@
+/**
+ * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
+ * @param {T} event_like
+ * @param {import('@opentelemetry/api').Span} current
+ * @returns {T}
+ */
+export function merge_tracing(event_like, current) {
+	return {
+		...event_like,
+		tracing: {
+			...event_like.tracing,
+			current
+		}
+	};
+}
+
+export {
+	with_request_store,
+	getRequestEvent,
+	get_request_store,
+	try_get_request_store
+} from './event.js';