@sveltejs/kit 2.20.7 → 2.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.20.7",
+  "version": "2.21.0",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -18,11 +18,12 @@
   "homepage": "https://svelte.dev",
   "type": "module",
   "dependencies": {
+    "@sveltejs/acorn-typescript": "^1.0.5",
     "@types/cookie": "^0.6.0",
+    "acorn": "^8.14.1",
     "cookie": "^0.6.0",
     "devalue": "^5.1.0",
     "esm-env": "^1.2.2",
-    "import-meta-resolve": "^4.1.0",
     "kleur": "^4.1.5",
     "magic-string": "^0.30.5",
     "mrmime": "^2.0.0",
@@ -31,18 +32,18 @@
     "sirv": "^3.0.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.44.1",
+    "@playwright/test": "^1.51.1",
     "@sveltejs/vite-plugin-svelte": "^5.0.1",
     "@types/connect": "^3.4.38",
     "@types/node": "^18.19.48",
     "@types/set-cookie-parser": "^2.4.7",
-    "dts-buddy": "^0.5.5",
+    "dts-buddy": "^0.6.0",
     "rollup": "^4.14.2",
     "svelte": "^5.23.1",
     "svelte-preprocess": "^6.0.0",
     "typescript": "^5.3.3",
-    "vite": "^6.0.11",
-    "vitest": "^3.0.1"
+    "vite": "^6.2.7",
+    "vitest": "^3.1.1"
   },
   "peerDependencies": {
     "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0",

package/src/core/sync/utils.js

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { mkdirp } from '../../utils/filesystem.js';
-import { resolve_peer_dependency } from '../../utils/import.js';
+import { import_peer } from '../../utils/import.js';
 
 /** @type {{ VERSION: string }} */
-const { VERSION } = await resolve_peer_dependency('svelte/compiler');
+const { VERSION } = await import_peer('svelte/compiler');
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();

package/src/exports/public.d.ts

@@ -36,18 +36,18 @@ export interface Adapter {
 	 */
 	adapt: (builder: Builder) => MaybePromise<void>;
 	/**
-	 * Checks called during dev and build to determine whether specific features will work in production with this adapter
+	 * Checks called during dev and build to determine whether specific features will work in production with this adapter.
 	 */
 	supports?: {
 		/**
-		 * Test support for `read` from `$app/server`
-		 * @param config The merged route config
+		 * Test support for `read` from `$app/server`.
+		 * @param details.config The merged route config
 		 */
 		read?: (details: { config: any; route: { id: string } }) => boolean;
 	};
 	/**
 	 * Creates an `Emulator`, which allows the adapter to influence the environment
-	 * during dev, build and prerendering
+	 * during dev, build and prerendering.
 	 */
 	emulate?: () => MaybePromise<Emulator>;
 }
@@ -790,7 +790,7 @@ export type HandleClientError = (input: {
 }) => MaybePromise<void | App.Error>;
 
 /**
- * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) a `fetch` request that happens inside a `load` function that runs on the server (or during pre-rendering)
+ * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) a `fetch` request that happens inside a `load` function that runs on the server (or during prerendering).
  */
 export type HandleFetch = (input: {
 	event: RequestEvent;
@@ -1409,7 +1409,7 @@ export interface ServerLoadEvent<
 }
 
 /**
- * Shape of a form action method that is part of `export const actions = {..}` in `+page.server.js`.
+ * Shape of a form action method that is part of `export const actions = {...}` in `+page.server.js`.
  * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
  */
 export type Action<
@@ -1419,7 +1419,7 @@ export type Action<
 > = (event: RequestEvent<Params, RouteId>) => MaybePromise<OutputData>;
 
 /**
- * Shape of the `export const actions = {..}` object in `+page.server.js`.
+ * Shape of the `export const actions = {...}` object in `+page.server.js`.
  * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
  */
 export type Actions<

package/src/exports/vite/build/build_server.js

@@ -3,7 +3,8 @@ import { mkdirp } from '../../../utils/filesystem.js';
 import { filter_fonts, find_deps, resolve_symlinks } from './utils.js';
 import { s } from '../../../utils/misc.js';
 import { normalizePath } from 'vite';
-import { basename } from 'node:path';
+import { basename, join } from 'node:path';
+import { create_static_analyser } from '../static_analysis/index.js';
 
 /**
  * @param {string} out
@@ -14,7 +15,7 @@ import { basename } from 'node:path';
  * @param {import('vite').Rollup.OutputAsset[] | null} css
  * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
  */
-export function build_server_nodes(out, kit, manifest_data, server_manifest, client_manifest, css, output_config) {
+export async function build_server_nodes(out, kit, manifest_data, server_manifest, client_manifest, css, output_config) {
 	mkdirp(`${out}/server/nodes`);
 	mkdirp(`${out}/server/stylesheets`);
 
@@ -73,7 +74,14 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 		}
 	}
 
-	manifest_data.nodes.forEach((node, i) => {
+	const { get_page_options } = create_static_analyser(async (server_node) => {
+		// Windows needs the file:// protocol for absolute path dynamic imports
+		return import(`file://${join(out, 'server', resolve_symlinks(server_manifest, server_node).chunk.file)}`);
+	});
+
+	for (let i = 0; i < manifest_data.nodes.length; i++) {
+		const node = manifest_data.nodes[i];
+
 		/** @type {string[]} */
 		const imports = [];
 
@@ -101,12 +109,16 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 		}
 
 		if (node.universal) {
-			imports.push(
-				`import * as universal from '../${
-					resolve_symlinks(server_manifest, node.universal).chunk.file
-				}';`
-			);
-			exports.push('export { universal };');
+			const page_options = await get_page_options(node);
+			if (!!page_options && page_options.ssr === false) {
+				exports.push(`export const universal = ${s(page_options, null, 2)};`)
+			} else {
+				imports.push(
+					`import * as universal from '../${resolve_symlinks(server_manifest, node.universal).chunk.file}';`
+				);
+				// TODO: when building for analysis, explain why the file was loaded on the server if we fail to load it
+				exports.push('export { universal };');
+			}
 			exports.push(`export const universal_id = ${s(node.universal)};`);
 		}
 
@@ -186,5 +198,5 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 			`${out}/server/nodes/${i}.js`,
 			`${imports.join('\n')}\n\n${exports.join('\n')}\n`
 		);
-	});
+	}
 }

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

@@ -19,6 +19,7 @@ import { not_found } from '../utils.js';
 import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
+import { create_static_analyser } from '../static_analysis/index.js';
 
 const cwd = process.cwd();
 // vite-specifc queries that we should skip handling for css urls
@@ -101,6 +102,9 @@ export async function dev(vite, vite_config, svelte_config) {
 		return { module, module_node, url };
 	}
 
+	/** @type {(file: string) => void} */
+	let invalidate_page_options;
+
 	function update_manifest() {
 		try {
 			({ manifest_data } = sync.create(svelte_config));
@@ -124,6 +128,12 @@ export async function dev(vite, vite_config, svelte_config) {
 			return;
 		}
 
+		const static_analyser = create_static_analyser(async (server_node) => {
+			const { module } = await resolve(server_node);
+			return module;
+		});
+		invalidate_page_options = static_analyser.invalidate_page_options;
+
 		manifest = {
 			appDir: svelte_config.kit.appDir,
 			appPath: svelte_config.kit.appDir,
@@ -202,9 +212,15 @@ export async function dev(vite, vite_config, svelte_config) {
 						}
 
 						if (node.universal) {
-							const { module, module_node } = await resolve(node.universal);
-							module_nodes.push(module_node);
-							result.universal = module;
+							const page_options = await static_analyser.get_page_options(node);
+							if (page_options?.ssr === false) {
+								result.universal = page_options;
+							} else {
+								// TODO: explain why the file was loaded on the server if we fail to load it
+								const { module, module_node } = await resolve(node.universal);
+								module_nodes.push(module_node);
+								result.universal = module;
+							}
 						}
 
 						if (node.server) {
@@ -344,6 +360,7 @@ export async function dev(vite, vite_config, svelte_config) {
 		if (timeout || restarting) return;
 
 		sync.update(svelte_config, manifest_data, file);
+		invalidate_page_options(path.relative(cwd, file));
 	});
 
 	const { appTemplate, errorTemplate, serviceWorker, hooks } = svelte_config.kit.files;

package/src/exports/vite/index.js

@@ -34,7 +34,7 @@ import {
 	sveltekit_paths,
 	sveltekit_server
 } from './module_ids.js';
-import { resolve_peer_dependency } from '../../utils/import.js';
+import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
 
 const cwd = process.cwd();
@@ -155,7 +155,7 @@ export async function sveltekit() {
 		...svelte_config.vitePlugin
 	};
 
-	const { svelte } = await resolve_peer_dependency('@sveltejs/vite-plugin-svelte');
+	const { svelte } = await import_peer('@sveltejs/vite-plugin-svelte');
 
 	return [...svelte(vite_plugin_svelte_options), ...(await kit({ svelte_config }))];
 }
@@ -181,7 +181,7 @@ let manifest_data;
  * @return {Promise<import('vite').Plugin[]>}
  */
 async function kit({ svelte_config }) {
-	const vite = await resolve_peer_dependency('vite');
+	const vite = await import_peer('vite');
 
 	const { kit } = svelte_config;
 	const out = `${kit.outDir}/output`;
@@ -821,7 +821,7 @@ Tips:
 				// first, build server nodes without the client manifest so we can analyse it
 				log.info('Analysing routes');
 
-				build_server_nodes(
+				await build_server_nodes(
 					out,
 					kit,
 					manifest_data,
@@ -983,7 +983,7 @@ Tips:
 				);
 
 				// regenerate nodes with the client manifest...
-				build_server_nodes(
+				await build_server_nodes(
 					out,
 					kit,
 					manifest_data,

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

@@ -14,7 +14,7 @@ import { not_found } from '../utils.js';
 /** @typedef {(req: Req, res: Res, next: () => void) => void} Handler */
 
 /**
- * @param {{ middlewares: import('connect').Server }} vite
+ * @param {import('vite').PreviewServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
  */

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

@@ -0,0 +1,259 @@
+import { tsPlugin } from '@sveltejs/acorn-typescript';
+import { Parser } from 'acorn';
+import { read } from '../../../utils/filesystem.js';
+
+const inheritable_page_options = new Set(['ssr', 'prerender', 'csr', 'trailingSlash', 'config']);
+
+const page_options = new Set([...inheritable_page_options, 'entries']);
+
+const skip_parsing_regex = new RegExp(
+	`${Array.from(page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
+);
+
+const parser = Parser.extend(tsPlugin());
+
+/**
+ * Collects exported page options from a +page.js/+layout.js file.
+ * We ignore reassignments and use the declared value.
+ * Returns `null` if any export is too difficult to analyse.
+ * @param {string} filename
+ * @param {string} input
+ * @returns {Record<string, any> | null}
+ */
+export function statically_analyse_exports(filename, input) {
+	// if there's a chance there are no page exports or export all declaration,
+	// then we can skip the AST parsing which is expensive
+	if (!skip_parsing_regex.test(input)) {
+		return {};
+	}
+
+	try {
+		const source = parser.parse(input, {
+			sourceType: 'module',
+			ecmaVersion: 'latest'
+		});
+
+		/** @type {Map<string, import('acorn').Literal['value']>} */
+		const static_exports = new Map();
+
+		for (const statement of source.body) {
+			// ignore export all declarations with aliases that are not page options
+			if (
+				statement.type === 'ExportAllDeclaration' &&
+				statement.exported &&
+				!page_options.has(get_name(statement.exported))
+			) {
+				continue;
+			}
+
+			if (
+				statement.type === 'ExportDefaultDeclaration' ||
+				statement.type === 'ExportAllDeclaration'
+			) {
+				return null;
+			} else if (statement.type !== 'ExportNamedDeclaration') {
+				continue;
+			}
+
+			if (statement.specifiers.length) {
+				/** @type {Map<string, string>} */
+				const export_specifiers = new Map();
+				for (const specifier of statement.specifiers) {
+					const exported_name = get_name(specifier.exported);
+					if (!page_options.has(exported_name)) {
+						continue;
+					}
+
+					if (statement.source) {
+						return null;
+					}
+
+					export_specifiers.set(get_name(specifier.local), exported_name);
+				}
+
+				for (const statement of source.body) {
+					switch (statement.type) {
+						case 'ImportDeclaration': {
+							for (const import_specifier of statement.specifiers) {
+								if (export_specifiers.has(import_specifier.local.name)) {
+									return null;
+								}
+							}
+							break;
+						}
+						case 'ExportNamedDeclaration':
+						case 'VariableDeclaration':
+						case 'FunctionDeclaration':
+						case 'ClassDeclaration': {
+							const declaration =
+								statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+
+							if (!declaration) {
+								break;
+							}
+
+							// class and function declarations
+							if (declaration.type !== 'VariableDeclaration') {
+								if (export_specifiers.has(declaration.id.name)) {
+									return null;
+								}
+								break;
+							}
+
+							for (const variable_declarator of declaration.declarations) {
+								if (
+									variable_declarator.id.type !== 'Identifier' ||
+									!export_specifiers.has(variable_declarator.id.name)
+								) {
+									continue;
+								}
+
+								if (variable_declarator.init?.type === 'Literal') {
+									static_exports.set(
+										/** @type {string} */ (export_specifiers.get(variable_declarator.id.name)),
+										variable_declarator.init.value
+									);
+									export_specifiers.delete(variable_declarator.id.name);
+									continue;
+								}
+
+								// references a declaration we can't easily evaluate statically
+								return null;
+							}
+							break;
+						}
+					}
+				}
+
+				// there were some export specifiers that we couldn't resolve
+				if (export_specifiers.size) {
+					return null;
+				}
+				continue;
+			}
+
+			if (!statement.declaration) {
+				continue;
+			}
+
+			// class and function declarations
+			if (statement.declaration.type !== 'VariableDeclaration') {
+				if (page_options.has(statement.declaration.id.name)) {
+					return null;
+				}
+				continue;
+			}
+
+			for (const declaration of statement.declaration.declarations) {
+				if (declaration.id.type !== 'Identifier') {
+					return null;
+				}
+
+				if (!page_options.has(declaration.id.name)) {
+					continue;
+				}
+
+				if (declaration.init?.type === 'Literal') {
+					static_exports.set(declaration.id.name, declaration.init.value);
+					continue;
+				}
+
+				// references a declaration we can't easily evaluate statically
+				return null;
+			}
+		}
+
+		return Object.fromEntries(static_exports);
+	} catch (error) {
+		if (error instanceof Error) {
+			error.message = `Failed to statically analyse ${filename}. ${error.message}`;
+		}
+		throw error;
+	}
+}
+
+/**
+ * @param {import('acorn').Identifier | import('acorn').Literal} node
+ * @returns {string}
+ */
+export function get_name(node) {
+	return node.type === 'Identifier' ? node.name : /** @type {string} */ (node.value);
+}
+
+/**
+ * @param {(server_node: string) => Promise<Record<string, any>>} resolve
+ */
+export function create_static_analyser(resolve) {
+	/** @type {Map<string, Record<string, any> | null>} */
+	const static_exports = new Map();
+
+	/**
+	 * Computes the final page options for a node (if possible). Otherwise, returns `null`.
+	 * @param {import('types').PageNode} node
+	 * @returns {Promise<import('types').UniversalNode | null>}
+	 */
+	const get_page_options = async (node) => {
+		if (node.universal && static_exports.has(node.universal)) {
+			return /** @type {import('types').UniversalNode | null} */ (
+				static_exports.get(node.universal)
+			);
+		}
+
+		/** @type {Record<string, any> | null} */
+		let page_options = {};
+
+		if (node.server) {
+			const module = await resolve(node.server);
+			for (const key in inheritable_page_options) {
+				if (key in module) {
+					page_options[key] = module[key];
+				}
+			}
+		}
+
+		if (node.universal) {
+			let universal_exports = static_exports.get(node.universal);
+			if (universal_exports === undefined) {
+				const input = read(node.universal);
+				universal_exports = statically_analyse_exports(node.universal, input);
+			}
+
+			if (universal_exports === null) {
+				static_exports.set(node.universal, null);
+				return null;
+			}
+
+			page_options = { ...page_options, ...universal_exports };
+		}
+
+		if (node.parent) {
+			const parent_options = await get_page_options(node.parent);
+			if (parent_options === null) {
+				// if the parent cannot be statically analysed, we can't know what
+				// page options the current node inherits, so we invalidate it too
+				if (node.universal) {
+					static_exports.set(node.universal, null);
+				}
+				return null;
+			}
+
+			page_options = { ...parent_options, ...page_options };
+		}
+
+		if (node.universal) {
+			static_exports.set(node.universal, page_options);
+		}
+
+		return page_options;
+	};
+
+	/**
+	 * @param {string} file
+	 * @returns {void}
+	 */
+	const invalidate_page_options = (file) => {
+		static_exports.delete(file);
+	};
+
+	return { get_page_options, invalidate_page_options };
+}

package/src/runtime/server/endpoint.js

@@ -15,7 +15,7 @@ export async function render_endpoint(event, mod, state) {
 
 	let handler = mod[method] || mod.fallback;
 
-	if (method === 'HEAD' && mod.GET && !mod.HEAD) {
+	if (method === 'HEAD' && !mod.HEAD && mod.GET) {
 		handler = mod.GET;
 	}
 

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

@@ -15,6 +15,7 @@ import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { get_data_json } from '../data/index.js';
 import { DEV } from 'esm-env';
+import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**
  * The maximum request depth permitted before assuming we're stuck in an infinite loop
@@ -93,10 +94,13 @@ export async function render_page(event, page, options, manifest, state, nodes,
 		/** @type {import('./types.js').Fetched[]} */
 		const fetched = [];
 
+		const ssr = nodes.ssr();
+		const csr = nodes.csr();
+
 		// renders an empty 'shell' page if SSR is turned off and if there is
 		// no server data to prerender. As a result, the load functions and rendering
 		// only occur client-side.
-		if (nodes.ssr() === false && !(state.prerendering && should_prerender_data)) {
+		if (ssr === false && !(state.prerendering && should_prerender_data)) {
 			// if the user makes a request through a non-enhanced form, the returned value is lost
 			// because there is no SSR or client-side handling of the response
 			if (DEV && action_result && !event.request.headers.has('x-sveltekit-action')) {
@@ -117,7 +121,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 				fetched,
 				page_config: {
 					ssr: false,
-					csr: nodes.csr()
+					csr
 				},
 				status,
 				error: null,
@@ -171,8 +175,6 @@ export async function render_page(event, page, options, manifest, state, nodes,
 			});
 		});
 
-		const csr = nodes.csr();
-
 		/** @type {Array<Promise<Record<string, any> | null>>} */
 		const load_promises = nodes.data.map((node, i) => {
 			if (load_error) throw load_error;
@@ -244,16 +246,22 @@ export async function render_page(event, page, options, manifest, state, nodes,
 							let j = i;
 							while (!branch[j]) j -= 1;
 
+							const layouts = compact(branch.slice(0, j + 1));
+							const nodes = new PageNodes(layouts.map((layout) => layout.node));
+
 							return await render_response({
 								event,
 								options,
 								manifest,
 								state,
 								resolve_opts,
-								page_config: { ssr: true, csr: true },
+								page_config: {
+									ssr: nodes.ssr(),
+									csr: nodes.csr()
+								},
 								status,
 								error,
-								branch: compact(branch.slice(0, j + 1)).concat({
+								branch: layouts.concat({
 									node,
 									data: null,
 									server_data: null
@@ -294,8 +302,6 @@ export async function render_page(event, page, options, manifest, state, nodes,
 			});
 		}
 
-		const ssr = nodes.ssr();
-
 		return await render_response({
 			event,
 			options,
@@ -303,7 +309,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 			state,
 			resolve_opts,
 			page_config: {
-				csr: nodes.csr(),
+				csr,
 				ssr
 			},
 			status,

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

@@ -29,6 +29,7 @@ export async function load_server_data({ event, state, node, parent }) {
 	};
 
 	const load = node.server.load;
+	// TODO: shouldn't this be calculated using PageNodes? there could be a trailingSlash option on a layout
 	const slash = node.server.trailingSlash;
 
 	if (!load) {

package/src/runtime/server/respond.js

@@ -288,7 +288,7 @@ export async function respond(request, options, manifest, state) {
 	let trailing_slash = 'never';
 
 	try {
-		/** @type {PageNodes|undefined} */
+		/** @type {PageNodes | undefined} */
 		const page_nodes = route?.page
 			? new PageNodes(await load_page_nodes(route.page, manifest))
 			: undefined;

package/src/types/internal.d.ts

@@ -401,7 +401,7 @@ export interface SSRNode {
 	universal_id?: string;
 	server_id?: string;
 
-	/** inlined styles. */
+	/** inlined styles */
 	inline_styles?(): MaybePromise<Record<string, string>>;
 	/** Svelte component */
 	component?: SSRComponentLoader;

package/src/utils/import.js

@@ -1,25 +1,52 @@
-import * as imr from 'import-meta-resolve';
 import process from 'node:process';
-import { pathToFileURL } from 'node:url';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Resolves a peer dependency relative to the current CWD. Duplicated with `packages/adapter-auto`
+ * @param {string} dependency
+ */
+function resolve_peer(dependency) {
+	let [name, ...parts] = dependency.split('/');
+	if (name[0] === '@') name += `/${parts.shift()}`;
+
+	let dir = process.cwd();
+
+	while (!fs.existsSync(`${dir}/node_modules/${name}/package.json`)) {
+		if (dir === (dir = path.dirname(dir))) {
+			throw new Error(
+				`Could not resolve peer dependency "${name}" relative to your project — please install it and try again.`
+			);
+		}
+	}
+
+	const pkg_dir = `${dir}/node_modules/${name}`;
+	const pkg = JSON.parse(fs.readFileSync(`${pkg_dir}/package.json`, 'utf-8'));
+
+	const subpackage = ['.', ...parts].join('/');
+
+	let exported = pkg.exports[subpackage];
+
+	while (typeof exported !== 'string') {
+		if (!exported) {
+			throw new Error(`Could not find valid "${subpackage}" export in ${name}/package.json`);
+		}
+
+		exported = exported['import'] ?? exported['default'];
+	}
+
+	return path.resolve(pkg_dir, exported);
+}
 
 /**
  * Resolve a dependency relative to the current working directory,
  * rather than relative to this package (but falls back to trying that, if necessary)
  * @param {string} dependency
  */
-export async function resolve_peer_dependency(dependency) {
+export async function import_peer(dependency) {
 	try {
-		// @ts-expect-error the types are wrong
-		const resolved = imr.resolve(dependency, pathToFileURL(process.cwd() + '/dummy.js'));
-		return await import(resolved);
+		return await import(resolve_peer(dependency));
 	} catch {
-		try {
-			// both imr.resolve and await import above can throw, which is why we can't just do import(resolved).catch(...) above
-			return await import(dependency);
-		} catch {
-			throw new Error(
-				`Could not resolve peer dependency "${dependency}" relative to your project — please install it and try again.`
-			);
-		}
+		return await import(dependency);
 	}
 }

package/src/utils/page_nodes.js

@@ -39,16 +39,15 @@ export class PageNodes {
 	}
 
 	/**
-	 * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash' | 'entries'} Option
-	 * @template {(import('types').UniversalNode | import('types').ServerNode)[Option]} Value
+	 * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash'} Option
 	 * @param {Option} option
 	 * @returns {Value | undefined}
 	 */
 	#get_option(option) {
+		/** @typedef {(import('types').UniversalNode | import('types').ServerNode)[Option]} Value */
+
 		return this.data.reduce((value, node) => {
-			return /** @type {Value} TypeScript's too dumb to understand this */ (
-				node?.universal?.[option] ?? node?.server?.[option] ?? value
-			);
+			return node?.universal?.[option] ?? node?.server?.[option] ?? value;
 		}, /** @type {Value | undefined} */ (undefined));
 	}
 
@@ -77,6 +76,7 @@ export class PageNodes {
 
 			current = {
 				...current,
+				// TODO: should we override the server config value with the universal value similar to other page options?
 				...node?.universal?.config,
 				...node?.server?.config
 			};

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.20.7';
+export const VERSION = '2.21.0';

package/types/index.d.ts

@@ -18,18 +18,18 @@ declare module '@sveltejs/kit' {
 		 */
 		adapt: (builder: Builder) => MaybePromise<void>;
 		/**
-		 * Checks called during dev and build to determine whether specific features will work in production with this adapter
+		 * Checks called during dev and build to determine whether specific features will work in production with this adapter.
 		 */
 		supports?: {
 			/**
-			 * Test support for `read` from `$app/server`
-			 * @param config The merged route config
+			 * Test support for `read` from `$app/server`.
+			 * @param details.config The merged route config
 			 */
 			read?: (details: { config: any; route: { id: string } }) => boolean;
 		};
 		/**
 		 * Creates an `Emulator`, which allows the adapter to influence the environment
-		 * during dev, build and prerendering
+		 * during dev, build and prerendering.
 		 */
 		emulate?: () => MaybePromise<Emulator>;
 	}
@@ -772,7 +772,7 @@ declare module '@sveltejs/kit' {
 	}) => MaybePromise<void | App.Error>;
 
 	/**
-	 * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) a `fetch` request that happens inside a `load` function that runs on the server (or during pre-rendering)
+	 * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) a `fetch` request that happens inside a `load` function that runs on the server (or during prerendering).
 	 */
 	export type HandleFetch = (input: {
 		event: RequestEvent;
@@ -1391,7 +1391,7 @@ declare module '@sveltejs/kit' {
 	}
 
 	/**
-	 * Shape of a form action method that is part of `export const actions = {..}` in `+page.server.js`.
+	 * Shape of a form action method that is part of `export const actions = {...}` in `+page.server.js`.
 	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
 	 */
 	export type Action<
@@ -1401,7 +1401,7 @@ declare module '@sveltejs/kit' {
 	> = (event: RequestEvent<Params, RouteId>) => MaybePromise<OutputData>;
 
 	/**
-	 * Shape of the `export const actions = {..}` object in `+page.server.js`.
+	 * Shape of the `export const actions = {...}` object in `+page.server.js`.
 	 * See [form actions](https://svelte.dev/docs/kit/form-actions) for more information.
 	 */
 	export type Actions<
@@ -1881,7 +1881,7 @@ declare module '@sveltejs/kit' {
 		universal_id?: string;
 		server_id?: string;
 
-		/** inlined styles. */
+		/** inlined styles */
 		inline_styles?(): MaybePromise<Record<string, string>>;
 		/** Svelte component */
 		component?: SSRComponentLoader;

package/types/index.d.ts.map

@@ -5,7 +5,10 @@
 		"Adapter",
 		"LoadProperties",
 		"AwaitedActions",
+		"OptionalUnion",
+		"uniqueSymbol",
 		"ActionFailure",
+		"UnpackValidationError",
 		"Builder",
 		"Config",
 		"Cookies",
@@ -166,6 +169,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }