@sveltejs/kit 1.4.0 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -22,7 +22,7 @@
     "set-cookie-parser": "^2.5.1",
     "sirv": "^2.0.2",
     "tiny-glob": "^0.2.9",
-    "undici": "5.16.0"
+    "undici": "5.18.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.29.2",

package/src/core/adapt/builder.js

@@ -18,13 +18,54 @@ const pipe = promisify(pipeline);
  *   config: import('types').ValidatedConfig;
  *   build_data: import('types').BuildData;
  *   server_metadata: import('types').ServerMetadata;
- *   routes: import('types').RouteData[];
+ *   route_data: import('types').RouteData[];
  *   prerendered: import('types').Prerendered;
+ *   prerender_map: import('types').PrerenderMap;
  *   log: import('types').Logger;
  * }} opts
  * @returns {import('types').Builder}
  */
-export function create_builder({ config, build_data, server_metadata, routes, prerendered, log }) {
+export function create_builder({
+	config,
+	build_data,
+	server_metadata,
+	route_data,
+	prerendered,
+	prerender_map,
+	log
+}) {
+	/** @type {Map<import('types').RouteDefinition, import('types').RouteData>} */
+	const lookup = new Map();
+
+	/**
+	 * Rather than exposing the internal `RouteData` type, which is subject to change,
+	 * we expose a stable type that adapters can use to group/filter routes
+	 */
+	const routes = route_data.map((route) => {
+		const methods =
+			/** @type {import('types').HttpMethod[]} */
+			(server_metadata.routes.get(route.id)?.methods);
+		const config = server_metadata.routes.get(route.id)?.config;
+
+		/** @type {import('types').RouteDefinition} */
+		const facade = {
+			id: route.id,
+			segments: get_route_segments(route.id).map((segment) => ({
+				dynamic: segment.includes('['),
+				rest: segment.includes('[...'),
+				content: segment
+			})),
+			pattern: route.pattern,
+			prerender: prerender_map.get(route.id) ?? false,
+			methods,
+			config
+		};
+
+		lookup.set(facade, route);
+
+		return facade;
+	});
+
 	return {
 		log,
 		rimraf,
@@ -33,6 +74,7 @@ export function create_builder({ config, build_data, server_metadata, routes, pr
 
 		config,
 		prerendered,
+		routes,
 
 		async compress(directory) {
 			if (!existsSync(directory)) {
@@ -52,29 +94,12 @@ export function create_builder({ config, build_data, server_metadata, routes, pr
 		},
 
 		async createEntries(fn) {
-			/** @type {import('types').RouteDefinition[]} */
-			const facades = routes.map((route) => {
-				const methods =
-					/** @type {import('types').HttpMethod[]} */
-					(server_metadata.routes.get(route.id)?.methods);
-
-				return {
-					id: route.id,
-					segments: get_route_segments(route.id).map((segment) => ({
-						dynamic: segment.includes('['),
-						rest: segment.includes('[...'),
-						content: segment
-					})),
-					pattern: route.pattern,
-					methods
-				};
-			});
-
 			const seen = new Set();
 
-			for (let i = 0; i < routes.length; i += 1) {
-				const route = routes[i];
-				const { id, filter, complete } = fn(facades[i]);
+			for (let i = 0; i < route_data.length; i += 1) {
+				const route = route_data[i];
+				if (prerender_map.get(route.id) === true) continue;
+				const { id, filter, complete } = fn(routes[i]);
 
 				if (seen.has(id)) continue;
 				seen.add(id);
@@ -82,9 +107,10 @@ export function create_builder({ config, build_data, server_metadata, routes, pr
 				const group = [route];
 
 				// figure out which lower priority routes should be considered fallbacks
-				for (let j = i + 1; j < routes.length; j += 1) {
-					if (filter(facades[j])) {
-						group.push(routes[j]);
+				for (let j = i + 1; j < route_data.length; j += 1) {
+					if (prerender_map.get(routes[j].id) === true) continue;
+					if (filter(routes[j])) {
+						group.push(route_data[j]);
 					}
 				}
 
@@ -95,7 +121,7 @@ export function create_builder({ config, build_data, server_metadata, routes, pr
 				// TODO is this still necessary, given the new way of doing things?
 				filtered.forEach((route) => {
 					if (route.page) {
-						const endpoint = routes.find((candidate) => candidate.id === route.id + '.json');
+						const endpoint = route_data.find((candidate) => candidate.id === route.id + '.json');
 
 						if (endpoint) {
 							filtered.add(endpoint);
@@ -143,11 +169,13 @@ export function create_builder({ config, build_data, server_metadata, routes, pr
 			});
 		},
 
-		generateManifest: ({ relativePath }) => {
+		generateManifest: ({ relativePath, routes: subset }) => {
 			return generate_manifest({
 				build_data,
 				relative_path: relativePath,
-				routes
+				routes: subset
+					? subset.map((route) => /** @type {import('types').RouteData} */ (lookup.get(route)))
+					: route_data
 			});
 		},
 

package/src/core/adapt/index.js

@@ -18,13 +18,9 @@ export async function adapt(config, build_data, server_metadata, prerendered, pr
 		config,
 		build_data,
 		server_metadata,
-		routes: build_data.manifest_data.routes.filter((route) => {
-			if (!route.page && !route.endpoint) return false;
-
-			const prerender = prerender_map.get(route.id);
-			return prerender === false || prerender === undefined || prerender === 'auto';
-		}),
+		route_data: build_data.manifest_data.routes.filter((route) => route.page || route.endpoint),
 		prerendered,
+		prerender_map,
 		log
 	});
 	await adapt(builder);

package/src/core/postbuild/analyse.js

@@ -67,6 +67,8 @@ async function analyse({ manifest_path, env }) {
 
 		/** @type {import('types').PrerenderOption | undefined} */
 		let prerender = undefined;
+		/** @type {any} */
+		let config = undefined;
 
 		if (route.endpoint) {
 			const mod = await route.endpoint();
@@ -87,6 +89,8 @@ async function analyse({ manifest_path, env }) {
 			if (mod.PUT) methods.add('PUT');
 			if (mod.PATCH) methods.add('PATCH');
 			if (mod.DELETE) methods.add('DELETE');
+
+			config = mod.config;
 		}
 
 		if (route.page) {
@@ -123,13 +127,35 @@ async function analyse({ manifest_path, env }) {
 				(should_prerender !== false && get_option(nodes, 'ssr') === false && !page?.server?.actions
 					? 'auto'
 					: should_prerender ?? false);
+
+			config = get_config(nodes);
 		}
 
 		metadata.routes.set(route.id, {
 			prerender,
+			config,
 			methods: Array.from(methods)
 		});
 	}
 
 	return metadata;
 }
+
+/**
+ * Do a shallow merge (first level) of the config object
+ * @param {Array<import('types').SSRNode | undefined>} nodes
+ */
+function get_config(nodes) {
+	let current = {};
+	for (const node of nodes) {
+		const config = node?.universal?.config ?? node?.server?.config;
+		if (config) {
+			current = {
+				...current,
+				...config
+			};
+		}
+	}
+
+	return Object.keys(current).length ? current : undefined;
+}

package/src/core/sync/write_root.js

@@ -21,16 +21,16 @@ export function write_root(manifest_data, output) {
 
 	let l = max_depth;
 
-	let pyramid = `<svelte:component this={components[${l}]} data={data_${l}} {form} />`;
+	let pyramid = `<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} />`;
 
 	while (l--) {
 		pyramid = `
-			{#if components[${l + 1}]}
-				<svelte:component this={components[${l}]} data={data_${l}}>
+			{#if constructors[${l + 1}]}
+				<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}}>
 					${pyramid.replace(/\n/g, '\n\t\t\t\t\t')}
 				</svelte:component>
 			{:else}
-				<svelte:component this={components[${l}]} data={data_${l}} {form} />
+				<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} />
 			{/if}
 		`
 			.replace(/^\t\t\t/gm, '')
@@ -49,7 +49,8 @@ export function write_root(manifest_data, output) {
 				export let stores;
 				export let page;
 
-				export let components;
+				export let constructors;
+				export let components = [];
 				export let form;
 				${levels.map((l) => `export let data_${l} = null;`).join('\n\t\t\t\t')}
 

package/src/core/sync/write_tsconfig.js

@@ -85,19 +85,29 @@ export function get_tsconfig(kit, include_base_url) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path.relative(kit.outDir, file));
 
-	const include = ['ambient.d.ts', './types/**/$types.d.ts', config_relative('vite.config.ts')];
-	for (const dir of [kit.files.routes, kit.files.lib]) {
-		const relative = project_relative(path.dirname(dir));
-		include.push(config_relative(`${relative}/**/*.js`));
-		include.push(config_relative(`${relative}/**/*.ts`));
-		include.push(config_relative(`${relative}/**/*.svelte`));
+	const include = new Set([
+		'ambient.d.ts',
+		'./types/**/$types.d.ts',
+		config_relative('vite.config.ts')
+	]);
+	// TODO(v2): find a better way to include all src files. We can't just use routes/lib only because
+	// people might have other folders/files in src that they want included.
+	const src_includes = [kit.files.routes, kit.files.lib, path.resolve('src')].filter((dir) => {
+		const relative = path.relative(path.resolve('src'), dir);
+		return !relative || relative.startsWith('..');
+	});
+	for (const dir of src_includes) {
+		include.add(config_relative(`${dir}/**/*.js`));
+		include.add(config_relative(`${dir}/**/*.ts`));
+		include.add(config_relative(`${dir}/**/*.svelte`));
 	}
+
 	// Test folder is a special case - we advocate putting tests in a top-level test folder
 	// and it's not configurable (should we make it?)
 	const test_folder = project_relative('tests');
-	include.push(config_relative(`${test_folder}/**/*.js`));
-	include.push(config_relative(`${test_folder}/**/*.ts`));
-	include.push(config_relative(`${test_folder}/**/*.svelte`));
+	include.add(config_relative(`${test_folder}/**/*.js`));
+	include.add(config_relative(`${test_folder}/**/*.ts`));
+	include.add(config_relative(`${test_folder}/**/*.svelte`));
 
 	const exclude = [config_relative('node_modules/**'), './[!ambient.d.ts]**'];
 	if (path.extname(kit.files.serviceWorker)) {
@@ -135,7 +145,7 @@ export function get_tsconfig(kit, include_base_url) {
 			// TODO(v2): use the new flag verbatimModuleSyntax instead (requires support by Vite/Esbuild)
 			ignoreDeprecations: ts && Number(ts.version.split('.')[0]) >= 5 ? '5.0' : undefined
 		},
-		include,
+		include: [...include],
 		exclude
 	};
 

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

@@ -198,23 +198,26 @@ function update_types(config, routes, route, to_delete = new Set()) {
 
 	// 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
 	if (route.layout || route.leaf) {
-		// If T extends the empty object, void is also allowed as a return type
-		declarations.push(`type MaybeWithVoid<T> = {} extends T ? T | void : T;`);
-		// Returns the key of the object whose values are required.
 		declarations.push(
-			`export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];`
-		);
-		// Helper type to get the correct output type for load functions. It should be passed the parent type to check what types from App.PageData are still required.
-		// If none, void is also allowed as a return type.
-		declarations.push(
-			`type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>`
-		);
-		// null & {} == null, we need to prevent that in some situations
-		declarations.push(`type EnsureDefined<T> = T extends null | undefined ? {} : T;`);
-		// Takes a union type and returns a union type where each type also has all properties
-		// of all possible types (typed as undefined), making accessing them more ergonomic
-		declarations.push(
-			`type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;`
+			// If T extends the empty object, void is also allowed as a return type
+			`type MaybeWithVoid<T> = {} extends T ? T | void : T;`,
+
+			// Returns the key of the object whose values are required.
+			`export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];`,
+
+			// Helper type to get the correct output type for load functions. It should be passed the parent type to check what types from App.PageData are still required.
+			// If none, void is also allowed as a return type.
+			`type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>`,
+
+			// null & {} == null, we need to prevent that in some situations
+			`type EnsureDefined<T> = T extends null | undefined ? {} : T;`,
+
+			// Takes a union type and returns a union type where each type also has all properties
+			// of all possible types (typed as undefined), making accessing them more ergonomic
+			`type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;`,
+
+			// Re-export `Snapshot` from @sveltejs/kit — in future we could use this to infer <T> from the return type of `snapshot.capture`
+			`export type Snapshot<T = any> = Kit.Snapshot<T>;`
 		);
 	}
 

package/src/runtime/client/client.js

@@ -15,6 +15,7 @@ import {
 	is_external_url,
 	scroll_state
 } from './utils.js';
+import * as storage from './session-storage.js';
 import {
 	lock_fetch,
 	unlock_fetch,
@@ -31,7 +32,7 @@ import { HttpError, Redirect } from '../control.js';
 import { stores } from './singletons.js';
 import { unwrap_promises } from '../../utils/promises.js';
 import * as devalue from 'devalue';
-import { INDEX_KEY, PRELOAD_PRIORITIES, SCROLL_KEY } from './constants.js';
+import { INDEX_KEY, PRELOAD_PRIORITIES, SCROLL_KEY, SNAPSHOT_KEY } from './constants.js';
 import { validate_common_exports } from '../../utils/exports.js';
 import { compact } from '../../utils/array.js';
 
@@ -52,12 +53,10 @@ default_error_loader();
 
 /** @typedef {{ x: number, y: number }} ScrollPosition */
 /** @type {Record<number, ScrollPosition>} */
-let scroll_positions = {};
-try {
-	scroll_positions = JSON.parse(sessionStorage[SCROLL_KEY]);
-} catch {
-	// do nothing
-}
+const scroll_positions = storage.get(SCROLL_KEY) ?? {};
+
+/** @type {Record<string, any[]>} */
+const snapshots = storage.get(SNAPSHOT_KEY) ?? {};
 
 /** @param {number} index */
 function update_scroll_positions(index) {
@@ -75,6 +74,14 @@ export function create_client({ target }) {
 	/** @type {Array<((url: URL) => boolean)>} */
 	const invalidated = [];
 
+	/**
+	 * An array of the `+layout.svelte` and `+page.svelte` component instances
+	 * that currently live on the page — used for capturing and restoring snapshots.
+	 * It's updated/manipulated through `bind:this` in `Root.svelte`.
+	 * @type {import('svelte').SvelteComponent[]}
+	 */
+	const components = [];
+
 	/** @type {{id: string, promise: Promise<import('./types').NavigationResult>} | null} */
 	let load_cache = null;
 
@@ -158,6 +165,20 @@ export function create_client({ target }) {
 		await update(intent, url, []);
 	}
 
+	/** @param {number} index */
+	function capture_snapshot(index) {
+		if (components.some((c) => c?.snapshot)) {
+			snapshots[index] = components.map((c) => c?.snapshot?.capture());
+		}
+	}
+
+	/** @param {number} index */
+	function restore_snapshot(index) {
+		snapshots[index]?.forEach((value, i) => {
+			components[i]?.snapshot?.restore(value);
+		});
+	}
+
 	/**
 	 * @param {string | URL} url
 	 * @param {{ noScroll?: boolean; replaceState?: boolean; keepFocus?: boolean; state?: any; invalidateAll?: boolean }} opts
@@ -238,11 +259,20 @@ export function create_client({ target }) {
 	 * @param {import('./types').NavigationIntent | undefined} intent
 	 * @param {URL} url
 	 * @param {string[]} redirect_chain
+	 * @param {number} [previous_history_index]
 	 * @param {{hash?: string, scroll: { x: number, y: number } | null, keepfocus: boolean, details: { replaceState: boolean, state: any } | null}} [opts]
 	 * @param {{}} [nav_token] To distinguish between different navigation events and determine the latest. Needed for example for redirects to keep the original token
 	 * @param {() => void} [callback]
 	 */
-	async function update(intent, url, redirect_chain, opts, nav_token = {}, callback) {
+	async function update(
+		intent,
+		url,
+		redirect_chain,
+		previous_history_index,
+		opts,
+		nav_token = {},
+		callback
+	) {
 		token = nav_token;
 		let navigation_result = intent && (await load_route(intent));
 
@@ -301,11 +331,28 @@ export function create_client({ target }) {
 
 		updating = true;
 
+		// `previous_history_index` will be undefined for invalidation
+		if (previous_history_index) {
+			update_scroll_positions(previous_history_index);
+			capture_snapshot(previous_history_index);
+		}
+
 		if (opts && opts.details) {
 			const { details } = opts;
 			const change = details.replaceState ? 0 : 1;
 			details.state[INDEX_KEY] = current_history_index += change;
 			history[details.replaceState ? 'replaceState' : 'pushState'](details.state, '', url);
+
+			if (!details.replaceState) {
+				// if we navigated back, then pushed a new state, we can
+				// release memory by pruning the scroll/snapshot lookup
+				let i = current_history_index + 1;
+				while (snapshots[i] || scroll_positions[i]) {
+					delete snapshots[i];
+					delete scroll_positions[i];
+					i += 1;
+				}
+			}
 		}
 
 		// reset preload synchronously after the history state has been set to avoid race conditions
@@ -384,10 +431,12 @@ export function create_client({ target }) {
 
 		root = new Root({
 			target,
-			props: { ...result.props, stores },
+			props: { ...result.props, stores, components },
 			hydrate: true
 		});
 
+		restore_snapshot(current_history_index);
+
 		/** @type {import('types').AfterNavigate} */
 		const navigation = {
 			from: null,
@@ -445,7 +494,7 @@ export function create_client({ target }) {
 			},
 			props: {
 				// @ts-ignore Somehow it's getting SvelteComponent and SvelteComponentDev mixed up
-				components: compact(branch).map((branch_node) => branch_node.node.component)
+				constructors: compact(branch).map((branch_node) => branch_node.node.component)
 			}
 		};
 
@@ -804,7 +853,7 @@ export function create_client({ target }) {
 					// server_data_node is undefined if it wasn't reloaded from the server;
 					// and if current loader uses server data, we want to reuse previous data.
 					server_data_node === undefined && loader[0] ? { type: 'skip' } : server_data_node ?? null,
-					previous?.server
+					loader[0] ? previous?.server : undefined
 				)
 			});
 		});
@@ -1091,7 +1140,8 @@ export function create_client({ target }) {
 			return;
 		}
 
-		update_scroll_positions(current_history_index);
+		// store this before calling `accepted()`, which may change the index
+		const previous_history_index = current_history_index;
 
 		accepted();
 
@@ -1105,6 +1155,7 @@ export function create_client({ target }) {
 			intent,
 			url,
 			redirect_chain,
+			previous_history_index,
 			{
 				scroll,
 				keepfocus,
@@ -1385,12 +1436,10 @@ export function create_client({ target }) {
 			addEventListener('visibilitychange', () => {
 				if (document.visibilityState === 'hidden') {
 					update_scroll_positions(current_history_index);
+					storage.set(SCROLL_KEY, scroll_positions);
 
-					try {
-						sessionStorage[SCROLL_KEY] = JSON.stringify(scroll_positions);
-					} catch {
-						// do nothing
-					}
+					capture_snapshot(current_history_index);
+					storage.set(SNAPSHOT_KEY, snapshots);
 				}
 			});
 
@@ -1537,7 +1586,7 @@ export function create_client({ target }) {
 				});
 			});
 
-			addEventListener('popstate', (event) => {
+			addEventListener('popstate', async (event) => {
 				if (event.state?.[INDEX_KEY]) {
 					// if a popstate-driven navigation is cancelled, we need to counteract it
 					// with history.go, which means we end up back here, hence this check
@@ -1555,8 +1604,9 @@ export function create_client({ target }) {
 					}
 
 					const delta = event.state[INDEX_KEY] - current_history_index;
+					let blocked = false;
 
-					navigate({
+					await navigate({
 						url: new URL(location.href),
 						scroll,
 						keepfocus: false,
@@ -1567,10 +1617,15 @@ export function create_client({ target }) {
 						},
 						blocked: () => {
 							history.go(-delta);
+							blocked = true;
 						},
 						type: 'popstate',
 						delta
 					});
+
+					if (!blocked) {
+						restore_snapshot(current_history_index);
+					}
 				}
 			});
 

package/src/runtime/client/constants.js

@@ -1,3 +1,4 @@
+export const SNAPSHOT_KEY = 'sveltekit:snapshot';
 export const SCROLL_KEY = 'sveltekit:scroll';
 export const INDEX_KEY = 'sveltekit:index';
 

package/src/runtime/client/session-storage.js

@@ -0,0 +1,25 @@
+/**
+ * Read a value from `sessionStorage`
+ * @param {string} key
+ */
+export function get(key) {
+	try {
+		return JSON.parse(sessionStorage[key]);
+	} catch {
+		// do nothing
+	}
+}
+
+/**
+ * Write a value to `sessionStorage`
+ * @param {string} key
+ * @param {any} value
+ */
+export function set(key, value) {
+	const json = JSON.stringify(value);
+	try {
+		sessionStorage[key] = json;
+	} catch {
+		// do nothing
+	}
+}

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

@@ -90,7 +90,7 @@ export async function render_response({
 				navigating: writable(null),
 				updated
 			},
-			components: await Promise.all(branch.map(({ node }) => node.component())),
+			constructors: await Promise.all(branch.map(({ node }) => node.component())),
 			form: form_value
 		};
 

package/src/utils/exports.js

@@ -31,7 +31,8 @@ export const validate_common_exports = validator([
 	'prerender',
 	'csr',
 	'ssr',
-	'trailingSlash'
+	'trailingSlash',
+	'config'
 ]);
 
 export const validate_page_server_exports = validator([
@@ -40,7 +41,8 @@ export const validate_page_server_exports = validator([
 	'csr',
 	'ssr',
 	'actions',
-	'trailingSlash'
+	'trailingSlash',
+	'config'
 ]);
 
 export const validate_server_exports = validator([
@@ -50,5 +52,6 @@ export const validate_server_exports = validator([
 	'PUT',
 	'DELETE',
 	'prerender',
-	'trailingSlash'
+	'trailingSlash',
+	'config'
 ]);

package/types/index.d.ts

@@ -7,13 +7,15 @@ import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
 	CspDirectives,
+	HttpMethod,
 	Logger,
 	MaybePromise,
 	Prerendered,
 	PrerenderHttpErrorHandlerValue,
 	PrerenderMissingIdHandlerValue,
+	PrerenderOption,
 	RequestOptions,
-	RouteDefinition,
+	RouteSegment,
 	UniqueInterface
 } from './private.js';
 import { SSRNodeLoader, SSRRoute, ValidatedConfig } from './internal.js';
@@ -85,10 +87,13 @@ export interface Builder {
 	config: ValidatedConfig;
 	/** Information about prerendered pages and assets, if any. */
 	prerendered: Prerendered;
+	/** An array of dynamic (not prerendered) routes */
+	routes: RouteDefinition[];
 
 	/**
 	 * Create separate functions that map to one or more routes of your app.
 	 * @param fn A function that groups a set of routes into an entry point
+	 * @deprecated Use `builder.routes` instead
 	 */
 	createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
 
@@ -101,7 +106,7 @@ export interface Builder {
 	 * Generate a server-side manifest to initialise the SvelteKit [server](https://kit.svelte.dev/docs/types#public-types-server) with.
 	 * @param opts a relative path to the base directory of the app and optionally in which format (esm or cjs) the manifest should be generated
 	 */
-	generateManifest(opts: { relativePath: string }): string;
+	generateManifest(opts: { relativePath: string; routes?: RouteDefinition[] }): string;
 
 	/**
 	 * Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`.
@@ -515,7 +520,23 @@ export interface KitConfig {
 		config?: (config: Record<string, any>) => Record<string, any> | void;
 	};
 	/**
-	 * Client-side navigation can be buggy if you deploy a new version of your app while people are using it. If the code for the new page is already loaded, it may have stale content; if it isn't, the app's route manifest may point to a JavaScript file that no longer exists. SvelteKit solves this problem by falling back to traditional full-page navigation if it detects that a new version has been deployed, using the `name` specified here (which defaults to a timestamp of the build).
+	 * Client-side navigation can be buggy if you deploy a new version of your app while people are using it. If the code for the new page is already loaded, it may have stale content; if it isn't, the app's route manifest may point to a JavaScript file that no longer exists.
+	 * SvelteKit helps you solve this problem through version management.
+	 * 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 `pollInverval` and then using `beforeNavigate`:
+	 * ```html
+	 * /// +layout.svelte
+	 * <script>
+	 * import { beforeNavigate } from '$app/navigation';
+	 * import { updated } from '$app/stores';
+	 *
+	 * beforeNavigate(({ willUnload, to }) => {
+	 *   if ($updated && !willUnload && to?.url) {
+	 *     location.href = to.route.url.href;
+	 *   }
+	 * });
+	 * </script>
+	 * ```
 	 *
 	 * If you set `pollInterval` to a non-zero value, SvelteKit will poll for new versions in the background and set the value of the [`updated`](/docs/modules#$app-stores-updated) store to `true` when it detects one.
 	 */
@@ -959,6 +980,15 @@ export interface ResolveOptions {
 	preload?(input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }): boolean;
 }
 
+export interface RouteDefinition<Config = any> {
+	id: string;
+	pattern: RegExp;
+	prerender: PrerenderOption;
+	segments: RouteSegment[];
+	methods: HttpMethod[];
+	config: Config;
+}
+
 export class Server {
 	constructor(manifest: SSRManifest);
 	init(options: ServerInitOptions): Promise<void>;
@@ -1077,6 +1107,13 @@ export type Actions<
 
 /**
  * When calling a form action via fetch, the response will be one of these shapes.
+ * ```svelte
+ * <form method="post" use:enhance={() => {
+ *   return ({ result }) => {
+ * 		// result is of type ActionResult
+ *   };
+ * }}
+ * ```
  */
 export type ActionResult<
 	Success extends Record<string, unknown> | undefined = Record<string, any>,
@@ -1192,3 +1229,11 @@ export interface SubmitFunction<
 		  }) => void)
 	>;
 }
+
+/**
+ * The type of `export const snapshot` exported from a page or layout component.
+ */
+export interface Snapshot<T = any> {
+	capture: () => T;
+	restore: (snapshot: T) => void;
+}

package/types/internal.d.ts

@@ -239,6 +239,7 @@ export interface ServerMetadata {
 		{
 			prerender: PrerenderOption | undefined;
 			methods: HttpMethod[];
+			config: any;
 		}
 	>;
 }
@@ -279,6 +280,7 @@ export interface SSRNode {
 		ssr?: boolean;
 		csr?: boolean;
 		trailingSlash?: TrailingSlash;
+		config?: any;
 	};
 
 	server: {
@@ -288,6 +290,7 @@ export interface SSRNode {
 		csr?: boolean;
 		trailingSlash?: TrailingSlash;
 		actions?: Actions;
+		config?: any;
 	};
 
 	// store this in dev so we can print serialization errors
@@ -331,6 +334,7 @@ export interface PageNodeIndexes {
 export type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>> & {
 	prerender?: PrerenderOption;
 	trailingSlash?: TrailingSlash;
+	config?: any;
 };
 
 export interface SSRRoute {

package/types/private.d.ts

@@ -2,6 +2,8 @@
 // but which cannot be imported from `@sveltejs/kit`. Care should
 // be taken to avoid breaking changes when editing this file
 
+import { RouteDefinition } from './index.js';
+
 export interface AdapterEntry {
 	/**
 	 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
@@ -12,8 +14,11 @@ export interface AdapterEntry {
 
 	/**
 	 * A function that compares the candidate route with the current route to determine
-	 * if it should be treated as a fallback for the current route. For example, `/foo/[c]`
-	 * is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
+	 * if it should be grouped with the current route.
+	 *
+	 * Use cases:
+	 * - Fallback pages: `/foo/[c]` is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes
+	 * - Grouping routes that share a common `config`: `/foo` should be deployed to the edge, `/bar` and `/baz` should be deployed to a serverless function
 	 */
 	filter(route: RouteDefinition): boolean;
 
@@ -212,13 +217,6 @@ export interface RequestOptions {
 	platform?: App.Platform;
 }
 
-export interface RouteDefinition {
-	id: string;
-	pattern: RegExp;
-	segments: RouteSegment[];
-	methods: HttpMethod[];
-}
-
 export interface RouteSegment {
 	content: string;
 	dynamic: boolean;