@sveltejs/kit 3.0.0-next.6 → 3.0.0-next.7

package/src/exports/vite/index.js

@@ -17,10 +17,12 @@ import {
 	resolve_explicit_env_entry,
 	create_sveltekit_env_service_worker,
 	create_sveltekit_env_service_worker_dev,
-	create_sveltekit_env_private
+	create_sveltekit_env_private,
+	create_exported_declarations
 } from '../../core/env.js';
 import * as sync from '../../core/sync/sync.js';
 import { create_assets } from '../../core/sync/create_manifest_data/index.js';
+import { load_and_validate_params } from '../../utils/params.js';
 import { runtime_directory, logger } from '../../core/utils.js';
 import { generate_manifest } from '../../core/generate_manifest/index.js';
 import { build_server_nodes } from './build/build_server.js';
@@ -54,10 +56,13 @@ import {
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
 import { should_ignore, has_children } from './static_analysis/utils.js';
-import { process_config, split_config } from '../../core/config/index.js';
+import { process_config, split_config, validate_config } from '../../core/config/index.js';
 import { treeshake_prerendered_remotes } from './build/remote.js';
 
-/** @type {string} */
+/**
+ * Populated after Vite plugins' `config` hooks run
+ * @type {string}
+ */
 let root;
 
 /** @type {import('./types.js').EnforcedConfig} */
@@ -162,7 +167,7 @@ export async function sveltekit(config) {
 	// any options passed to the plugin that SvelteKit doesn't use itself are
 	// forwarded to vite-plugin-svelte, which does its own validation
 	const split = split_config(config ?? {});
-	const svelte_config = process_config(split.svelte_config, { cwd });
+	const svelte_config = validate_config(split.svelte_config);
 
 	if (Array.isArray(svelte_config.preprocess)) {
 		svelte_config.preprocess.push(warning_preprocessor);
@@ -197,7 +202,7 @@ export async function sveltekit(config) {
 	}
 
 	return [
-		plugin_svelte_config(),
+		plugin_root(),
 		...vite_plugin_svelte.svelte(inline_vps_config),
 		...kit({
 			svelte_config
@@ -213,7 +218,7 @@ function resolve_root(vite_config) {
 /**
  * @return {Plugin}
  */
-function plugin_svelte_config() {
+function plugin_root() {
 	return {
 		name: 'vite-plugin-sveltekit-resolve-svelte-config',
 		// make sure it runs first
@@ -223,9 +228,8 @@ function plugin_svelte_config() {
 			handler(config) {
 				root = resolve_root(config);
 
-				// TODO: mjs mts?
 				const config_file = ['svelte.config.js', 'svelte.config.ts'].find((file) =>
-					fs.existsSync(`${root}/${file}`)
+					fs.existsSync(path.join(root, file))
 				);
 				if (config_file) {
 					throw new Error(
@@ -255,7 +259,7 @@ function plugin_svelte_config() {
  * - https://rolldown.rs/apis/plugin-api#output-generation-hooks
  *
  * @param {object} opts
- * @param {import('types').ValidatedConfig} opts.svelte_config options are only resolved after the Vite `config` hook runs
+ * @param {import('types').ValidatedConfig} opts.svelte_config
  * @return {Plugin[]}
  */
 function kit({ svelte_config }) {
@@ -291,7 +295,7 @@ function kit({ svelte_config }) {
 	let initial_config;
 
 	/** @type {string | null} */
-	let service_worker_entry_file = resolve_entry(svelte_config.kit.files.serviceWorker);
+	let service_worker_entry_file;
 	/** @type {import('node:path').ParsedPath} */
 	let parsed_service_worker;
 
@@ -321,10 +325,6 @@ function kit({ svelte_config }) {
 			options: svelte_config
 		},
 
-		applyToEnvironment(environment) {
-			return environment.name !== 'serviceWorker';
-		},
-
 		/**
 		 * Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.
 		 * @see https://vitejs.dev/guide/api-plugin.html#config
@@ -335,7 +335,7 @@ function kit({ svelte_config }) {
 				initial_config = config;
 				is_build = config_env.command === 'build';
 
-				({ kit } = svelte_config);
+				({ kit } = process_config(svelte_config, root));
 				out_dir = posixify(kit.outDir);
 				out = `${out_dir}/output`;
 
@@ -466,7 +466,7 @@ function kit({ svelte_config }) {
 					__SVELTEKIT_PATHS_RELATIVE__: s(kit.paths.relative),
 					__SVELTEKIT_CLIENT_ROUTING__: s(kit.router.resolution === 'client'),
 					__SVELTEKIT_HASH_ROUTING__: s(kit.router.type === 'hash'),
-					__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.tracing.server),
+					__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.tracing.server),
 					__SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__: s(kit.experimental.handleRenderingErrors),
 					__SVELTEKIT_ROOT__: s(root),
 					__SVELTEKIT_DEV__: s(!is_build)
@@ -495,6 +495,23 @@ function kit({ svelte_config }) {
 					/** @type {NonNullable<UserConfig['ssr']>} */ (new_config.ssr).external = ['cookie'];
 				}
 
+				// Vite's `define` is a compile-time text replacement, but Vitest strips
+				// user `define` from the server config and reinstalls the values only as
+				// `globalThis` properties inside test workers, so anything
+				// that runs outside of a test will freak out over
+				// them not being defined
+				if (process.env.VITEST === 'true') {
+					for (const key in new_config.define) {
+						const value = new_config.define[key];
+						try {
+							/** @type {Record<string, any>} */ (globalThis)[key] = JSON.parse(value);
+						} catch {
+							// `kit_global` isn't JSON, so don't try to parse it. We may one day
+							// need to define it in Vitest somehow but for now, ignore it
+						}
+					}
+				}
+
 				warn_overridden_config(config, new_config);
 
 				return new_config;
@@ -519,10 +536,6 @@ function kit({ svelte_config }) {
 	const plugin_virtual_modules = {
 		name: 'vite-plugin-sveltekit-virtual-modules',
 
-		applyToEnvironment(environment) {
-			return environment.name !== 'serviceWorker';
-		},
-
 		async configResolved(config) {
 			explicit_env_entry = resolve_explicit_env_entry(kit);
 			explicit_env_config = await sync.env(kit, explicit_env_entry, config.root, config.mode);
@@ -558,6 +571,10 @@ function kit({ svelte_config }) {
 			});
 		},
 
+		applyToEnvironment(environment) {
+			return environment.name !== 'serviceWorker';
+		},
+
 		resolveId: {
 			filter: {
 				id: [exactRegex('$service-worker'), prefixRegex('__sveltekit/')]
@@ -598,7 +615,7 @@ function kit({ svelte_config }) {
 						return create_service_worker_module(svelte_config);
 
 					case sveltekit_env:
-						return create_sveltekit_env(explicit_env_config, env, explicit_env_entry);
+						return create_sveltekit_env(explicit_env_config, env, explicit_env_entry, !is_build);
 
 					case sveltekit_env_public_client:
 						return create_sveltekit_env_public(
@@ -741,49 +758,56 @@ function kit({ svelte_config }) {
 				if (manifest_data.hooks.client) entrypoints.add(manifest_data.hooks.client);
 				if (manifest_data.hooks.universal) entrypoints.add(manifest_data.hooks.universal);
 
-				const chain = [normalized];
-
-				let current = normalized;
-				let includes_remote_file = false;
+				// Walk up the import graph from the server-only module, looking for a chain
+				// that leads back to a client entrypoint. We search all candidates (not just
+				// the first) because a module can be imported by both server and client code,
+				// and a greedy first-match could follow a server-only branch that never
+				// reaches an entrypoint — see https://github.com/sveltejs/kit/issues/16232
+				/** @type {Set<string>} */
+				const visited = new Set([normalized]);
 
-				while (true) {
+				/**
+				 * @param {string} current
+				 * @param {string[]} chain
+				 * @returns {string[] | null}
+				 */
+				function find_chain(current, chain) {
 					const importers = import_map.get(current);
-					if (!importers) break;
+					if (!importers) return null;
 
-					const candidates = Array.from(importers).filter((importer) => !chain.includes(importer));
-					if (candidates.length === 0) break;
+					for (const importer of importers) {
+						if (visited.has(importer)) continue;
+						visited.add(importer);
 
-					chain.push((current = candidates[0]));
+						const next_chain = [...chain, importer];
+						if (entrypoints.has(importer)) {
+							return next_chain;
+						}
+						const result = find_chain(importer, next_chain);
+						if (result) return result;
+					}
+					return null;
+				}
 
-					includes_remote_file ||= svelte_config.kit.moduleExtensions.some((ext) => {
-						return current.endsWith(`.remote${ext}`);
-					});
+				const chain = find_chain(normalized, [normalized]);
 
-					if (entrypoints.has(current)) {
-						const pyramid = chain
-							.reverse()
-							.map((id, i) => {
-								return `${' '.repeat(i + 1)}${id}`;
-							})
-							.join(' imports\n');
-
-						if (includes_remote_file) {
-							error_for_missing_config(
-								'remote functions',
-								'kit.experimental.remoteFunctions',
-								'true'
-							);
-						}
+				if (chain) {
+					const pyramid = chain
+						.reverse()
+						.map((id, i) => {
+							return `${' '.repeat(i + 1)}${id}`;
+						})
+						.join(' imports\n');
 
-						let message = `Cannot import ${normalized} into code that runs in the browser, as this could leak sensitive information.`;
-						message += `\n\n${pyramid}`;
-						message += `\n\nIf you're only using the import as a type, change it to \`import type\`.`;
+					let message = `Cannot import ${normalized} into code that runs in the browser, as this could leak sensitive information.`;
+					message += `\n\n${pyramid}`;
+					message += `\n\nIf you're only using the import as a type, change it to \`import type\`.`;
 
-						throw stackless(message);
-					}
+					throw stackless(message);
 				}
 
-				throw new Error('An impossible situation occurred');
+				// No chain from this server-only module to a client entrypoint was found —
+				// the module is only imported from server code, which is valid.
 			}
 		}
 	};
@@ -805,7 +829,7 @@ function kit({ svelte_config }) {
 		name: 'vite-plugin-sveltekit-remote',
 
 		applyToEnvironment(environment) {
-			return environment.name !== 'serviceWorker';
+			return svelte_config.kit.experimental.remoteFunctions && environment.name !== 'serviceWorker';
 		},
 
 		// prevent other plugins from resolving our remote virtual module
@@ -823,10 +847,6 @@ function kit({ svelte_config }) {
 				id: prefixRegex('\0sveltekit-remote:')
 			},
 			handler(id) {
-				if (!kit.experimental.remoteFunctions) {
-					return null;
-				}
-
 				// On-the-fly generated entry point for remote file just forwards the original module
 				// We're not using manualChunks because it can cause problems with circular dependencies
 				// (e.g. https://github.com/sveltejs/kit/issues/14679) and module ordering in general
@@ -839,18 +859,10 @@ function kit({ svelte_config }) {
 		},
 
 		configureServer(_dev_server) {
-			if (!kit.experimental.remoteFunctions) {
-				return;
-			}
-
 			dev_server = _dev_server;
 		},
 
 		async transform(code, id) {
-			if (!kit.experimental.remoteFunctions) {
-				return;
-			}
-
 			const normalized = normalize_id(id, normalized_lib, normalized_cwd);
 			if (!svelte_config.kit.moduleExtensions.some((ext) => normalized.endsWith(`.remote${ext}`))) {
 				return;
@@ -876,7 +888,7 @@ function kit({ svelte_config }) {
 					'\n\n' +
 					dedent`
 					import * as $$_self_$$ from './${path.basename(id)}';
-					import { init_remote_functions as $$_init_$$ } from '@sveltejs/kit/internal';
+					import { init_remote_functions as $$_init_$$ } from '@sveltejs/kit/internal/server';
 
 					${dev_server ? 'await Promise.resolve()' : ''}
 
@@ -934,15 +946,17 @@ function kit({ svelte_config }) {
 				}
 			}
 
-			let namespace = '__remote';
-			let uid = 1;
-			while (map.has(namespace)) namespace = `__remote${uid++}`;
-
-			const exports = Array.from(map).map(([name, type]) => {
-				return `export const ${name} = ${namespace}.${type}('${remote.hash}/${name}');`;
-			});
+			const { namespace, declarations, reexports } = create_exported_declarations(
+				map.keys(),
+				(name, ns) => `${ns}.${map.get(name)}('${remote.hash}/${name}')`,
+				'__remote'
+			);
 
-			let result = `import * as ${namespace} from '__sveltekit/remote';\n\n${exports.join('\n')}\n`;
+			let result = `import * as ${namespace} from '__sveltekit/remote';\n\n${declarations.join('\n')}`;
+			if (reexports.length > 0) {
+				result += `\nexport { ${reexports.join(', ')} };`;
+			}
+			result += '\n';
 
 			if (dev_server) {
 				result += `\nimport.meta.hot?.accept();\n`;
@@ -954,6 +968,26 @@ function kit({ svelte_config }) {
 		}
 	};
 
+	/** @type {Plugin} */
+	const plugin_remote_guard = {
+		name: 'vite-plugin-sveltekit-remote-guard',
+
+		applyToEnvironment() {
+			return !svelte_config.kit.experimental.remoteFunctions;
+		},
+
+		transform: {
+			filter: {
+				id: new RegExp(
+					`.remote(${svelte_config.kit.moduleExtensions.join('|')})$`.replaceAll('.', '\\.')
+				)
+			},
+			handler() {
+				error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true');
+			}
+		}
+	};
+
 	/** @type {Manifest} */
 	let vite_server_manifest;
 	/** @type {Manifest | null} */
@@ -979,6 +1013,8 @@ function kit({ svelte_config }) {
 
 			if (!service_worker_entry_file) return;
 
+			service_worker_entry_file = posixify(service_worker_entry_file);
+
 			if (kit.paths.assets) {
 				throw new Error('Cannot use service worker alongside config.paths.assets');
 			}
@@ -1022,8 +1058,8 @@ function kit({ svelte_config }) {
 			return new_config;
 		},
 
-		// the serviceWorker environment only applies during build because Vite currently
-		// only supports the default client environment during development
+		// our serviceWorker environment only exists when building because Vite only
+		// supports the default client environment during development (for now)
 		applyToEnvironment(environment) {
 			return environment.name === 'serviceWorker';
 		},
@@ -1156,32 +1192,30 @@ function kit({ svelte_config }) {
 	/** @type {Plugin} */
 	const plugin_service_worker_env = {
 		name: 'vite-plugin-sveltekit-service-worker-env',
-
-		transform: {
-			filter: {
-				id: service_worker_entry_file || '<skip>'
-			},
-			handler(code) {
-				// prepend the service worker with an import that configures
-				// `env`, in case `$app/env/public` is imported. In production
-				// this is required: dynamic public env vars aren't known at
-				// build time, so `env.js` is loaded at runtime. In dev, the
-				// imported module just inlines the current values instead.
-				return {
-					code: `import '__sveltekit/env/service-worker';\n${code}`
-				};
-			}
+		applyToEnvironment(environment) {
+			return !!service_worker_entry_file && environment.config.consumer === 'client';
+		},
+		transform(code, id) {
+			if (id !== service_worker_entry_file) return;
+
+			// prepend the service worker with an import that configures
+			// `env`, in case `$app/env/public` is imported. In production
+			// this is required: dynamic public env vars aren't known at
+			// build time, so `env.js` is loaded at runtime. In dev, the
+			// imported module just inlines the current values instead.
+			return {
+				code: `import '__sveltekit/env/service-worker';\n${code}`
+			};
 		}
 	};
 
+	/** @type {() => Promise<void> | undefined} */
+	let finalise;
+
 	/** @type {Plugin} */
 	const plugin_compile = {
 		name: 'vite-plugin-sveltekit-compile',
 
-		applyToEnvironment(environment) {
-			return environment.name !== 'serviceWorker';
-		},
-
 		/**
 		 * Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.
 		 * @see https://vitejs.dev/guide/api-plugin.html#config
@@ -1229,11 +1263,10 @@ function kit({ svelte_config }) {
 						}
 					});
 
-					// ...and every matcher
-					Object.entries(manifest_data.matchers).forEach(([key, file]) => {
-						const name = posixify(path.join('entries/matchers', key));
-						server_input[name] = path.resolve(root, file);
-					});
+					// ...and the params file
+					if (manifest_data.params) {
+						server_input['entries/params'] = path.resolve(root, manifest_data.params);
+					}
 
 					// ...and the hooks files
 					if (manifest_data.hooks.server) {
@@ -1254,13 +1287,6 @@ function kit({ svelte_config }) {
 						if (kit.adapter && !kit.adapter.supports?.instrumentation?.()) {
 							throw new Error(`${server_instrumentation} is unsupported in ${kit.adapter.name}.`);
 						}
-						if (!kit.experimental.instrumentation.server) {
-							error_for_missing_config(
-								'`instrumentation.server.js`',
-								'kit.experimental.instrumentation.server',
-								'true'
-							);
-						}
 						server_input['instrumentation.server'] = server_instrumentation;
 					}
 
@@ -1448,6 +1474,10 @@ function kit({ svelte_config }) {
 			return preview(vite, vite_config, svelte_config);
 		},
 
+		applyToEnvironment(environment) {
+			return environment.name !== 'serviceWorker';
+		},
+
 		renderChunk(code, chunk) {
 			if (code.includes('__SVELTEKIT_TRACK__')) {
 				return {
@@ -1479,6 +1509,12 @@ function kit({ svelte_config }) {
 			}
 			mkdirp(out);
 
+			await load_and_validate_params({
+				routes: manifest_data.routes,
+				params_path: manifest_data.params,
+				root
+			});
+
 			const { output: server_chunks } = /** @type {Rolldown.RolldownOutput} */ (
 				await builder.build(builder.environments.ssr)
 			);
@@ -1776,63 +1812,88 @@ function kit({ svelte_config }) {
 				})};\n`
 			);
 
-			if (service_worker_entry_file) {
-				log.info('Building service worker');
-
-				// mirror client settings that we couldn't set per environment in the config hook
-				builder.environments.serviceWorker.config.define =
-					builder.environments.client.config.define;
-				builder.environments.serviceWorker.config.resolve.alias = [
-					...get_config_aliases(kit, vite_config.root)
-				];
+			// defer the adapt step to run after any buildApp hooks the adapter might have
+			finalise = async () => {
+				// defer creating the service worker too because other plugins might build
+				// the client environment again and overwrite our service worker which
+				// outputs to the same directory
+				if (service_worker_entry_file) {
+					log.info('Building service worker');
+
+					// mirror client settings that we couldn't set per environment in the config hook
+					builder.environments.serviceWorker.config.define =
+						builder.environments.client.config.define;
+					builder.environments.serviceWorker.config.resolve.alias = [
+						...get_config_aliases(kit, vite_config.root)
+					];
 
-				// we have to overwrite this because it can't be configured per environment in the config hook
-				builder.environments.serviceWorker.config.experimental.renderBuiltUrl = (filename) => {
-					return {
-						runtime: `new URL(${JSON.stringify(filename)}, location.href).pathname`
+					// we have to overwrite this because it can't be configured per environment in the config hook
+					builder.environments.serviceWorker.config.experimental.renderBuiltUrl = (filename) => {
+						return {
+							runtime: `new URL(${JSON.stringify(filename)}, location.href).pathname`
+						};
 					};
-				};
-
-				await builder.build(builder.environments.serviceWorker);
-			}
-
-			console.log(
-				`\nRun ${styleText(['bold', 'cyan'], 'npm run preview')} to preview your production build locally.`
-			);
 
-			if (kit.adapter) {
-				const { adapt } = await import('../../core/adapt/index.js');
-				await adapt(
-					svelte_config,
-					build_data,
-					metadata,
-					prerendered,
-					prerender_results.prerender_map,
-					log,
-					remotes,
-					vite_config,
-					explicit_env_config
-				);
-			} else {
-				console.log(styleText(['bold', 'yellow'], '\nNo adapter specified'));
+					await builder.build(builder.environments.serviceWorker);
+				}
 
-				const link = styleText(['bold', 'cyan'], 'https://svelte.dev/docs/kit/adapters');
 				console.log(
-					`See ${link} to learn how to configure your app to run on the platform of your choosing`
+					`\nRun ${styleText(['bold', 'cyan'], 'npm run preview')} to preview your production build locally.`
 				);
+
+				if (kit.adapter) {
+					const { adapt } = await import('../../core/adapt/index.js');
+					await adapt(
+						svelte_config,
+						build_data,
+						metadata,
+						prerendered,
+						prerender_results.prerender_map,
+						log,
+						remotes,
+						vite_config,
+						explicit_env_config
+					);
+				} else {
+					console.log(styleText(['bold', 'yellow'], '\nNo adapter specified'));
+
+					const link = styleText(['bold', 'cyan'], 'https://svelte.dev/docs/kit/adapters');
+					console.log(
+						`See ${link} to learn how to configure your app to run on the platform of your choosing`
+					);
+				}
+			};
+		}
+	};
+
+	/** @type {Plugin} */
+	const plugin_adapter = {
+		name: 'vite-plugin-sveltekit-adapter',
+		apply: 'build',
+		buildApp: {
+			// this will run after any buildApp hooks provided by other Vite plugins
+			// see https://vite.dev/guide/api-environment-frameworks#environments-during-build
+			order: 'post',
+			async handler() {
+				await finalise?.();
 			}
 		}
 	};
 
-	return [
-		plugin_setup,
-		plugin_remote,
-		plugin_virtual_modules,
-		process.env.TEST !== 'true' ? plugin_guard : undefined,
-		service_worker_entry_file && plugin_service_worker_env,
-		plugin_service_worker,
-		plugin_compile
-	].filter((p) => !!p);
+	return /** @type {Plugin[]} */ (
+		[
+			svelte_config.kit.adapter?.vite?.plugins,
+			plugin_setup,
+			plugin_remote_guard,
+			plugin_remote,
+			plugin_virtual_modules,
+			process.env.TEST !== 'true' ? plugin_guard : undefined,
+			plugin_service_worker,
+			plugin_service_worker_env,
+			plugin_compile,
+			plugin_adapter
+		].filter(Boolean)
+	);
 }
 
 /**

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { lookup } from 'mrmime';
+import { lookup } from '../../../utils/mime.js';
 import sirv from 'sirv';
 import { loadEnv, normalizePath } from 'vite';
 import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';

package/src/exports/vite/utils.js

@@ -152,17 +152,15 @@ export function normalize_id(id, lib, cwd) {
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**
- * For `error_for_missing_config('instrumentation.server.js', 'experimental.instrumentation.server', true)`,
+ * For `error_for_missing_config('remote functions', 'experimental.remoteFunctions', 'true')`,
  * returns:
  *
  * ```
- * To enable `instrumentation.server.js`, add the following to the SvelteKit plugin in your `vite.config.js`:
+ * To enable remote functions, add the following to the SvelteKit plugin in your `vite.config.js`:
  *
  *\`\`\`js
  *	experimental: {
- *		instrumentation: {
- *			server: true
- *		}
+ *		remoteFunctions: true
  *	}
  *\`\`\`
  *```

package/src/runtime/app/paths/client.js

@@ -1,4 +1,4 @@
-/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname } from '$app/types' */
+/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname, RouteParams } from '$app/types' */
 /** @import { ResolveArgs } from './types.js' */
 import { base, assets, hash_routing } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
@@ -59,11 +59,7 @@ export function resolve(...args) {
 		);
 	}
 
-	// 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 + pathname_prefix + resolve_route(args[0], /** @type {Record<string, string>} */ (args[1]))
-	);
+	return base + pathname_prefix + resolve_route(args[0], args[1] ?? {});
 }
 
 /**
@@ -84,7 +80,7 @@ export function resolve(...args) {
  * @since 2.52.0
  *
  * @param {Pathname | URL | (string & {})} url
- * @returns {Promise<{ id: RouteId, params: Record<string, string> } | null>}
+ * @returns {Promise<{ [K in RouteId]: { id: K; params: RouteParams<K>; } }[RouteId] | null>}
  */
 export async function match(url) {
 	if (typeof url === 'string') {

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

@@ -21,7 +21,7 @@ export function resolve(id, params) {
 		);
 	}
 
-	const resolved = resolve_route(id, /** @type {Record<string, string>} */ (params));
+	const resolved = resolve_route(id, params ?? {});
 
 	if (relative) {
 		const store = try_get_request_store();