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

package/src/core/env.js

@@ -51,6 +51,10 @@ export async function load_explicit_env(kit, file, root, mode) {
 	/** @type {Record<string, EnvVarConfig<any>>} */
 	let variables;
 
+	/** @type {import('../runtime/app/env/internal.js')} */ (
+		await server.ssrLoadModule(`${runtime_directory}/app/env/internal.js`)
+	).set_building();
+
 	try {
 		({ variables } = await server.ssrLoadModule(file));
 
@@ -87,11 +91,12 @@ export async function load_explicit_env(kit, file, root, mode) {
 
 /**
  * Creates the `__sveltekit/env` module
- * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, EnvVarConfig<any> | undefined> | null} variables
  * @param {Record<string, string>} env
  * @param {string | null} entry
+ * @param {boolean} is_dev
  */
-export function create_sveltekit_env(variables, env, entry) {
+export function create_sveltekit_env(variables, env, entry, is_dev) {
 	const imports = entry
 		? [
 				`import { variables } from ${JSON.stringify(entry)};`,
@@ -106,7 +111,7 @@ export function create_sveltekit_env(variables, env, entry) {
 	const issues = {};
 
 	for (const [name, config] of Object.entries(variables ?? {})) {
-		if (config.static) {
+		if (config?.static) {
 			if (config.public) {
 				const value = validate(variables ?? {}, env[name], name, issues);
 				declarations.push(`explicit_public_env.${name} = ${devalue.uneval(value)};`);
@@ -116,7 +121,7 @@ export function create_sveltekit_env(variables, env, entry) {
 				`const ${name} = validate(variables, env.${name}, ${JSON.stringify(name)}, issues);`
 			);
 
-			if (config.public) {
+			if (config?.public) {
 				setters.push(`explicit_public_env.${name} = ${name};`);
 				setters.push(`rendered_env.${name} = ${name};`);
 			} else {
@@ -145,6 +150,19 @@ export function create_sveltekit_env(variables, env, entry) {
 			}`
 	];
 
+	// In dev, initialise the env immediately. Tools like `vite-node` load modules
+	// through the Vite config but don't run the SvelteKit dev server, which is what
+	// normally calls `set_env`. Without this, dynamic env vars imported from
+	// `$app/env/public` and `$app/env/private` would be `undefined` in such contexts.
+	if (is_dev) {
+		/** @type {Record<string, string>} */
+		const dev_env = {};
+		for (const name of Object.keys(variables ?? {})) {
+			if (name in env) dev_env[name] = env[name];
+		}
+		blocks.push(`set_env(${devalue.uneval(dev_env)});`);
+	}
+
 	const module = blocks.join('\n\n');
 
 	return module;
@@ -213,9 +231,36 @@ export function create_sveltekit_env_public(variables, env, prelude) {
 	return `${prelude}\n\n${exports.join('')}`;
 }
 
+/**
+ * Creates the `__sveltekit/env/service-worker` module used in production. When an app uses
+ * dynamic public env vars, they're loaded at runtime via an import of the prerendered
+ * `env.js`. If there are none, values are inlined.
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, string>} env
+ * @param {string} global
+ * @param {string} base
+ * @param {string} app_dir
+ */
+export function create_sveltekit_env_service_worker(variables, env, global, base, app_dir) {
+	const has_dynamic_public_env = Object.values(variables ?? {}).some(
+		(config) => config.public && !config.static
+	);
+
+	if (!has_dynamic_public_env) {
+		return create_sveltekit_env_service_worker_dev(variables, env, global);
+	}
+
+	return dedent`
+		import { env } from '${base}/${app_dir}/env.js';
+
+		globalThis.__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ = true;
+
+		${global} = { env };
+	`;
+}
+
 /**
  * Creates the `__sveltekit/env/service-worker` module used in development
- * (but not in prod, which goes through build_service_worker instead)
  * @param {Record<string, EnvVarConfig<any>> | null} variables
  * @param {Record<string, string>} env
  * @param {string} global
@@ -330,3 +375,73 @@ export const reserved = new Set([
 ]);
 
 export const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+/**
+ * Generates `export const` declarations (and, for reserved-word names that need
+ * aliasing, `const` + re-export specifiers) for a set of named exports.
+ *
+ * For regular names, emits a single efficient `export const name = expr;` statement.
+ * For reserved-word names (e.g. `delete`, `class`), emits `const alias = expr;` plus
+ * a re-export specifier (`alias as name`), since reserved words can't be `const`
+ * binding names but CAN appear in export specifiers.
+ *
+ * You can do evil things like `export { c as class }`. In order to import/re-export
+ * these, you need to alias the binding, then un-alias it when re-exporting:
+ *
+ *   const _0 = ...; // safe binding name
+ *   export { _0 as class }; // valid — `class` is allowed in export specifiers
+ *
+ * Aliases are chosen to avoid collisions with any of the supplied names. The
+ * namespace binding (used to hold the imported module) is likewise chosen to
+ * avoid collisions.
+ *
+ * @param {Iterable<string>} names — the export names
+ * @param {(name: string, namespace: string) => string} build_expression —
+ *   called for each name to produce the right-hand side of the declaration;
+ *   receives the chosen namespace binding so it can reference the imported module
+ * @param {string} namespace_prefix — the preferred binding name for the namespace
+ *   (suffixed with a number if it collides with any export name)
+ * @returns {{ namespace: string, declarations: string[], reexports: string[] }}
+ */
+export function create_exported_declarations(names, build_expression, namespace_prefix) {
+	/** @type {Set<string>} */
+	const set = new Set(names);
+
+	let namespace = namespace_prefix;
+	let namespace_index = 0;
+	while (set.has(namespace)) {
+		namespace = `${namespace_prefix}${namespace_index++}`;
+	}
+
+	let alias_index = 0;
+	/** @type {Map<string, string>} */
+	const aliases = new Map();
+
+	for (const name of set) {
+		if (!reserved.has(name)) continue;
+
+		let alias = `_${alias_index++}`;
+		while (set.has(alias)) {
+			alias = `_${alias_index++}`;
+		}
+		aliases.set(name, alias);
+	}
+
+	/** @type {string[]} */
+	const declarations = [];
+	/** @type {string[]} */
+	const reexports = [];
+
+	for (const name of set) {
+		const alias = aliases.get(name);
+		const expr = build_expression(name, namespace);
+		if (alias) {
+			declarations.push(`const ${alias} = ${expr};`);
+			reexports.push(`${alias} as ${name}`);
+		} else {
+			declarations.push(`export const ${name} = ${expr};`);
+		}
+	}
+
+	return { namespace, declarations, reexports };
+}

package/src/core/generate_manifest/index.js

@@ -1,7 +1,7 @@
 /** @import { RemoteChunk } from 'types' */
 import fs from 'node:fs';
 import path from 'node:path';
-import * as mime from 'mrmime';
+import { lookup as mime_lookup } from '../../utils/mime.js';
 import { s } from '../../utils/misc.js';
 import { get_mime_lookup } from '../utils.js';
 import { resolve_symlinks } from '../../exports/vite/build/utils.js';
@@ -69,10 +69,8 @@ export function generate_manifest({
 		assets.push(build_data.service_worker);
 	}
 
-	// In case of server-side route resolution, we need to include all matchers. Prerendered routes are not part
-	// of the server manifest, and they could reference matchers that then would not be included.
-	const matchers = new Set(
-		build_data.client?.nodes ? Object.keys(build_data.manifest_data.matchers) : undefined
+	const uses_matchers = build_data.manifest_data.routes.some((route) =>
+		route.params.some((param) => param.matcher)
 	);
 
 	/** @param {Array<number | undefined>} indexes */
@@ -93,7 +91,7 @@ export function generate_manifest({
 		files[file] = fs.statSync(path.resolve(build_data.out_dir, 'server', file)).size;
 
 		const ext = path.extname(file);
-		mime_types[ext] ??= mime.lookup(ext) || '';
+		mime_types[ext] ??= mime_lookup(ext) || '';
 	}
 
 	// prettier-ignore
@@ -117,10 +115,6 @@ export function generate_manifest({
 					${routes.map(route => {
 						if (!route.page && !route.endpoint) return;
 
-						route.params.forEach(param => {
-							if (param.matcher) matchers.add(param.matcher);
-						});
-
 						return dedent`
 							{
 								id: ${s(route.id)},
@@ -134,11 +128,14 @@ export function generate_manifest({
 				],
 				prerendered_routes: new Set(${s(prerendered)}),
 				matchers: async () => {
-					${Array.from(
-						matchers,
-						type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`
-					).join('\n')}
-					return { ${Array.from(matchers).join(', ')} };
+					${
+						uses_matchers && build_data.manifest_data.params
+							? dedent`
+								const { params } = await import('${join_relative(relative_path, '/entries/params.js')}');
+								return params;
+							`
+							: 'return {};'
+					}
 				},
 				server_assets: ${s(files)}
 			}

package/src/core/postbuild/analyse.js

@@ -1,4 +1,3 @@
-/** @import { Adapter } from '@sveltejs/kit' */
 /** @import { RemoteChunk } from 'types' */
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -39,15 +38,7 @@ async function analyse({
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	const vite_config = await load_vite_config(vite_config_file);
-
 	const config = extract_svelte_config(vite_config).kit;
-
-	// TODO i think this can just be config.adapter?
-	/** @type {Adapter | undefined} */
-	const adapter = vite_config.plugins.find(
-		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
-	)?.api?.adapter;
-
 	const server_root = join(config.outDir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */
@@ -57,11 +48,16 @@ async function analyse({
 	// essential we do this before analysing the code
 	internal.set_building();
 
-	// set env, `read`, and `manifest`, in case they're used in initialisation
-	internal.set_env(env);
+	// set `read` and `manifest`, in case they're used in initialisation
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
+	// `set_env` lives in a separate module that imports the user's `src/env` config. We import it
+	// *after* `set_building()` so that `building`-dependent expressions resolve correctly
+	/** @type {import('__sveltekit/env')} */
+	const { set_env } = await import(pathToFileURL(`${server_root}/server/env.js`).href);
+	set_env(env);
+
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
 		nodes: [],
@@ -126,7 +122,7 @@ async function analyse({
 				server_manifest,
 				tracked_features
 			)) {
-				check_feature(route.id, route_config, feature, adapter);
+				check_feature(route.id, route_config, feature, config.adapter);
 			}
 		}
 

package/src/core/postbuild/crawl.js

@@ -38,6 +38,18 @@ export function crawl(html, base) {
 	/** @type {string[]} */
 	const hrefs = [];
 
+	/** @type {string[]} */
+	const invalid = [];
+
+	/** @param {string} url */
+	const push_href = (url) => {
+		try {
+			hrefs.push(resolve(base, url));
+		} catch {
+			invalid.push(url);
+		}
+	};
+
 	let i = 0;
 	main: while (i < html.length) {
 		const char = html[i];
@@ -186,9 +198,13 @@ export function crawl(html, base) {
 
 				if (href) {
 					if (tag === 'BASE') {
-						base = resolve(base, href);
+						try {
+							base = resolve(base, href);
+						} catch {
+							invalid.push(href);
+						}
 					} else if (!rel || !/\bexternal\b/i.test(rel)) {
-						hrefs.push(resolve(base, href));
+						push_href(href);
 					}
 				}
 
@@ -201,7 +217,7 @@ export function crawl(html, base) {
 				}
 
 				if (src) {
-					hrefs.push(resolve(base, src));
+					push_href(src);
 				}
 
 				if (srcset) {
@@ -222,7 +238,7 @@ export function crawl(html, base) {
 					candidates.push(value);
 					for (const candidate of candidates) {
 						const src = candidate.split(WHITESPACE)[0];
-						if (src) hrefs.push(resolve(base, src));
+						if (src) push_href(src);
 					}
 				}
 
@@ -230,7 +246,7 @@ export function crawl(html, base) {
 					const attr = name ?? property;
 
 					if (attr && CRAWLABLE_META_NAME_ATTRS.has(attr)) {
-						hrefs.push(resolve(base, content));
+						push_href(content);
 					}
 				}
 			}
@@ -239,5 +255,5 @@ export function crawl(html, base) {
 		i += 1;
 	}
 
-	return { ids, hrefs };
+	return { ids, hrefs, invalid };
 }

package/src/core/postbuild/prerender.js

@@ -1,4 +1,3 @@
-/** @import { Adapter } from '@sveltejs/kit' */
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -44,14 +43,20 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	/** @type {import('types').ServerInternalModule} */
 	const internal = await import(pathToFileURL(`${out}/server/internal.js`).href);
 
-	/** @type {import('types').ServerModule} */
-	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
-
 	// configure `import { building } from `$app/env` —
 	// essential we do this before analysing the code
 	internal.set_building();
 	internal.set_prerendering();
 
+	// `set_env` and `Server` live in modules that import the user's `src/env` config. We import them
+	// *after* `set_building()` so that `building`-dependent expressions resolve correctly
+	/** @type {import('__sveltekit/env')} */
+	const { set_env } = await import(pathToFileURL(`${out}/server/env.js`).href);
+	set_env(env);
+
+	/** @type {import('types').ServerModule} */
+	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
+
 	/**
 	 * @template {{message: string}} T
 	 * @template {Omit<T, 'message'>} K
@@ -105,12 +110,14 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 	const config = extract_svelte_config(vite_config).kit;
 
+	const prerender_origin = config.paths.origin || 'http://sveltekit-prerender';
+
 	if (hash) {
 		const fallback = await generate_fallback({
 			manifest_path,
 			env,
 			out_dir: config.outDir,
-			origin: config.prerender.origin,
+			origin: prerender_origin,
 			assets: config.files.assets
 		});
 
@@ -125,13 +132,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		return { prerendered, prerender_map };
 	}
 
-	// TODO this can just be config.adapter?
-	/** @type {Adapter | undefined} */
-	const adapter = vite_config.plugins.find(
-		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
-	)?.api?.adapter;
-
-	const emulator = await adapter?.emulate?.();
+	const emulator = await config.adapter?.emulate?.();
 
 	/** @type {import('types').Logger} */
 	const log = logger({ verbose });
@@ -145,7 +146,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		({ status, path, referrer, referenceType }) => {
 			const message =
 				status === 404 && !path.startsWith(config.paths.base)
-					? `${path} does not begin with \`base\`, which is configured in \`paths.base\` and can be imported from \`$app/paths\` - see https://svelte.dev/docs/kit/configuration#paths for more info`
+					? `${path} does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\` - see https://svelte.dev/docs/kit/configuration#paths for more info`
 					: path;
 
 			return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
@@ -180,6 +181,14 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	);
 
+	const handle_invalid_url = normalise_error_handler(
+		log,
+		config.prerender.handleInvalidUrl,
+		({ href, referrer }) => {
+			return `Invalid URL ${href}${referrer ? ` (linked from ${referrer})` : ''}`;
+		}
+	);
+
 	const q = queue(config.prerender.concurrency);
 
 	/**
@@ -251,7 +260,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		/** @type {Map<string, import('types').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		const response = await server.respond(new Request(config.prerender.origin + encoded), {
+		const response = await server.respond(new Request(prerender_origin + encoded), {
 			getClientAddress() {
 				throw new Error('Cannot read clientAddress during prerendering');
 			},
@@ -334,16 +343,20 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 		// if it's a 200 HTML response, crawl it. Skip error responses, as we don't save those
 		if (response.ok && config.prerender.crawl && headers['content-type'] === 'text/html') {
-			const { ids, hrefs } = crawl(body.toString(), decoded);
+			const { ids, hrefs, invalid } = crawl(body.toString(), decoded);
+
+			for (const href of invalid) {
+				handle_invalid_url({ href, referrer: decoded });
+			}
 
 			actual_hashlinks.set(decoded, ids);
 
 			/** @param {string} href */
 			const removePrerenderOrigin = (href) => {
-				if (href.startsWith(config.prerender.origin)) {
-					if (href === config.prerender.origin) return '/';
-					if (href.at(config.prerender.origin.length) !== '/') return href;
-					return href.slice(config.prerender.origin.length);
+				if (href.startsWith(prerender_origin)) {
+					if (href === prerender_origin) return '/';
+					if (href.at(prerender_origin.length) !== '/') return href;
+					return href.slice(prerender_origin.length);
 				}
 				return href;
 			};
@@ -388,6 +401,12 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const type = headers['content-type'];
 		const is_html = response_type === REDIRECT || type === 'text/html';
 
+		if (!is_html && response.status === 200 && decoded.slice(config.paths.base.length + 1) === '') {
+			throw new Error(
+				`Cannot prerender a root +server.js that returns a non-HTML response - static hosts always serve an HTML file for \`${config.paths.base || '/'}\``
+			);
+		}
+
 		const file = output_filename(decoded, is_html);
 		const dest = `${config.outDir}/output/prerendered/${category}/${file}`;
 
@@ -497,10 +516,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	}
 
-	// the user's remote function modules may reference environment variables,
-	// `read` or the `manifest` at the top-level so we need to set them before
-	// evaluating those modules to avoid potential runtime errors
-	internal.set_env(env);
+	// the user's remote function modules may reference `read` or the `manifest` at the top-level
+	// so we need to set them before evaluating those modules to avoid potential runtime errors
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
 

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

@@ -1,4 +1,4 @@
-import { lookup } from 'mrmime';
+import { lookup } from '../../../utils/mime.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
@@ -29,22 +29,13 @@ export default function create_manifest_data({
 }) {
 	const assets = create_assets(config);
 	const hooks = create_hooks(config, cwd);
-	const matchers = create_matchers(config, cwd);
+	const params = resolve_params(config, cwd);
 	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
 
-	// validate matcher names used in parameterised routes
-	for (const route of routes) {
-		for (const param of route.params) {
-			if (param.matcher && !matchers[param.matcher]) {
-				throw new Error(`No matcher found for parameter '${param.matcher}' in route ${route.id}`);
-			}
-		}
-	}
-
 	return {
 		assets,
 		hooks,
-		matchers,
+		params,
 		nodes,
 		routes
 	};
@@ -82,38 +73,9 @@ function create_hooks(config, cwd) {
  * @param {import('types').ValidatedConfig} config
  * @param {string} cwd
  */
-function create_matchers(config, cwd) {
-	const params_base = path.relative(cwd, config.kit.files.params);
-
-	/** @type {Record<string, string>} */
-	const matchers = {};
-	if (fs.existsSync(config.kit.files.params)) {
-		for (const file of fs.readdirSync(config.kit.files.params)) {
-			const ext = path.extname(file);
-			if (!config.kit.moduleExtensions.includes(ext)) continue;
-			const type = file.slice(0, -ext.length);
-
-			if (/^\w+$/.test(type)) {
-				const matcher_file = path.join(params_base, file);
-
-				// Disallow same matcher with different extensions
-				if (matchers[type]) {
-					throw new Error(`Duplicate matchers: ${matcher_file} and ${matchers[type]}`);
-				} else {
-					matchers[type] = matcher_file;
-				}
-			} else {
-				// Allow for matcher test collocation
-				if (type.endsWith('.test') || type.endsWith('.spec')) continue;
-
-				throw new Error(
-					`Matcher names can only have underscores and alphanumeric characters — "${file}" is invalid`
-				);
-			}
-		}
-	}
-
-	return matchers;
+function resolve_params(config, cwd) {
+	const params_file = resolve_entry(config.kit.files.params);
+	return params_file ? posixify(path.relative(cwd, params_file)) : null;
 }
 
 /**
@@ -221,10 +183,17 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 			// We can't use withFileTypes because of a NodeJs bug which returns wrong results
 			// with isDirectory() in case of symlinks: https://github.com/nodejs/node/issues/30646
-			const files = fs.readdirSync(dir).map((name) => ({
-				is_dir: fs.statSync(path.join(dir, name)).isDirectory(),
-				name
-			}));
+			// We sort the entries because `readdirSync` order is not guaranteed and differs
+			// between runtimes (e.g. Node returns entries alphabetically, Bun in directory
+			// order). Node indices are assigned from this traversal order, so without sorting
+			// the SSR and client manifests can disagree, causing hydration mismatches.
+			const files = fs
+				.readdirSync(dir)
+				.sort()
+				.map((name) => ({
+					is_dir: fs.statSync(path.join(dir, name)).isDirectory(),
+					name
+				}));
 
 			// process files first
 			for (const file of files) {
@@ -368,7 +337,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 			const root = routes[0];
 			if (!root.leaf && !root.error && !root.layout && !root.endpoint) {
 				throw new Error(
-					'No routes found. If you are using a custom src/routes directory, make sure it is specified in your Svelte config file'
+					'No routes found. If you are using a custom src/routes directory, make sure it is specified in your SvelteKit Vite plugin options'
 				);
 			}
 		}
@@ -495,6 +464,17 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		if (route.endpoint) {
 			route.endpoint.page_options = get_page_options(route.endpoint.file, cwd);
 		}
+
+		if (route.page && route.endpoint) {
+			const page = nodes[route.page.leaf];
+			if (page.page_options?.prerender || route.endpoint.page_options?.prerender) {
+				const endpoint_file = route.endpoint.file.split('/').pop();
+
+				throw new Error(
+					`Cannot prerender a route (${route.id}) with both a \`+page.svelte\` and a \`${endpoint_file}\``
+				);
+			}
+		}
 	}
 
 	return {

package/src/core/sync/write_client_manifest.js

@@ -139,6 +139,11 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 	write_if_changed(
 		`${output}/app.js`,
 		dedent`
+			// in dev, this makes Vite inject its client as this module's first dependency,
+			// so that global constant replacements are installed before any other module
+			// (including user hooks) evaluates. In build it's inert.
+			import.meta.hot;
+
 			${
 				client_hooks_file
 					? `import * as client_hooks from '${relative_path(output, client_hooks_file)}';`
@@ -177,25 +182,20 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			export const decode = (type, value) => decoders[type](value);
 
 			export { default as root } from '../root.js';
+
+			export const get_error_template = () => import('../shared/error-template.js').then(m => m.default);
 		`
 	);
 
 	if (client_routing) {
-		// write matchers to a separate module so that we don't
-		// need to worry about name conflicts
-		const imports = [];
-		const matchers = [];
-
-		for (const key in manifest_data.matchers) {
-			const src = manifest_data.matchers[key];
-
-			imports.push(`import { match as ${key} } from ${s(relative_path(output, src))};`);
-			matchers.push(key);
-		}
+		const uses_matchers = manifest_data.routes.some((route) =>
+			route.params.some((param) => param.matcher)
+		);
 
-		const module = imports.length
-			? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
-			: 'export const matchers = {};';
+		const module =
+			!manifest_data.params || !uses_matchers
+				? 'export const matchers = {};'
+				: `import { params as matchers } from ${s(relative_path(output, manifest_data.params))};\n\nexport { matchers };`;
 
 		write_if_changed(`${output}/matchers.js`, module);
 	}