@sveltejs/kit 1.15.10 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.15.10",
+  "version": "1.16.0",
   "description": "The fastest way to build Svelte apps",
   "repository": {
     "type": "git",
@@ -36,7 +36,7 @@
     "marked": "^4.2.3",
     "rollup": "^3.7.0",
     "svelte": "^3.56.0",
-    "svelte-preprocess": "^5.0.0",
+    "svelte-preprocess": "^5.0.3",
     "typescript": "^4.9.4",
     "uvu": "^0.5.6",
     "vite": "^4.3.0"

package/src/core/config/options.js

@@ -229,6 +229,20 @@ const options = object(
 					}
 				),
 
+				handleEntryGeneratorMismatch: validate(
+					(/** @type {any} */ { message }) => {
+						throw new Error(
+							message +
+								`\nTo suppress or handle this error, implement \`handleEntryGeneratorMismatch\` in https://kit.svelte.dev/docs/configuration#prerender`
+						);
+					},
+					(input, keypath) => {
+						if (typeof input === 'function') return input;
+						if (['fail', 'warn', 'ignore'].includes(input)) return input;
+						throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
+					}
+				),
+
 				origin: validate('http://sveltekit-prerender', (input, keypath) => {
 					assert_string(input, keypath);
 

package/src/core/generate_manifest/index.js

@@ -43,17 +43,6 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 		})
 	);
 
-	/** @typedef {{ index: number, path: string }} LookupEntry */
-	/** @type {Map<import('types').PageNode, LookupEntry>} */
-	const bundled_nodes = new Map();
-
-	build_data.manifest_data.nodes.forEach((node, i) => {
-		bundled_nodes.set(node, {
-			path: join_relative(relative_path, `/nodes/${i}.js`),
-			index: i
-		});
-	});
-
 	/** @type {(path: string) => string} */
 	const loader = (path) => `() => import('${path}')`;
 
@@ -68,14 +57,10 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 	function get_nodes(indexes) {
 		let string = indexes.map((n) => reindexed.get(n) ?? '').join(',');
 
-		if (indexes.at(-1) === undefined) {
-			// since JavaScript ignores trailing commas, we need to insert a dummy
-			// comma so that the array has the correct length if the last item
-			// is undefined
-			string += ',';
-		}
-
-		return `[${string}]`;
+		// since JavaScript ignores trailing commas, we need to insert a dummy
+		// comma so that the array has the correct length if the last item
+		// is undefined
+		return `[${string},]`;
 	}
 
 	// prettier-ignore
@@ -94,12 +79,12 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 				],
 				routes: [
 					${routes.map(route => {
+						if (!route.page && !route.endpoint) return;
+						
 						route.params.forEach(param => {
 							if (param.matcher) matchers.add(param.matcher);
 						});
 
-						if (!route.page && !route.endpoint) return;
-
 						return dedent`
 							{
 								id: ${s(route.id)},

package/src/core/postbuild/analyse.js

@@ -2,7 +2,9 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { get_option } from '../../utils/options.js';
 import {
-	validate_common_exports,
+	validate_layout_exports,
+	validate_layout_server_exports,
+	validate_page_exports,
 	validate_page_server_exports,
 	validate_server_exports
 } from '../../utils/exports.js';
@@ -10,6 +12,7 @@ import { load_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
 import { should_polyfill } from '../../utils/platform.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
+import { resolve_entry } from '../../utils/routing.js';
 
 export default forked(import.meta.url, analyse);
 
@@ -72,6 +75,8 @@ async function analyse({ manifest_path, env }) {
 		let prerender = undefined;
 		/** @type {any} */
 		let config = undefined;
+		/** @type {import('types').PrerenderEntryGenerator | undefined} */
+		let entries = undefined;
 
 		if (route.endpoint) {
 			const mod = await route.endpoint();
@@ -95,6 +100,7 @@ async function analyse({ manifest_path, env }) {
 			if (mod.OPTIONS) api_methods.push('OPTIONS');
 
 			config = mod.config;
+			entries = mod.entries;
 		}
 
 		if (route.page) {
@@ -109,8 +115,8 @@ async function analyse({ manifest_path, env }) {
 
 			for (const layout of layouts) {
 				if (layout) {
-					validate_common_exports(layout.server, layout.server_id);
-					validate_common_exports(layout.universal, layout.universal_id);
+					validate_layout_server_exports(layout.server, layout.server_id);
+					validate_layout_exports(layout.universal, layout.universal_id);
 				}
 			}
 
@@ -119,12 +125,13 @@ async function analyse({ manifest_path, env }) {
 				if (page.server?.actions) page_methods.push('POST');
 
 				validate_page_server_exports(page.server, page.server_id);
-				validate_common_exports(page.universal, page.universal_id);
+				validate_page_exports(page.universal, page.universal_id);
 			}
 
 			prerender = get_option(nodes, 'prerender') ?? false;
 
 			config = get_config(nodes);
+			entries ??= get_option(nodes, 'entries');
 		}
 
 		metadata.routes.set(route.id, {
@@ -136,7 +143,9 @@ async function analyse({ manifest_path, env }) {
 			api: {
 				methods: api_methods
 			},
-			prerender
+			prerender,
+			entries:
+				entries && (await entries()).map((entry_object) => resolve_entry(route.id, entry_object))
 		});
 	}
 

package/src/core/postbuild/prerender.js

@@ -127,6 +127,14 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		}
 	);
 
+	const handle_entry_generator_mismatch = normalise_error_handler(
+		log,
+		config.prerender.handleEntryGeneratorMismatch,
+		({ generatedFromId, entry, matchedId }) => {
+			return `The entries export from ${generatedFromId} generated entry ${entry}, which was matched by ${matchedId} - see the \`handleEntryGeneratorMismatch\` option in https://kit.svelte.dev/docs/configuration#prerender for more info.`;
+		}
+	);
+
 	const q = queue(config.prerender.concurrency);
 
 	/**
@@ -164,23 +172,25 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 	 * @param {string | null} referrer
 	 * @param {string} decoded
 	 * @param {string} [encoded]
+	 * @param {string} [generated_from_id]
 	 */
-	function enqueue(referrer, decoded, encoded) {
+	function enqueue(referrer, decoded, encoded, generated_from_id) {
 		if (seen.has(decoded)) return;
 		seen.add(decoded);
 
 		const file = decoded.slice(config.paths.base.length + 1);
 		if (files.has(file)) return;
 
-		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer));
+		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer, generated_from_id));
 	}
 
 	/**
 	 * @param {string} decoded
 	 * @param {string} encoded
 	 * @param {string?} referrer
+	 * @param {string} [generated_from_id]
 	 */
-	async function visit(decoded, encoded, referrer) {
+	async function visit(decoded, encoded, referrer, generated_from_id) {
 		if (!decoded.startsWith(config.paths.base)) {
 			handle_http_error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
 			return;
@@ -206,6 +216,20 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 			}
 		});
 
+		const encoded_id = response.headers.get('x-sveltekit-routeid');
+		const decoded_id = encoded_id && decode_uri(encoded_id);
+		if (
+			decoded_id !== null &&
+			generated_from_id !== undefined &&
+			decoded_id !== generated_from_id
+		) {
+			handle_entry_generator_mismatch({
+				generatedFromId: generated_from_id,
+				entry: decoded,
+				matchedId: decoded_id
+			});
+		}
+
 		const body = Buffer.from(await response.arrayBuffer());
 
 		save('pages', response, body, decoded, encoded, referrer, 'linked');
@@ -378,9 +402,18 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		saved.set(file, dest);
 	}
 
+	/** @type {Array<{ id: string, entries: Array<string>}>} */
+	const route_level_entries = [];
+	for (const [id, { entries }] of metadata.routes.entries()) {
+		if (entries) {
+			route_level_entries.push({ id, entries });
+		}
+	}
+
 	if (
 		config.prerender.entries.length > 1 ||
 		config.prerender.entries[0] !== '*' ||
+		route_level_entries.length > 0 ||
 		prerender_map.size > 0
 	) {
 		// Only log if we're actually going to do something to not confuse users
@@ -401,6 +434,12 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		}
 	}
 
+	for (const { id, entries } of route_level_entries) {
+		for (const entry of entries) {
+			enqueue(null, config.paths.base + entry, undefined, id);
+		}
+	}
+
 	await q.done();
 
 	// handle invalid fragment links

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

@@ -194,6 +194,12 @@ function update_types(config, routes, route, to_delete = new Set()) {
 			.join('; ')} }`
 	);
 
+	if (route.params.length > 0) {
+		exports.push(
+			`export type EntryGenerator = () => Promise<Array<RouteParams>> | Array<RouteParams>;`
+		);
+	}
+
 	declarations.push(`type RouteId = '${route.id}';`);
 
 	// These could also be placed in our public types, but it would bloat them unnecessarily and we may want to change these in the future

package/src/exports/hooks/sequence.js

@@ -21,7 +21,7 @@ export function sequence(...handlers) {
 			return handle({
 				event,
 				resolve: (event, options) => {
-					/** @param {{ html: string, done: boolean }} opts */
+					/** @type {import('types').ResolveOptions['transformPageChunk']} */
 					const transformPageChunk = async ({ html, done }) => {
 						if (options?.transformPageChunk) {
 							html = (await options.transformPageChunk({ html, done })) ?? '';
@@ -34,9 +34,21 @@ export function sequence(...handlers) {
 						return html;
 					};
 
+					/** @type {import('types').ResolveOptions['filterSerializedResponseHeaders']} */
+					const filterSerializedResponseHeaders =
+						parent_options?.filterSerializedResponseHeaders ??
+						options?.filterSerializedResponseHeaders;
+
+					/** @type {import('types').ResolveOptions['preload']} */
+					const preload = parent_options?.preload ?? options?.preload;
+
 					return i < length - 1
-						? apply_handle(i + 1, event, { transformPageChunk })
-						: resolve(event, { transformPageChunk });
+						? apply_handle(i + 1, event, {
+								transformPageChunk,
+								filterSerializedResponseHeaders,
+								preload
+						  })
+						: resolve(event, { transformPageChunk, filterSerializedResponseHeaders, preload });
 				}
 			});
 		}

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

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import { mkdirp } from '../../../utils/filesystem.js';
 import { find_deps, resolve_symlinks } from './utils.js';
 import { s } from '../../../utils/misc.js';
+import { normalizePath } from 'vite';
 
 /**
  * @param {string} out
@@ -48,12 +49,6 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 		const fonts = [];
 
 		if (node.component && client_manifest) {
-			const entry = find_deps(client_manifest, node.component, true);
-
-			imported.push(...entry.imports);
-			stylesheets.push(...entry.stylesheets);
-			fonts.push(...entry.fonts);
-
 			exports.push(
 				`export const component = async () => (await import('../${
 					resolve_symlinks(server_manifest, node.component).chunk.file
@@ -62,14 +57,6 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 		}
 
 		if (node.universal) {
-			if (client_manifest) {
-				const entry = find_deps(client_manifest, node.universal, true);
-
-				imported.push(...entry.imports);
-				stylesheets.push(...entry.stylesheets);
-				fonts.push(...entry.fonts);
-			}
-
 			imports.push(`import * as universal from '../${server_manifest[node.universal].file}';`);
 			exports.push(`export { universal };`);
 			exports.push(`export const universal_id = ${s(node.universal)};`);
@@ -81,6 +68,18 @@ export function build_server_nodes(out, kit, manifest_data, server_manifest, cli
 			exports.push(`export const server_id = ${s(node.server)};`);
 		}
 
+		if (client_manifest && (node.universal || node.component)) {
+			const entry = find_deps(
+				client_manifest,
+				`${normalizePath(kit.outDir)}/generated/client-optimized/nodes/${i}.js`,
+				true
+			);
+
+			imported.push(...entry.imports);
+			stylesheets.push(...entry.stylesheets);
+			fonts.push(...entry.fonts);
+		}
+
 		exports.push(
 			`export const imports = ${s(imported)};`,
 			`export const stylesheets = ${s(stylesheets)};`,

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

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { normalizePath } from 'vite';
 
 /**
  * Adds transitive JS and CSS dependencies to the js and css inputs.
@@ -72,7 +73,7 @@ export function find_deps(manifest, entry, add_dynamic_css) {
  */
 export function resolve_symlinks(manifest, file) {
 	while (!manifest[file]) {
-		const next = path.relative('.', fs.realpathSync(file));
+		const next = normalizePath(path.relative('.', fs.realpathSync(file)));
 		if (next === file) throw new Error(`Could not find file "${file}" in Vite manifest`);
 		file = next;
 	}

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

@@ -116,7 +116,7 @@ export async function dev(vite, vite_config, svelte_config) {
 			_: {
 				client: {
 					start: `${runtime_base}/client/start.js`,
-					app: `${svelte_config.kit.outDir}/generated/client/app.js`,
+					app: `${to_fs(svelte_config.kit.outDir)}/generated/client/app.js`,
 					imports: [],
 					stylesheets: [],
 					fonts: []

package/src/exports/vite/index.js

@@ -525,27 +525,6 @@ function kit({ svelte_config }) {
 				} else {
 					input['entry/start'] = `${runtime_directory}/client/start.js`;
 					input['entry/app'] = `${kit.outDir}/generated/client-optimized/app.js`;
-
-					/**
-					 * @param {string | undefined} file
-					 */
-					function add_input(file) {
-						if (!file) return;
-
-						const resolved = path.resolve(file);
-						const relative = decodeURIComponent(path.relative(kit.files.routes, resolved));
-
-						const name = relative.startsWith('..')
-							? path.basename(file).replace(/^\+/, '')
-							: relative.replace(/(\\|\/)\+/g, '-').replace(/[\\/]/g, '-');
-
-						input[`entry/${name}`] = resolved;
-					}
-
-					for (const node of manifest_data.nodes) {
-						add_input(node.component);
-						add_input(node.universal);
-					}
 				}
 
 				// see the kit.output.preloadStrategy option for details on why we have multiple options here

package/src/runtime/app/forms.js

@@ -1,19 +1,9 @@
 import * as devalue from 'devalue';
-import { client } from '../client/singletons.js';
+import { DEV } from 'esm-env';
+import { client_method } from '../client/singletons.js';
 import { invalidateAll } from './navigation.js';
-import { BROWSER, DEV } from 'esm-env';
-
-/**
- * @param {string} name
- */
-function guard(name) {
-	return () => {
-		throw new Error(`Cannot call ${name}(...) on the server`);
-	};
-}
 
-/** @type {import('$app/forms').applyAction} */
-export const applyAction = BROWSER ? client.apply_action : guard('applyAction');
+export const applyAction = client_method('apply_action');
 
 /** @type {import('$app/forms').deserialize} */
 export function deserialize(result) {

package/src/runtime/app/navigation.js

@@ -1,22 +1,17 @@
-import { BROWSER } from 'esm-env';
-import { client } from '../client/singletons.js';
-
-/**
- * @param {string} name
- */
-function guard(name) {
-	return () => {
-		throw new Error(`Cannot call ${name}(...) on the server`);
-	};
-}
-
-export const disableScrollHandling = BROWSER
-	? client.disable_scroll_handling
-	: guard('disableScrollHandling');
-export const goto = BROWSER ? client.goto : guard('goto');
-export const invalidate = BROWSER ? client.invalidate : guard('invalidate');
-export const invalidateAll = BROWSER ? client.invalidateAll : guard('invalidateAll');
-export const preloadData = BROWSER ? client.preload_data : guard('preloadData');
-export const preloadCode = BROWSER ? client.preload_code : guard('preloadCode');
-export const beforeNavigate = BROWSER ? client.before_navigate : () => {};
-export const afterNavigate = BROWSER ? client.after_navigate : () => {};
+import { client_method } from '../client/singletons.js';
+
+export const disableScrollHandling = /* @__PURE__ */ client_method('disable_scroll_handling');
+
+export const goto = /* @__PURE__ */ client_method('goto');
+
+export const invalidate = /* @__PURE__ */ client_method('invalidate');
+
+export const invalidateAll = /* @__PURE__ */ client_method('invalidate_all');
+
+export const preloadData = /* @__PURE__ */ client_method('preload_data');
+
+export const preloadCode = /* @__PURE__ */ client_method('preload_code');
+
+export const beforeNavigate = /* @__PURE__ */ client_method('before_navigate');
+
+export const afterNavigate = /* @__PURE__ */ client_method('after_navigate');

package/src/runtime/client/client.js

@@ -31,9 +31,9 @@ import { stores } from './singletons.js';
 import { unwrap_promises } from '../../utils/promises.js';
 import * as devalue from 'devalue';
 import { INDEX_KEY, PRELOAD_PRIORITIES, SCROLL_KEY, SNAPSHOT_KEY } from './constants.js';
-import { validate_common_exports } from '../../utils/exports.js';
+import { validate_page_exports } from '../../utils/exports.js';
 import { compact } from '../../utils/array.js';
-import { validate_depends } from '../shared.js';
+import { INVALIDATED_PARAM, validate_depends } from '../shared.js';
 
 let errored = false;
 
@@ -428,7 +428,7 @@ export function create_client(app, target) {
 		const node = await loader();
 
 		if (DEV) {
-			validate_common_exports(node.universal);
+			validate_page_exports(node.universal);
 		}
 
 		if (node.universal?.load) {
@@ -1354,7 +1354,7 @@ export function create_client(app, target) {
 			return invalidate();
 		},
 
-		invalidateAll: () => {
+		invalidate_all: () => {
 			force_invalidation = true;
 			return invalidate();
 		},
@@ -1775,13 +1775,10 @@ export function create_client(app, target) {
 async function load_data(url, invalid) {
 	const data_url = new URL(url);
 	data_url.pathname = add_data_suffix(url.pathname);
-	if (DEV && url.searchParams.has('x-sveltekit-invalidated')) {
-		throw new Error('Cannot used reserved query parameter "x-sveltekit-invalidated"');
+	if (DEV && url.searchParams.has(INVALIDATED_PARAM)) {
+		throw new Error(`Cannot used reserved query parameter "${INVALIDATED_PARAM}"`);
 	}
-	data_url.searchParams.append(
-		'x-sveltekit-invalidated',
-		invalid.map((x) => (x ? '1' : '')).join('_')
-	);
+	data_url.searchParams.append(INVALIDATED_PARAM, invalid.map((i) => (i ? '1' : '0')).join(''));
 
 	const res = await native_fetch(data_url.href);
 

package/src/runtime/client/singletons.js

@@ -1,5 +1,6 @@
 import { writable } from 'svelte/store';
 import { create_updated_store, notifiable_store } from './utils.js';
+import { BROWSER } from 'esm-env';
 
 /** @type {import('./types').Client} */
 export let client;
@@ -13,6 +14,35 @@ export function init(opts) {
 	client = opts.client;
 }
 
+/**
+ * @template {keyof typeof client} T
+ * @param {T} key
+ * @returns {typeof client[T]}
+ */
+export function client_method(key) {
+	if (!BROWSER) {
+		if (key === 'before_navigate' || key === 'after_navigate') {
+			// @ts-expect-error doesn't recognize that both keys here return void so expects a async function
+			return () => {};
+		} else {
+			/** @type {Record<string, string>} */
+			const name_lookup = {
+				disable_scroll_handling: 'disableScrollHandling',
+				preload_data: 'preloadData',
+				preload_code: 'preloadCode',
+				invalidate_all: 'invalidateAll'
+			};
+
+			return () => {
+				throw new Error(`Cannot call ${name_lookup[key] ?? key}(...) on the server`);
+			};
+		}
+	} else {
+		// @ts-expect-error
+		return (...args) => client[key](...args);
+	}
+}
+
 export const stores = {
 	url: notifiable_store({}),
 	page: notifiable_store({}),

package/src/runtime/client/types.d.ts

@@ -54,7 +54,7 @@ export interface Client {
 	disable_scroll_handling(): void;
 	goto: typeof goto;
 	invalidate: typeof invalidate;
-	invalidateAll: typeof invalidateAll;
+	invalidate_all: typeof invalidateAll;
 	preload_code: typeof preloadCode;
 	preload_data: typeof preloadData;
 	apply_action: typeof applyAction;

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

@@ -8,8 +8,6 @@ import { text } from '../../../exports/index.js';
 import * as devalue from 'devalue';
 import { create_async_iterator } from '../../../utils/streaming.js';
 
-export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';
-
 const encoder = new TextEncoder();
 
 /**

package/src/runtime/server/fetch.js

@@ -16,8 +16,6 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 	return async (info, init) => {
 		const original_request = normalize_fetch_input(info, init, event.url);
 
-		const request_body = init?.body;
-
 		// some runtimes (e.g. Cloudflare) error if you access `request.mode`,
 		// annoyingly, so we need to read the value from the `init` object instead
 		let mode = (info instanceof Request ? info.mode : init?.mode) ?? 'cors';
@@ -111,15 +109,6 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					}
 				}
 
-				if (request_body && typeof request_body !== 'string' && !ArrayBuffer.isView(request_body)) {
-					// TODO is this still necessary? we just bail out below
-					// per https://developer.mozilla.org/en-US/docs/Web/API/Request/Request, this can be a
-					// Blob, BufferSource, FormData, URLSearchParams, USVString, or ReadableStream object.
-					// non-string bodies are irksome to deal with, but luckily aren't particularly useful
-					// in this context anyway, so we take the easy route and ban them
-					throw new Error('Request body must be a string or TypedArray');
-				}
-
 				if (!request.headers.has('accept')) {
 					request.headers.set('accept', '*/*');
 				}

package/src/runtime/server/respond.js

@@ -15,18 +15,21 @@ import {
 	strip_data_suffix
 } from '../../utils/url.js';
 import { exec } from '../../utils/routing.js';
-import { INVALIDATED_PARAM, redirect_json_response, render_data } from './data/index.js';
+import { redirect_json_response, render_data } from './data/index.js';
 import { add_cookies_to_headers, get_cookies } from './cookie.js';
 import { create_fetch } from './fetch.js';
 import { Redirect } from '../control.js';
 import {
-	validate_common_exports,
+	validate_layout_exports,
+	validate_layout_server_exports,
+	validate_page_exports,
 	validate_page_server_exports,
 	validate_server_exports
 } from '../../utils/exports.js';
 import { get_option } from '../../utils/options.js';
 import { error, json, text } from '../../exports/index.js';
 import { action_json_redirect, is_action_json_request } from './page/actions.js';
+import { INVALIDATED_PARAM } from '../shared.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
@@ -94,7 +97,10 @@ export async function respond(request, options, manifest, state) {
 	if (is_data_request) {
 		decoded = strip_data_suffix(decoded) || '/';
 		url.pathname = strip_data_suffix(url.pathname) || '/';
-		invalidated_data_nodes = url.searchParams.get(INVALIDATED_PARAM)?.split('_').map(Boolean);
+		invalidated_data_nodes = url.searchParams
+			.get(INVALIDATED_PARAM)
+			?.split('')
+			.map((node) => node === '1');
 		url.searchParams.delete(INVALIDATED_PARAM);
 	}
 
@@ -193,8 +199,11 @@ export async function respond(request, options, manifest, state) {
 
 					for (const layout of layouts) {
 						if (layout) {
-							validate_common_exports(layout.server, /** @type {string} */ (layout.server_id));
-							validate_common_exports(
+							validate_layout_server_exports(
+								layout.server,
+								/** @type {string} */ (layout.server_id)
+							);
+							validate_layout_exports(
 								layout.universal,
 								/** @type {string} */ (layout.universal_id)
 							);
@@ -203,7 +212,7 @@ export async function respond(request, options, manifest, state) {
 
 					if (page) {
 						validate_page_server_exports(page.server, /** @type {string} */ (page.server_id));
-						validate_common_exports(page.universal, /** @type {string} */ (page.universal_id));
+						validate_page_exports(page.universal, /** @type {string} */ (page.universal_id));
 					}
 				}
 

package/src/runtime/shared.js

@@ -10,3 +10,5 @@ export function validate_depends(route_id, dep) {
 		);
 	}
 }
+
+export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';

package/src/utils/exports.js

@@ -1,9 +1,7 @@
 /**
- * @param {string[]} expected
+ * @param {Set<string>} expected
  */
 function validator(expected) {
-	const set = new Set(expected);
-
 	/**
 	 * @param {any} module
 	 * @param {string} [file]
@@ -12,11 +10,13 @@ function validator(expected) {
 		if (!module) return;
 
 		for (const key in module) {
-			if (key[0] === '_' || set.has(key)) continue; // key is valid in this module
+			if (key[0] === '_' || expected.has(key)) continue; // key is valid in this module
+
+			const values = [...expected.values()];
 
 			const hint =
 				hint_for_supported_files(key, file?.slice(file.lastIndexOf('.'))) ??
-				`valid exports are ${expected.join(', ')}, or anything with a '_' prefix`;
+				`valid exports are ${values.join(', ')}, or anything with a '_' prefix`;
 
 			throw new Error(`Invalid export '${key}'${file ? ` in ${file}` : ''} (${hint})`);
 		}
@@ -33,34 +33,45 @@ function validator(expected) {
 function hint_for_supported_files(key, ext = '.js') {
 	let supported_files = [];
 
-	if (valid_common_exports.includes(key)) {
+	if (valid_layout_exports.has(key)) {
+		supported_files.push(`+layout${ext}`);
+	}
+
+	if (valid_page_exports.has(key)) {
 		supported_files.push(`+page${ext}`);
 	}
 
-	if (valid_page_server_exports.includes(key)) {
+	if (valid_layout_server_exports.has(key)) {
+		supported_files.push(`+layout.server${ext}`);
+	}
+
+	if (valid_page_server_exports.has(key)) {
 		supported_files.push(`+page.server${ext}`);
 	}
 
-	if (valid_server_exports.includes(key)) {
+	if (valid_server_exports.has(key)) {
 		supported_files.push(`+server${ext}`);
 	}
 
 	if (supported_files.length > 0) {
-		return `'${key}' is a valid export in ${supported_files.join(` or `)}`;
+		return `'${key}' is a valid export in ${supported_files.slice(0, -1).join(`, `)}${
+			supported_files.length > 1 ? ' or ' : ''
+		}${supported_files.at(-1)}`;
 	}
 }
 
-const valid_common_exports = ['load', 'prerender', 'csr', 'ssr', 'trailingSlash', 'config'];
-const valid_page_server_exports = [
+const valid_layout_exports = new Set([
 	'load',
 	'prerender',
 	'csr',
 	'ssr',
-	'actions',
 	'trailingSlash',
 	'config'
-];
-const valid_server_exports = [
+]);
+const valid_page_exports = new Set([...valid_layout_exports, 'entries']);
+const valid_layout_server_exports = new Set([...valid_layout_exports, 'actions']);
+const valid_page_server_exports = new Set([...valid_layout_server_exports, 'entries']);
+const valid_server_exports = new Set([
 	'GET',
 	'POST',
 	'PATCH',
@@ -69,9 +80,12 @@ const valid_server_exports = [
 	'OPTIONS',
 	'prerender',
 	'trailingSlash',
-	'config'
-];
+	'config',
+	'entries'
+]);
 
-export const validate_common_exports = validator(valid_common_exports);
+export const validate_layout_exports = validator(valid_layout_exports);
+export const validate_page_exports = validator(valid_page_exports);
+export const validate_layout_server_exports = validator(valid_layout_server_exports);
 export const validate_page_server_exports = validator(valid_page_server_exports);
 export const validate_server_exports = validator(valid_server_exports);

package/src/utils/options.js

@@ -1,6 +1,6 @@
 /**
- * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash'} Option
- * @template {Option extends 'prerender' ? import('types').PrerenderOption : Option extends 'trailingSlash' ? import('types').TrailingSlash : boolean} Value
+ * @template {'prerender' | 'ssr' | 'csr' | 'trailingSlash' | 'entries'} Option
+ * @template {(import('types').SSRNode['universal'] | import('types').SSRNode['server'])[Option]} Value
  *
  * @param {Array<import('types').SSRNode | undefined>} nodes
  * @param {Option} option
@@ -9,7 +9,7 @@
  */
 export function get_option(nodes, option) {
 	return nodes.reduce((value, node) => {
-		return /** @type {any} TypeScript's too dumb to understand this */ (
+		return /** @type {Value} TypeScript's too dumb to understand this */ (
 			node?.universal?.[option] ?? node?.server?.[option] ?? value
 		);
 	}, /** @type {Value | undefined} */ (undefined));

package/src/utils/routing.js

@@ -96,6 +96,61 @@ export function parse_route_id(id) {
 	return { pattern, params };
 }
 
+const basic_param_pattern = /\[(\[)?(?:\.\.\.)?(\w+?)(?:=(\w+))?\]\]?/;
+
+/**
+ * Parses a route ID, then resolves it to a path by replacing parameters with actual values from `entry`.
+ * @param {string} id The route id
+ * @param {Record<string, string | undefined>} entry The entry meant to populate the route. For example, if the route is `/blog/[slug]`, the entry would be `{ slug: 'hello-world' }`
+ * @example
+ * ```js
+ * resolve_entry(`/blog/[slug]/[...somethingElse]`, { slug: 'hello-world', somethingElse: 'something/else' }); // `/blog/hello-world/something/else`
+ * ```
+ */
+export function resolve_entry(id, entry) {
+	const segments = get_route_segments(id);
+	return (
+		'/' +
+		segments
+			.map((segment) => {
+				const match = basic_param_pattern.exec(segment);
+
+				// static content -- i.e. not a param
+				if (!match) return segment;
+
+				const optional = !!match[1];
+				const name = match[2];
+				const param_value = entry[name];
+
+				// This is nested so TS correctly narrows the type
+				if (!param_value) {
+					if (optional) return '';
+					throw new Error(`Missing parameter '${name}' in route ${id}`);
+				}
+
+				if (param_value.startsWith('/') || param_value.endsWith('/'))
+					throw new Error(
+						`Parameter '${name}' in route ${id} cannot start or end with a slash -- this would cause an invalid route like foo//bar`
+					);
+
+				return param_value;
+			})
+			.filter(Boolean)
+			.join('/')
+	);
+}
+
+const optional_param_regex = /\/\[\[\w+?(?:=\w+)?\]\]/;
+
+/**
+ * Removes optional params from a route ID.
+ * @param {string} id
+ * @returns The route id with optional params removed
+ */
+export function remove_optional_params(id) {
+	return id.replace(optional_param_regex, '');
+}
+
 /**
  * Returns `false` for `(group)` segments
  * @param {string} segment

package/types/ambient.d.ts

@@ -359,6 +359,10 @@ declare module '@sveltejs/kit/hooks' {
 
 	/**
 	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+	 * The behavior for the `handle` options is as follows:
+	 * - `transformPageChunk` is applied in reverse order and merged
+	 * - `preload` is applied in forward order, the first option "wins" and no `preload` options after it are called
+	 * - `filterSerializedResponseHeaders` behaves the same as `preload`
 	 *
 	 * ```js
 	 * /// file: src/hooks.server.js
@@ -372,6 +376,10 @@ declare module '@sveltejs/kit/hooks' {
 	 * 			// transforms are applied in reverse order
 	 * 			console.log('first transform');
 	 * 			return html;
+	 * 		},
+	 * 		preload: () => {
+	 * 			// this one wins as it's the first defined in the chain
+	 * 			console.log('first preload');
 	 * 		}
 	 * 	});
 	 * 	console.log('first post-processing');
@@ -385,6 +393,13 @@ declare module '@sveltejs/kit/hooks' {
 	 * 		transformPageChunk: ({ html }) => {
 	 * 			console.log('second transform');
 	 * 			return html;
+	 * 		},
+	 * 		preload: () => {
+	 * 			console.log('second preload');
+	 * 		},
+	 * 		filterSerializedResponseHeaders: () => {
+	 * 			// this one wins as it's the first defined in the chain
+	 *    		console.log('second filterSerializedResponseHeaders');
 	 * 		}
 	 * 	});
 	 * 	console.log('second post-processing');
@@ -398,7 +413,9 @@ declare module '@sveltejs/kit/hooks' {
 	 *
 	 * ```
 	 * first pre-processing
+	 * first preload
 	 * second pre-processing
+	 * second filterSerializedResponseHeaders
 	 * second transform
 	 * first transform
 	 * second post-processing

package/types/index.d.ts

@@ -11,6 +11,7 @@ import {
 	Logger,
 	MaybePromise,
 	Prerendered,
+	PrerenderEntryGeneratorMismatchHandlerValue,
 	PrerenderHttpErrorHandlerValue,
 	PrerenderMissingIdHandlerValue,
 	PrerenderOption,
@@ -515,7 +516,7 @@ export interface KitConfig {
 		 */
 		handleHttpError?: PrerenderHttpErrorHandlerValue;
 		/**
-		 * How to respond to hash links from one prerendered page to another that don't correspond to an `id` on the destination page
+		 * How to respond when hash links from one prerendered page to another don't correspond to an `id` on the destination page.
 		 *
 		 * - `'fail'` — fail the build
 		 * - `'ignore'` - silently ignore the failure and continue
@@ -525,6 +526,17 @@ export interface KitConfig {
 		 * @default "fail"
 		 */
 		handleMissingId?: PrerenderMissingIdHandlerValue;
+		/**
+		 * How to respond when an entry generated by the `entries` export doesn't match the route it was generated from.
+		 *
+		 * - `'fail'` — fail the build
+		 * - `'ignore'` - silently ignore the failure and continue
+		 * - `'warn'` — continue, but print a warning
+		 * - `(details) => void` — a custom error handler that takes a `details` object with `generatedFromId`, `entry`, `matchedId` and `message` properties. If you `throw` from this function, the build will fail
+		 *
+		 * @default "fail"
+		 */
+		handleEntryGeneratorMismatch?: PrerenderEntryGeneratorMismatchHandlerValue;
 		/**
 		 * The value of `url.origin` during prerendering; useful if it is included in rendered content.
 		 * @default "http://sveltekit-prerender"
@@ -557,16 +569,16 @@ export interface KitConfig {
 	 * If SvelteKit encounters an error while loading the page and detects that a new version has been deployed (using the `name` specified here, which defaults to a timestamp of the build) it will fall back to traditional full-page navigation.
 	 * Not all navigations will result in an error though, for example if the JavaScript for the next page is already loaded. If you still want to force a full-page navigation in these cases, use techniques such as setting the `pollInterval` and then using `beforeNavigate`:
 	 * ```html
-	 * /// +layout.svelte
+	 * /// file: +layout.svelte
 	 * <script>
-	 * import { beforeNavigate } from '$app/navigation';
-	 * import { updated } from '$app/stores';
+	 *   import { beforeNavigate } from '$app/navigation';
+	 *   import { updated } from '$app/stores';
 	 *
-	 * beforeNavigate(({ willUnload, to }) => {
-	 *   if ($updated && !willUnload && to?.url) {
-	 *     location.href = to.url.href;
-	 *   }
-	 * });
+	 *   beforeNavigate(({ willUnload, to }) => {
+	 *     if ($updated && !willUnload && to?.url) {
+	 *       location.href = to.url.href;
+	 *     }
+	 *   });
 	 * </script>
 	 * ```
 	 *

package/types/internal.d.ts

@@ -266,6 +266,7 @@ export interface ServerMetadataRoute {
 	};
 	methods: HttpMethod[];
 	prerender: PrerenderOption | undefined;
+	entries: Array<string> | undefined;
 }
 
 export interface ServerMetadata {
@@ -308,6 +309,7 @@ export interface SSRNode {
 		csr?: boolean;
 		trailingSlash?: TrailingSlash;
 		config?: any;
+		entries?: PrerenderEntryGenerator;
 	};
 
 	server: {
@@ -318,6 +320,7 @@ export interface SSRNode {
 		trailingSlash?: TrailingSlash;
 		actions?: Actions;
 		config?: any;
+		entries?: PrerenderEntryGenerator;
 	};
 
 	universal_id: string;
@@ -355,10 +358,13 @@ export interface PageNodeIndexes {
 	leaf: number;
 }
 
+export type PrerenderEntryGenerator = () => MaybePromise<Array<Record<string, string>>>;
+
 export type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>> & {
 	prerender?: PrerenderOption;
 	trailingSlash?: TrailingSlash;
 	config?: any;
+	entries?: PrerenderEntryGenerator;
 };
 
 export interface SSRRoute {

package/types/private.d.ts

@@ -205,8 +205,17 @@ export interface PrerenderMissingIdHandler {
 	(details: { path: string; id: string; referrers: string[]; message: string }): void;
 }
 
+export interface PrerenderEntryGeneratorMismatchHandler {
+	(details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void;
+}
+
 export type PrerenderHttpErrorHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler;
 export type PrerenderMissingIdHandlerValue = 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler;
+export type PrerenderEntryGeneratorMismatchHandlerValue =
+	| 'fail'
+	| 'warn'
+	| 'ignore'
+	| PrerenderEntryGeneratorMismatchHandler;
 
 export type PrerenderOption = boolean | 'auto';