@sveltejs/kit 2.21.1 → 2.21.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.21.1",
+  "version": "2.21.3",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -29,7 +29,8 @@
     "mrmime": "^2.0.0",
     "sade": "^1.8.1",
     "set-cookie-parser": "^2.6.0",
-    "sirv": "^3.0.0"
+    "sirv": "^3.0.0",
+    "vitefu": "^1.0.6"
   },
   "devDependencies": {
     "@playwright/test": "^1.51.1",

package/src/core/postbuild/analyse.js

@@ -63,6 +63,7 @@ async function analyse({
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
+	/** @type {Map<string, { page_options: Record<string, any> | null, children: string[] }>} */
 	const static_exports = new Map();
 
 	// first, build server nodes without the client manifest so we can analyse it
@@ -73,6 +74,7 @@ async function analyse({
 		server_manifest,
 		null,
 		null,
+		null,
 		output_config,
 		static_exports
 	);

package/src/exports/public.d.ts

@@ -468,7 +468,7 @@ export interface KitConfig {
 		errorTemplate?: string;
 	};
 	/**
-	 * Inline CSS inside a `<style>` block at the head of the HTML. This option is a number that specifies the maximum length of a CSS file in UTF-16 code units, as specified by the [String.length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) property, to be inlined. All CSS files needed for the page and smaller than this value are merged and inlined in a `<style>` block.
+	 * Inline CSS inside a `<style>` block at the head of the HTML. This option is a number that specifies the maximum length of a CSS file in UTF-16 code units, as specified by the [String.length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) property, to be inlined. All CSS files needed for the page that are smaller than this value are merged and inlined in a `<style>` block.
 	 *
 	 * > [!NOTE] This results in fewer initial requests and can improve your [First Contentful Paint](https://web.dev/first-contentful-paint) score. However, it generates larger HTML output and reduces the effectiveness of browser caches. Use it advisedly.
 	 * @default 0

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

@@ -13,66 +13,49 @@ import { create_node_analyser } from '../static_analysis/index.js';
  * @param {import('types').ManifestData} manifest_data
  * @param {import('vite').Manifest} server_manifest
  * @param {import('vite').Manifest | null} client_manifest
- * @param {import('vite').Rollup.OutputAsset[] | null} css
+ * @param {import('vite').Rollup.OutputBundle | null} server_bundle
+ * @param {import('vite').Rollup.RollupOutput['output'] | null} client_bundle
  * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, Record<string, any> | null>} static_exports
+ * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
  */
-export async function build_server_nodes(out, kit, manifest_data, server_manifest, client_manifest, css, output_config, static_exports) {
+export async function build_server_nodes(out, kit, manifest_data, server_manifest, client_manifest, server_bundle, client_bundle, output_config, static_exports) {
 	mkdirp(`${out}/server/nodes`);
 	mkdirp(`${out}/server/stylesheets`);
 
 	/** @type {Map<string, string>} */
-	const stylesheet_lookup = new Map();
-
-	if (css) {
-		/** @type {Set<string>} */
-		const client_stylesheets = new Set();
-		for (const key in client_manifest) {
-			client_manifest[key].css?.forEach((filename) => {
-				client_stylesheets.add(filename);
-			});
-		}
+	const stylesheets_to_inline = new Map();
 
-		/** @type {Map<number, string[]>} */
-		const server_stylesheets = new Map();
-		manifest_data.nodes.forEach((node, i) => {
-			if (!node.component || !server_manifest[node.component]) return;
+	if (server_bundle && client_bundle && kit.inlineStyleThreshold > 0) {
+		const client = get_stylesheets(client_bundle);
 
-			const { stylesheets } = find_deps(server_manifest, node.component, false);
+		const server_chunks = Object.values(server_bundle);
+		const server = get_stylesheets(server_chunks);
 
-			if (stylesheets.length) {
-				server_stylesheets.set(i, stylesheets);
-			}
-		});
-
-		for (const asset of css) {
-			// ignore dynamically imported stylesheets since we don't need to inline those
-			if (!client_stylesheets.has(asset.fileName) || asset.source.length >= kit.inlineStyleThreshold) {
+		// map server stylesheet name to the client stylesheet name
+		for (const [id, client_stylesheet] of client.stylesheets_used) {
+			const server_stylesheet = server.stylesheets_used.get(id);
+			if (!server_stylesheet) {
 				continue;
 			}
+			client_stylesheet.forEach((file, i) => {
+				stylesheets_to_inline.set(file, server_stylesheet[i]);
+			}) 
+		}
 
-			// We know that the names for entry points are numbers.
-			const [index] = basename(asset.fileName).split('.');
-			// There can also be other CSS files from shared components
-			// for example, which we need to ignore here.
-			if (isNaN(+index)) continue;
-
-			const file = `${out}/server/stylesheets/${index}.js`;
-
-			// we need to inline the server stylesheet instead of the client one
-			// so that asset paths are correct on document load
-			const filenames = server_stylesheets.get(+index);
-
-			if (!filenames) {
-				throw new Error('This should never happen, but if it does, it means we failed to find the server stylesheet for a node.');
+		// filter out stylesheets that should not be inlined
+		for (const [fileName, content] of client.stylesheet_content) {
+			if (content.length >= kit.inlineStyleThreshold) {
+				stylesheets_to_inline.delete(fileName);
 			}
+		}
 
-			const sources = filenames.map((filename) => {
-				return fs.readFileSync(`${out}/server/${filename}`, 'utf-8');
-			});
-			fs.writeFileSync(file, `// ${filenames.join(', ')}\nexport default ${s(sources.join('\n'))};`);
-
-			stylesheet_lookup.set(asset.fileName, index);
+		// map server stylesheet source to the client stylesheet name
+		for (const [client_file, server_file] of stylesheets_to_inline) {
+			const source = server.stylesheet_content.get(server_file);
+			if (!source) {
+				throw new Error(`Server stylesheet source not found for client stylesheet ${client_file}`);
+			}
+			stylesheets_to_inline.set(client_file, source);
 		}
 	}
 
@@ -139,8 +122,9 @@ export async function build_server_nodes(out, kit, manifest_data, server_manifes
 			const entry_path = `${normalizePath(kit.outDir)}/generated/client-optimized/nodes/${i}.js`;
 			const entry = find_deps(client_manifest, entry_path, true);
 
-			// eagerly load stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
-			// If it is not used during SSR, it can be lazily loaded in the browser.
+			// eagerly load client stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
+			// However, if it is not used during SSR (not present in the server manifest),
+			// then it can be lazily loaded in the browser.
 	
 			/** @type {import('types').AssetDependencies | undefined} */
 			let component;
@@ -155,26 +139,26 @@ export async function build_server_nodes(out, kit, manifest_data, server_manifes
 			}
 
 			/** @type {Set<string>} */
-			const css_used_by_server = new Set();
+			const eager_css = new Set();
 			/** @type {Set<string>} */
-			const assets_used_by_server = new Set();
+			const eager_assets = new Set();
 
-			entry.stylesheet_map.forEach((value, key) => {
-				// pages and layouts are named as node indexes in the client manifest
-				// so we need to use the original filename when checking against the server manifest
-				if (key === entry_path) {
-					key = node.component ?? key;
+			entry.stylesheet_map.forEach((value, filepath) => {
+				// pages and layouts are renamed to node indexes when optimised for the client
+				// so we use the original filename instead to check against the server manifest
+				if (filepath === entry_path) {
+					filepath = node.component ?? filepath;
 				}
 
-				if (component?.stylesheet_map.has(key) || universal?.stylesheet_map.has(key)) {
-					value.css.forEach(file => css_used_by_server.add(file));
-					value.assets.forEach(file => assets_used_by_server.add(file));
+				if (component?.stylesheet_map.has(filepath) || universal?.stylesheet_map.has(filepath)) {
+					value.css.forEach(file => eager_css.add(file));
+					value.assets.forEach(file => eager_assets.add(file));
 				}
 			});
 
 			imported = entry.imports;
-			stylesheets = Array.from(css_used_by_server);
-			fonts = filter_fonts(Array.from(assets_used_by_server));
+			stylesheets = Array.from(eager_css);
+			fonts = filter_fonts(Array.from(eager_assets));
 		}
 
 		exports.push(
@@ -184,19 +168,26 @@ export async function build_server_nodes(out, kit, manifest_data, server_manifes
 		);
 
 		/** @type {string[]} */
-		const styles = [];
-
-		stylesheets.forEach((file) => {
-			if (stylesheet_lookup.has(file)) {
-				const index = stylesheet_lookup.get(file);
-				const name = `stylesheet_${index}`;
-				imports.push(`import ${name} from '../stylesheets/${index}.js';`);
-				styles.push(`\t${s(file)}: ${name}`);
+		const inline_styles = [];
+
+		stylesheets.forEach((file, i) => {
+			if (stylesheets_to_inline.has(file)) {
+				const filename = basename(file);
+				const dest = `${out}/server/stylesheets/${filename}.js`;
+				const source = stylesheets_to_inline.get(file);
+				if (!source) {
+					throw new Error(`Server stylesheet source not found for client stylesheet ${file}`);
+				}
+				fs.writeFileSync(dest, `// ${filename}\nexport default ${s(source)};`);
+
+				const name = `stylesheet_${i}`;
+				imports.push(`import ${name} from '../stylesheets/${filename}.js';`);
+				inline_styles.push(`\t${s(file)}: ${name}`);
 			}
 		});
 
-		if (styles.length > 0) {
-			exports.push(`export const inline_styles = () => ({\n${styles.join(',\n')}\n});`);
+		if (inline_styles.length > 0) {
+			exports.push(`export const inline_styles = () => ({\n${inline_styles.join(',\n')}\n});`);
 		}
 
 		fs.writeFileSync(
@@ -205,3 +196,37 @@ export async function build_server_nodes(out, kit, manifest_data, server_manifes
 		);
 	}
 }
+
+/**
+ * @param {(import('vite').Rollup.OutputAsset | import('vite').Rollup.OutputChunk)[]} chunks 
+ */
+function get_stylesheets(chunks) {
+	/**
+	 * A map of module IDs and the stylesheets they use.
+	 * @type {Map<string, string[]>}
+	 */
+	const stylesheets_used = new Map();
+
+	/**
+	 * A map of stylesheet names and their content.
+	 * @type {Map<string, string>}
+	 */
+	const stylesheet_content = new Map();
+
+	for (const chunk of chunks) {
+		if (chunk.type === 'asset') {
+			if (chunk.fileName.endsWith('.css')) {
+				stylesheet_content.set(chunk.fileName, chunk.source.toString());
+			}
+			continue;
+		}
+
+		if (chunk.viteMetadata?.importedCss.size) {
+			const css = Array.from(chunk.viteMetadata.importedCss);
+			for (const id of chunk.moduleIds) {
+				stylesheets_used.set(id, css );
+			}
+		}
+	}
+	return { stylesheets_used, stylesheet_content };
+}

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

@@ -355,14 +355,18 @@ export async function dev(vite, vite_config, svelte_config) {
 
 	// Debounce add/unlink events because in case of folder deletion or moves
 	// they fire in rapid succession, causing needless invocations.
+	// These watchers only run for routes, param matchers, and client hooks.
 	watch('add', () => debounce(update_manifest));
 	watch('unlink', () => debounce(update_manifest));
 	watch('change', (file) => {
 		// Don't run for a single file if the whole manifest is about to get updated
 		if (timeout || restarting) return;
 
+		if (/\+(page|layout).*$/.test(file)) {
+			invalidate_page_options(path.relative(cwd, file));
+		}
+
 		sync.update(svelte_config, manifest_data, file);
-		invalidate_page_options(path.relative(cwd, file));
 	});
 
 	const { appTemplate, errorTemplate, serviceWorker, hooks } = svelte_config.kit.files;
@@ -389,10 +393,10 @@ export async function dev(vite, vite_config, svelte_config) {
 		}
 	});
 
-	// changing the svelte config requires restarting the dev server
-	// the config is only read on start and passed on to vite-plugin-svelte
-	// which needs up-to-date values to operate correctly
 	vite.watcher.on('change', async (file) => {
+		// changing the svelte config requires restarting the dev server
+		// the config is only read on start and passed on to vite-plugin-svelte
+		// which needs up-to-date values to operate correctly
 		if (path.basename(file) === 'svelte.config.js') {
 			console.log(`svelte config changed, restarting vite dev-server. changed file: ${file}`);
 			restarting = true;

package/src/exports/vite/index.js

@@ -36,6 +36,7 @@ import {
 } from './module_ids.js';
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
+import { crawlFrameworkPkgs } from 'vitefu';
 
 const cwd = process.cwd();
 
@@ -227,7 +228,7 @@ async function kit({ svelte_config }) {
 		 * 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
 		 */
-		config(config, config_env) {
+		async config(config, config_env) {
 			initial_config = config;
 			vite_config_env = config_env;
 			is_build = config_env.command === 'build';
@@ -250,6 +251,20 @@ async function kit({ svelte_config }) {
 
 			const generated = path.posix.join(kit.outDir, 'generated');
 
+			const packages_depending_on_svelte_kit = (
+				await crawlFrameworkPkgs({
+					root: cwd,
+					isBuild: is_build,
+					viteUserConfig: config,
+					isSemiFrameworkPkgByJson: (pkg_json) => {
+						return (
+							!!pkg_json.dependencies?.['@sveltejs/kit'] ||
+							!!pkg_json.peerDependencies?.['@sveltejs/kit']
+						);
+					}
+				})
+			).ssr.noExternal;
+
 			// dev and preview config can be shared
 			/** @type {import('vite').UserConfig} */
 			const new_config = {
@@ -306,7 +321,11 @@ async function kit({ svelte_config }) {
 						//    when it is detected to keep our virtual modules working.
 						//    See https://github.com/sveltejs/kit/pull/9172
 						//    and https://vitest.dev/config/#deps-registernodeloader
-						'@sveltejs/kit'
+						'@sveltejs/kit',
+						// We need to bundle any packages depending on @sveltejs/kit so that
+						// everyone uses the same instances of classes such as `Redirect`
+						// which we use in `instanceof` checks
+						...packages_depending_on_svelte_kit
 					]
 				}
 			};
@@ -787,7 +806,7 @@ Tips:
 		 */
 		writeBundle: {
 			sequential: true,
-			async handler(_options) {
+			async handler(_options, bundle) {
 				if (secondary_build_started) return; // only run this once
 
 				const verbose = vite_config.logLevel === 'info';
@@ -843,7 +862,7 @@ Tips:
 
 				secondary_build_started = true;
 
-				const { output } = /** @type {import('vite').Rollup.RollupOutput} */ (
+				const { output: client_chunks } = /** @type {import('vite').Rollup.RollupOutput} */ (
 					await vite.build({
 						configFile: vite_config.configFile,
 						// CLI args
@@ -886,7 +905,7 @@ Tips:
 						imports: [...start.imports, ...app.imports],
 						stylesheets: [...start.stylesheets, ...app.stylesheets],
 						fonts: [...start.fonts, ...app.fonts],
-						uses_env_dynamic_public: output.some(
+						uses_env_dynamic_public: client_chunks.some(
 							(chunk) => chunk.type === 'chunk' && chunk.modules[env_dynamic_public]
 						)
 					};
@@ -935,14 +954,14 @@ Tips:
 						imports: start.imports,
 						stylesheets: start.stylesheets,
 						fonts: start.fonts,
-						uses_env_dynamic_public: output.some(
+						uses_env_dynamic_public: client_chunks.some(
 							(chunk) => chunk.type === 'chunk' && chunk.modules[env_dynamic_public]
 						)
 					};
 
 					if (svelte_config.kit.output.bundleStrategy === 'inline') {
 						const style = /** @type {import('rollup').OutputAsset} */ (
-							output.find(
+							client_chunks.find(
 								(chunk) =>
 									chunk.type === 'asset' &&
 									chunk.names.length === 1 &&
@@ -957,11 +976,6 @@ Tips:
 					}
 				}
 
-				const css = output.filter(
-					/** @type {(value: any) => value is import('vite').Rollup.OutputAsset} */
-					(value) => value.type === 'asset' && value.fileName.endsWith('.css')
-				);
-
 				// regenerate manifest now that we have client entry...
 				fs.writeFileSync(
 					manifest_path,
@@ -980,7 +994,8 @@ Tips:
 					manifest_data,
 					server_manifest,
 					client_manifest,
-					css,
+					bundle,
+					client_chunks,
 					svelte_config.kit.output,
 					static_exports
 				);

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

@@ -4,23 +4,22 @@ import { read } from '../../../utils/filesystem.js';
 
 const inheritable_page_options = new Set(['ssr', 'prerender', 'csr', 'trailingSlash', 'config']);
 
-const page_options = new Set([...inheritable_page_options, 'entries']);
+const valid_page_options = new Set([...inheritable_page_options, 'entries']);
 
 const skip_parsing_regex = new RegExp(
-	`${Array.from(page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
+	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );
 
 const parser = Parser.extend(tsPlugin());
 
 /**
- * Collects exported page options from a +page.js/+layout.js file.
- * We ignore reassignments and use the declared value.
- * Returns `null` if any export is too difficult to analyse.
- * @param {string} filename
+ * Collects page options from a +page.js/+layout.js file, ignoring reassignments
+ * and using the declared value. Returns `null` if any export is too difficult to analyse.
+ * @param {string} filename The name of the file to report when an error occurs
  * @param {string} input
  * @returns {Record<string, any> | null}
  */
-export function statically_analyse_exports(filename, input) {
+export function statically_analyse_page_options(filename, input) {
 	// if there's a chance there are no page exports or export all declaration,
 	// then we can skip the AST parsing which is expensive
 	if (!skip_parsing_regex.test(input)) {
@@ -34,14 +33,14 @@ export function statically_analyse_exports(filename, input) {
 		});
 
 		/** @type {Map<string, import('acorn').Literal['value']>} */
-		const static_exports = new Map();
+		const page_options = new Map();
 
 		for (const statement of source.body) {
 			// ignore export all declarations with aliases that are not page options
 			if (
 				statement.type === 'ExportAllDeclaration' &&
 				statement.exported &&
-				!page_options.has(get_name(statement.exported))
+				!valid_page_options.has(get_name(statement.exported))
 			) {
 				continue;
 			}
@@ -60,7 +59,7 @@ export function statically_analyse_exports(filename, input) {
 				const export_specifiers = new Map();
 				for (const specifier of statement.specifiers) {
 					const exported_name = get_name(specifier.exported);
-					if (!page_options.has(exported_name)) {
+					if (!valid_page_options.has(exported_name)) {
 						continue;
 					}
 
@@ -109,7 +108,7 @@ export function statically_analyse_exports(filename, input) {
 								}
 
 								if (variable_declarator.init?.type === 'Literal') {
-									static_exports.set(
+									page_options.set(
 										/** @type {string} */ (export_specifiers.get(variable_declarator.id.name)),
 										variable_declarator.init.value
 									);
@@ -138,7 +137,7 @@ export function statically_analyse_exports(filename, input) {
 
 			// class and function declarations
 			if (statement.declaration.type !== 'VariableDeclaration') {
-				if (page_options.has(statement.declaration.id.name)) {
+				if (valid_page_options.has(statement.declaration.id.name)) {
 					return null;
 				}
 				continue;
@@ -149,12 +148,12 @@ export function statically_analyse_exports(filename, input) {
 					return null;
 				}
 
-				if (!page_options.has(declaration.id.name)) {
+				if (!valid_page_options.has(declaration.id.name)) {
 					continue;
 				}
 
 				if (declaration.init?.type === 'Literal') {
-					static_exports.set(declaration.id.name, declaration.init.value);
+					page_options.set(declaration.id.name, declaration.init.value);
 					continue;
 				}
 
@@ -163,10 +162,10 @@ export function statically_analyse_exports(filename, input) {
 			}
 		}
 
-		return Object.fromEntries(static_exports);
+		return Object.fromEntries(page_options);
 	} catch (error) {
 		if (error instanceof Error) {
-			error.message = `Failed to statically analyse ${filename}. ${error.message}`;
+			error.message = `Failed to statically analyse page options for ${filename}. ${error.message}`;
 		}
 		throw error;
 	}
@@ -183,65 +182,67 @@ export function get_name(node) {
 /**
  * @param {{
  *   resolve: (file: string) => Promise<Record<string, any>>;
- *   static_exports?: Map<string, Record<string, any> | null>;
+ *   static_exports?: Map<string, { page_options: Record<string, any> | null, children: string[] }>;
  * }} opts
  */
 export function create_node_analyser({ resolve, static_exports = new Map() }) {
 	/**
 	 * Computes the final page options for a node (if possible). Otherwise, returns `null`.
 	 * @param {import('types').PageNode} node
-	 * @returns {Promise<import('types').UniversalNode | null>}
+	 * @returns {Promise<Record<string, any> | null>}
 	 */
 	const get_page_options = async (node) => {
-		if (node.universal && static_exports.has(node.universal)) {
-			return /** @type {import('types').UniversalNode | null} */ (
-				static_exports.get(node.universal)
-			);
+		const key = node.universal || node.server;
+		if (key && static_exports.has(key)) {
+			return { ...static_exports.get(key)?.page_options };
 		}
 
-		/** @type {Record<string, any> | null} */
+		/** @type {Record<string, any>} */
 		let page_options = {};
 
-		if (node.server) {
-			const module = await resolve(node.server);
-			for (const key in inheritable_page_options) {
-				if (key in module) {
-					page_options[key] = module[key];
-				}
-			}
-		}
+		if (node.parent) {
+			const parent_options = await get_page_options(node.parent);
 
-		if (node.universal) {
-			let universal_exports = static_exports.get(node.universal);
-			if (universal_exports === undefined) {
-				const input = read(node.universal);
-				universal_exports = statically_analyse_exports(node.universal, input);
+			const parent_key = node.parent.universal || node.parent.server;
+			if (key && parent_key) {
+				static_exports.get(parent_key)?.children.push(key);
 			}
 
-			if (universal_exports === null) {
-				static_exports.set(node.universal, null);
+			if (parent_options === null) {
+				// if the parent cannot be analysed, we can't know what page options
+				// the child node inherits, so we also mark it as unanalysable
+				if (key) {
+					static_exports.set(key, { page_options: null, children: [] });
+				}
 				return null;
 			}
 
-			page_options = { ...page_options, ...universal_exports };
+			page_options = { ...parent_options };
 		}
 
-		if (node.parent) {
-			const parent_options = await get_page_options(node.parent);
-			if (parent_options === null) {
-				// if the parent cannot be statically analysed, we can't know what
-				// page options the current node inherits, so we invalidate it too
-				if (node.universal) {
-					static_exports.set(node.universal, null);
+		if (node.server) {
+			const module = await resolve(node.server);
+			for (const page_option in inheritable_page_options) {
+				if (page_option in module) {
+					page_options[page_option] = module[page_option];
 				}
+			}
+		}
+
+		if (node.universal) {
+			const input = read(node.universal);
+			const universal_page_options = statically_analyse_page_options(node.universal, input);
+
+			if (universal_page_options === null) {
+				static_exports.set(node.universal, { page_options: null, children: [] });
 				return null;
 			}
 
-			page_options = { ...parent_options, ...page_options };
+			page_options = { ...page_options, ...universal_page_options };
 		}
 
-		if (node.universal) {
-			static_exports.set(node.universal, page_options);
+		if (key) {
+			static_exports.set(key, { page_options, children: [] });
 		}
 
 		return page_options;
@@ -249,11 +250,14 @@ export function create_node_analyser({ resolve, static_exports = new Map() }) {
 
 	/**
 	 * @param {string} file
-	 * @returns {void}
 	 */
 	const invalidate_page_options = (file) => {
+		static_exports.get(file)?.children.forEach((child) => static_exports.delete(child));
 		static_exports.delete(file);
 	};
 
-	return { get_page_options, invalidate_page_options };
+	return {
+		get_page_options,
+		invalidate_page_options
+	};
 }

package/src/runtime/app/forms.js

@@ -1,10 +1,13 @@
 import * as devalue from 'devalue';
-import { DEV } from 'esm-env';
+import { BROWSER, DEV } from 'esm-env';
 import { invalidateAll } from './navigation.js';
-import { app, applyAction } from '../client/client.js';
+import { app as client_app, applyAction } from '../client/client.js';
+import { app as server_app } from '../server/app.js';
 
 export { applyAction };
 
+const decoders = BROWSER ? client_app.decoders : server_app?.decoders;
+
 /**
  * Use this function to deserialize the response from a form submission.
  * Usage:
@@ -31,7 +34,7 @@ export function deserialize(result) {
 	const parsed = JSON.parse(result);
 
 	if (parsed.data) {
-		parsed.data = devalue.parse(parsed.data, app.decoders);
+		parsed.data = devalue.parse(parsed.data, decoders);
 	}
 
 	return parsed;

package/src/runtime/client/client.js

@@ -312,12 +312,16 @@ export async function start(_app, _target, hydrate) {
 	// if we reload the page, or Cmd-Shift-T back to it,
 	// recover scroll position
 	const scroll = scroll_positions[current_history_index];
-	if (scroll) {
-		history.scrollRestoration = 'manual';
-		scrollTo(scroll.x, scroll.y);
+	function restore_scroll() {
+		if (scroll) {
+			history.scrollRestoration = 'manual';
+			scrollTo(scroll.x, scroll.y);
+		}
 	}
 
 	if (hydrate) {
+		restore_scroll();
+
 		await _hydrate(target, hydrate);
 	} else {
 		await navigate({
@@ -325,6 +329,8 @@ export async function start(_app, _target, hydrate) {
 			url: resolve_url(app.hash ? decode_hash(new URL(location.href)) : location.href),
 			replace_state: true
 		});
+
+		restore_scroll();
 	}
 
 	_start_router();
@@ -2794,22 +2800,43 @@ function reset_focus() {
 		autofocus.focus();
 	} else {
 		// Reset page selection and focus
-		// We try to mimic browsers' behaviour as closely as possible by targeting the
-		// first scrollable region, but unfortunately it's not a perfect match — e.g.
-		// shift-tabbing won't immediately cycle up from the end of the page on Chromium
-		// See https://html.spec.whatwg.org/multipage/interaction.html#get-the-focusable-area
-		const root = document.body;
-		const tabindex = root.getAttribute('tabindex');
-
-		root.tabIndex = -1;
-		// @ts-expect-error
-		root.focus({ preventScroll: true, focusVisible: false });
+		// TODO: find a fix that works with hash routing too
+		if (!app.hash && location.hash && document.querySelector(location.hash)) {
+			const { x, y } = scroll_state();
 
-		// restore `tabindex` as to prevent `root` from stealing input from elements
-		if (tabindex !== null) {
-			root.setAttribute('tabindex', tabindex);
+			setTimeout(() => {
+				const history_state = history.state;
+				// Mimic the browsers' behaviour and set the sequential focus navigation
+				// starting point to the fragment identifier
+				location.replace(location.hash);
+				// but Firefox has a bug that sets the history state as null so we
+				// need to restore the history state
+				// See https://bugzilla.mozilla.org/show_bug.cgi?id=1199924
+				history.replaceState(history_state, '', location.hash);
+
+				// Scroll management has already happened earlier so we need to restore
+				// the scroll position after setting the sequential focus navigation starting point
+				scrollTo(x, y);
+			});
 		} else {
-			root.removeAttribute('tabindex');
+			// We try to mimic browsers' behaviour as closely as possible by targeting the
+			// first scrollable region, but unfortunately it's not a perfect match — e.g.
+			// shift-tabbing won't immediately cycle up from the end of the page on Chromium
+			// See https://html.spec.whatwg.org/multipage/interaction.html#get-the-focusable-area
+			const root = document.body;
+			const tabindex = root.getAttribute('tabindex');
+
+			root.tabIndex = -1;
+			// @ts-expect-error options.focusVisible is only supported in Firefox
+			// See https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#browser_compatibility
+			root.focus({ preventScroll: true, focusVisible: false });
+
+			// restore `tabindex` as to prevent `root` from stealing input from elements
+			if (tabindex !== null) {
+				root.setAttribute('tabindex', tabindex);
+			} else {
+				root.removeAttribute('tabindex');
+			}
 		}
 
 		// capture current selection, so we can compare the state after

package/src/runtime/server/app.js

@@ -0,0 +1,9 @@
+/** @type {{ decoders: Record<string, (data: any) => any> }} */
+export let app;
+
+/**
+ * @param {{ decoders: Record<string, (data: any) => any> }} value
+ */
+export function set_app(value) {
+	app = value;
+}

package/src/runtime/server/index.js

@@ -5,6 +5,7 @@ import { DEV } from 'esm-env';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { prerendering } from '__sveltekit/environment';
 import { set_read_implementation, set_manifest } from '__sveltekit/server';
+import { set_app } from './app.js';
 
 /** @type {ProxyHandler<{ type: 'public' | 'private' }>} */
 const prerender_env_handler = {
@@ -74,12 +75,21 @@ export class Server {
 
 				this.#options.hooks = {
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
-					handleError: module.handleError || (({ error }) => console.error(error)),
+					handleError:
+						module.handleError ||
+						(({ status, error }) =>
+							console.error((status === 404 && /** @type {Error} */ (error)?.message) || error)),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
 					reroute: module.reroute || (() => {}),
 					transport: module.transport || {}
 				};
 
+				set_app({
+					decoders: module.transport
+						? Object.fromEntries(Object.entries(module.transport).map(([k, v]) => [k, v.decode]))
+						: {}
+				});
+
 				if (module.init) {
 					await module.init();
 				}
@@ -94,6 +104,10 @@ export class Server {
 						reroute: () => {},
 						transport: {}
 					};
+
+					set_app({
+						decoders: {}
+					});
 				} else {
 					throw error;
 				}

package/src/runtime/server/respond.js

@@ -51,6 +51,8 @@ const page_methods = new Set(['GET', 'HEAD', 'POST']);
 
 const allowed_page_methods = new Set(['GET', 'HEAD', 'OPTIONS']);
 
+let warned_on_devtools_json_request = false;
+
 /**
  * @param {Request} request
  * @param {import('types').SSROptions} options
@@ -573,6 +575,21 @@ export async function respond(request, options, manifest, state) {
 			// if this request came direct from the user, rather than
 			// via our own `fetch`, render a 404 page
 			if (state.depth === 0) {
+				// In local development, Chrome requests this file for its 'automatic workspace folders' feature,
+				// causing console spam. If users want to serve this file they can install
+				// https://github.com/ChromeDevTools/vite-plugin-devtools-json
+				if (DEV && event.url.pathname === '/.well-known/appspecific/com.chrome.devtools.json') {
+					if (!warned_on_devtools_json_request) {
+						console.warn(
+							`\nGoogle Chrome is requesting ${event.url.pathname} to automatically configure devtools project settings. To serve this file, add this plugin to your Vite config:\n\nhttps://github.com/ChromeDevTools/vite-plugin-devtools-json\n`
+						);
+
+						warned_on_devtools_json_request = true;
+					}
+
+					return new Response(undefined, { status: 404 });
+				}
+
 				return await respond_with_error({
 					event,
 					options,

package/src/version.js

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

package/types/index.d.ts

@@ -450,7 +450,7 @@ declare module '@sveltejs/kit' {
 			errorTemplate?: string;
 		};
 		/**
-		 * Inline CSS inside a `<style>` block at the head of the HTML. This option is a number that specifies the maximum length of a CSS file in UTF-16 code units, as specified by the [String.length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) property, to be inlined. All CSS files needed for the page and smaller than this value are merged and inlined in a `<style>` block.
+		 * Inline CSS inside a `<style>` block at the head of the HTML. This option is a number that specifies the maximum length of a CSS file in UTF-16 code units, as specified by the [String.length](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length) property, to be inlined. All CSS files needed for the page that are smaller than this value are merged and inlined in a `<style>` block.
 		 *
 		 * > [!NOTE] This results in fewer initial requests and can improve your [First Contentful Paint](https://web.dev/first-contentful-paint) score. However, it generates larger HTML output and reduces the effectiveness of browser caches. Use it advisedly.
 		 * @default 0

package/types/index.d.ts.map

@@ -169,6 +169,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }