@sveltejs/kit 2.51.0 → 2.52.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.51.0",
+  "version": "2.52.2",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -23,12 +23,11 @@
     "@types/cookie": "^0.6.0",
     "acorn": "^8.14.1",
     "cookie": "^0.6.0",
-    "devalue": "^5.6.2",
+    "devalue": "^5.6.3",
     "esm-env": "^1.2.2",
     "kleur": "^4.1.5",
     "magic-string": "^0.30.5",
     "mrmime": "^2.0.0",
-    "sade": "^1.8.1",
     "set-cookie-parser": "^3.0.0",
     "sirv": "^3.0.0"
   },
@@ -41,7 +40,7 @@
     "@types/set-cookie-parser": "^2.4.7",
     "dts-buddy": "^0.6.2",
     "rollup": "^4.14.2",
-    "svelte": "^5.48.4",
+    "svelte": "^5.51.5",
     "svelte-preprocess": "^6.0.0",
     "typescript": "^5.3.3",
     "vite": "^6.3.5",

package/src/cli.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import process from 'node:process';
+import { parseArgs } from 'node:util';
 import colors from 'kleur';
-import sade from 'sade';
 import { load_config } from './core/config/index.js';
 import { coalesce_to_error } from './utils/error.js';
 
@@ -20,28 +20,76 @@ function handle_error(e) {
 }
 
 const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
-const prog = sade('svelte-kit').version(pkg.version);
-
-prog
-	.command('sync')
-	.describe('Synchronise generated type definitions')
-	.option('--mode', 'Specify a mode for loading environment variables', 'development')
-	.action(async ({ mode }) => {
-		const config_files = ['js', 'ts']
-			.map((ext) => `svelte.config.${ext}`)
-			.filter((f) => fs.existsSync(f));
-		if (config_files.length === 0) {
-			console.warn(`Missing Svelte config file in ${process.cwd()} — skipping`);
-			return;
-		}
-
-		try {
-			const config = await load_config();
-			const sync = await import('./core/sync/sync.js');
-			sync.all_types(config, mode);
-		} catch (error) {
-			handle_error(error);
-		}
+
+const help = `
+  Usage: svelte-kit <command> [options]
+
+  Commands:
+    sync        Synchronise generated type definitions
+
+  Options:
+    --version, -v   Show version number
+    --help, -h      Show this help message
+
+  Sync Options:
+    --mode <mode>   Specify a mode for loading environment variables (default: development)
+`;
+
+let parsed;
+try {
+	parsed = parseArgs({
+		options: {
+			version: { type: 'boolean', short: 'v' },
+			help: { type: 'boolean', short: 'h' },
+			mode: { type: 'string', default: 'development' }
+		},
+		allowPositionals: true,
+		strict: true
 	});
+} catch (err) {
+	const error = /** @type {Error} */ (err);
+	console.error(colors.bold().red(`> ${error.message}`));
+	console.log(help);
+	process.exit(1);
+}
+
+const { values, positionals } = parsed;
+
+if (values.version) {
+	console.log(pkg.version);
+	process.exit(0);
+}
 
-prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });
+if (values.help) {
+	console.log(help);
+	process.exit(0);
+}
+
+const command = positionals[0];
+
+if (!command) {
+	console.log(help);
+	process.exit(0);
+}
+
+if (command === 'sync') {
+	const config_files = ['js', 'ts']
+		.map((ext) => `svelte.config.${ext}`)
+		.filter((f) => fs.existsSync(f));
+	if (config_files.length === 0) {
+		console.warn(`Missing Svelte config file in ${process.cwd()} — skipping`);
+		process.exit(0);
+	}
+
+	try {
+		const config = await load_config();
+		const sync = await import('./core/sync/sync.js');
+		sync.all_types(config, values.mode);
+	} catch (error) {
+		handle_error(error);
+	}
+} else {
+	console.error(colors.bold().red(`> Unknown command: ${command}`));
+	console.log(help);
+	process.exit(1);
+}

package/src/core/adapt/builder.js

@@ -19,7 +19,7 @@ import { find_server_assets } from '../generate_manifest/find_server_assets.js';
 import { reserved } from '../env.js';
 
 const pipe = promisify(pipeline);
-const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.wasm'];
+const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.wasm', '.txt'];
 
 /**
  * Creates the Builder which is passed to adapters for building the application.

package/src/core/postbuild/analyse.js

@@ -65,21 +65,8 @@ 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
-	await build_server_nodes(
-		out,
-		config,
-		manifest_data,
-		server_manifest,
-		null,
-		null,
-		null,
-		output_config,
-		static_exports
-	);
+	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null, output_config);
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -188,7 +175,7 @@ async function analyse({
 		metadata.remotes.set(remote.hash, exports);
 	}
 
-	return { metadata, static_exports };
+	return { metadata };
 }
 
 /**

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

@@ -8,6 +8,10 @@ import { posixify, resolve_entry } from '../../../utils/filesystem.js';
 import { parse_route_id } from '../../../utils/routing.js';
 import { sort_routes } from './sort.js';
 import { isSvelte5Plus } from '../utils.js';
+import {
+	create_node_analyser,
+	get_page_options
+} from '../../../exports/vite/static_analysis/index.js';
 
 /**
  * Generates the manifest data used for the client-side manifest and types generation.
@@ -342,7 +346,8 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					}
 
 					route.endpoint = {
-						file: project_relative
+						file: project_relative,
+						page_options: null // will be filled later
 					};
 				}
 			}
@@ -415,6 +420,8 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 	const indexes = new Map(nodes.map((node, i) => [node, i]));
 
+	const node_analyser = create_node_analyser();
+
 	for (const route of routes) {
 		if (!route.leaf) continue;
 
@@ -459,6 +466,16 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 	}
 
+	for (const node of nodes) {
+		node.page_options = node_analyser.get_page_options(node);
+	}
+
+	for (const route of routes) {
+		if (route.endpoint) {
+			route.endpoint.page_options = get_page_options(route.endpoint.file);
+		}
+	}
+
 	return {
 		nodes,
 		routes: sort_routes(routes)

package/src/core/sync/sync.js

@@ -7,6 +7,10 @@ import { write_types, write_all_types } from './write_types/index.js';
 import { write_ambient } from './write_ambient.js';
 import { write_non_ambient } from './write_non_ambient.js';
 import { write_server } from './write_server.js';
+import {
+	create_node_analyser,
+	get_page_options
+} from '../../exports/vite/static_analysis/index.js';
 
 /**
  * Initialize SvelteKit's generated files that only depend on the config and mode.
@@ -45,7 +49,20 @@ export function create(config) {
  * @param {string} file
  */
 export function update(config, manifest_data, file) {
+	const node_analyser = create_node_analyser();
+
+	for (const node of manifest_data.nodes) {
+		node.page_options = node_analyser.get_page_options(node);
+	}
+
+	for (const route of manifest_data.routes) {
+		if (route.endpoint) {
+			route.endpoint.page_options = get_page_options(route.endpoint.file);
+		}
+	}
+
 	write_types(config, manifest_data, file);
+	write_non_ambient(config.kit, manifest_data);
 }
 
 /**

package/src/core/sync/write_non_ambient.js

@@ -13,6 +13,40 @@ const remove_group_segments = (/** @type {string} */ id) => {
 	return '/' + get_route_segments(id).join('/');
 };
 
+/**
+ * Get pathnames to add based on trailingSlash settings
+ * @param {string} pathname
+ * @param {import('types').RouteData} route
+ * @returns {string[]}
+ */
+function get_pathnames_for_trailing_slash(pathname, route) {
+	if (pathname === '/') {
+		return [pathname];
+	}
+
+	/** @type {({ trailingSlash?: import('types').TrailingSlash } | null)[]} */
+	const routes = [];
+
+	if (route.leaf) routes.push(route.leaf.page_options ?? null);
+	if (route.endpoint) routes.push(route.endpoint.page_options);
+
+	/** @type {Set<string>} */
+	const pathnames = new Set();
+
+	for (const page_options of routes) {
+		if (page_options === null || page_options.trailingSlash === 'ignore') {
+			pathnames.add(pathname);
+			pathnames.add(pathname + '/');
+		} else if (page_options.trailingSlash === 'always') {
+			pathnames.add(pathname + '/');
+		} else {
+			pathnames.add(pathname);
+		}
+	}
+
+	return Array.from(pathnames);
+}
+
 // `declare module "svelte/elements"` needs to happen in a non-ambient module, and dts-buddy generates one big ambient module,
 // so we can't add it there - therefore generate the typings ourselves here.
 // We're not using the `declare namespace svelteHTML` variant because that one doesn't augment the HTMLAttributes interface
@@ -67,19 +101,14 @@ function generate_app_types(manifest_data) {
 
 			const pathname = remove_group_segments(route.id);
 			const replaced_pathname = replace_required_params(replace_optional_params(pathname));
-			pathnames.add(`\`${replaced_pathname}\` & {}`);
 
-			if (pathname !== '/') {
-				// Support trailing slash
-				pathnames.add(`\`${replaced_pathname + '/'}\` & {}`);
+			for (const p of get_pathnames_for_trailing_slash(replaced_pathname, route)) {
+				pathnames.add(`\`${p}\` & {}`);
 			}
 		} else {
 			const pathname = remove_group_segments(route.id);
-			pathnames.add(s(pathname));
-
-			if (pathname !== '/') {
-				// Support trailing slash
-				pathnames.add(s(pathname + '/'));
+			for (const p of get_pathnames_for_trailing_slash(pathname, route)) {
+				pathnames.add(s(p));
 			}
 		}
 

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

@@ -1,40 +1,11 @@
 import fs from 'node:fs';
 import { mkdirp } from '../../../utils/filesystem.js';
-import { filter_fonts, find_deps, resolve_symlinks } from './utils.js';
+import { create_function_as_string, filter_fonts, find_deps, resolve_symlinks } from './utils.js';
 import { s } from '../../../utils/misc.js';
 import { normalizePath } from 'vite';
-import { basename, join } from 'node:path';
-import { create_node_analyser } from '../static_analysis/index.js';
+import { basename } from 'node:path';
 import { fix_css_urls } from '../../../utils/css.js';
 
-/**
- * Regenerate server nodes after acquiring client manifest
- * @overload
- * @param {string} out
- * @param {import('types').ValidatedKitConfig} kit
- * @param {import('types').ManifestData} manifest_data
- * @param {import('vite').Manifest} server_manifest
- * @param {import('vite').Manifest} client_manifest
- * @param {string} assets_path
- * @param {import('vite').Rollup.RollupOutput['output']} client_chunks
- * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
- * @returns {Promise<void>}
- */
-/**
- * Build server nodes without client manifest for analysis phase
- * @overload
- * @param {string} out
- * @param {import('types').ValidatedKitConfig} kit
- * @param {import('types').ManifestData} manifest_data
- * @param {import('vite').Manifest} server_manifest
- * @param {null} client_manifest
- * @param {null} assets_path
- * @param {null} client_chunks
- * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
- * @returns {Promise<void>}
- */
 /**
  * @param {string} out
  * @param {import('types').ValidatedKitConfig} kit
@@ -44,9 +15,8 @@ import { fix_css_urls } from '../../../utils/css.js';
  * @param {string | null} assets_path
  * @param {import('vite').Rollup.RollupOutput['output'] | null} client_chunks
  * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
- * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
  */
-export async function build_server_nodes(
+export function build_server_nodes(
 	out,
 	kit,
 	manifest_data,
@@ -54,8 +24,7 @@ export async function build_server_nodes(
 	client_manifest,
 	assets_path,
 	client_chunks,
-	output_config,
-	static_exports
+	output_config
 ) {
 	mkdirp(`${out}/server/nodes`);
 	mkdirp(`${out}/server/stylesheets`);
@@ -109,23 +78,14 @@ export async function build_server_nodes(
 
 				// only convert to a function if we have adjusted any URLs
 				if (css !== transformed_css) {
-					return `function css(assets, base) { return \`${s(transformed_css).slice(1, -1)}\`; }`;
+					return create_function_as_string('css', ['assets', 'base'], transformed_css);
 				}
+
 				return s(css);
 			};
 		}
 	}
 
-	const { get_page_options } = create_node_analyser({
-		resolve: (server_node) => {
-			// Windows needs the file:// protocol for absolute path dynamic imports
-			return import(
-				`file://${join(out, 'server', resolve_symlinks(server_manifest, server_node).chunk.file)}`
-			);
-		},
-		static_exports
-	});
-
 	for (let i = 0; i < manifest_data.nodes.length; i++) {
 		const node = manifest_data.nodes[i];
 
@@ -159,9 +119,8 @@ export async function build_server_nodes(
 		}
 
 		if (node.universal) {
-			const page_options = await get_page_options(node);
-			if (!!page_options && page_options.ssr === false) {
-				exports.push(`export const universal = ${s(page_options, null, 2)};`);
+			if (!!node.page_options && node.page_options.ssr === false) {
+				exports.push(`export const universal = ${s(node.page_options, null, 2)};`);
 			} else {
 				imports.push(
 					`import * as universal from '../${resolve_symlinks(server_manifest, node.universal).chunk.file}';`

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

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { normalizePath } from 'vite';
+import { s } from '../../../utils/misc.js';
 
 /**
  * Adds transitive JS and CSS dependencies to the js and css inputs.
@@ -129,3 +130,18 @@ export function filter_fonts(assets) {
 export function assets_base(config) {
 	return (config.paths.assets || config.paths.base || '.') + '/';
 }
+
+/**
+ * Writes a function with arguments used by a template literal.
+ * This helps us store strings in a module and inject values at runtime.
+ * @param {string} name The name of the function
+ * @param {string[]} placeholder_names The names of the placeholders in the string
+ * @param {string} str A string with placeholders such as "Hello ${arg0}".
+ * 										 It must have backticks and dollar signs escaped.
+ * @returns {string} The function written as a string
+ */
+export function create_function_as_string(name, placeholder_names, str) {
+	str = s(str).slice(1, -1);
+	const args = placeholder_names ? placeholder_names.join(', ') : '';
+	return `function ${name}(${args}) { return \`${str}\`; }`;
+}

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

@@ -19,7 +19,6 @@ import { not_found } from '../utils.js';
 import { SCHEME } from '../../../utils/url.js';
 import { check_feature } from '../../../utils/features.js';
 import { escape_html } from '../../../utils/escape.js';
-import { create_node_analyser } from '../static_analysis/index.js';
 
 const cwd = process.cwd();
 // vite-specifc queries that we should skip handling for css urls
@@ -103,9 +102,6 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 		return { module, module_node, url };
 	}
 
-	/** @type {(file: string) => void} */
-	let invalidate_page_options;
-
 	function update_manifest() {
 		try {
 			({ manifest_data } = sync.create(svelte_config));
@@ -129,14 +125,6 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 			return;
 		}
 
-		const node_analyser = create_node_analyser({
-			resolve: async (server_node) => {
-				const { module } = await resolve(server_node);
-				return module;
-			}
-		});
-		invalidate_page_options = node_analyser.invalidate_page_options;
-
 		manifest = {
 			appDir: svelte_config.kit.appDir,
 			appPath: svelte_config.kit.appDir,
@@ -215,9 +203,8 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 						}
 
 						if (node.universal) {
-							const page_options = await node_analyser.get_page_options(node);
-							if (page_options?.ssr === false) {
-								result.universal = page_options;
+							if (node.page_options?.ssr === false) {
+								result.universal = node.page_options;
 							} else {
 								// TODO: explain why the file was loaded on the server if we fail to load it
 								const { module, module_node } = await resolve(node.universal);
@@ -370,12 +357,8 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 	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));
-		}
-
+		// Unless it's a file where the trailing slash page option might have changed
+		if (timeout || restarting || !/\+(page|layout|server).*$/.test(file)) return;
 		sync.update(svelte_config, manifest_data, file);
 	});
 

package/src/exports/vite/index.js

@@ -1063,7 +1063,7 @@ async function kit({ svelte_config }) {
 
 				log.info('Analysing routes');
 
-				const { metadata, static_exports } = await analyse({
+				const { metadata } = await analyse({
 					hash: kit.router.type === 'hash',
 					manifest_path,
 					manifest_data,
@@ -1263,7 +1263,7 @@ async function kit({ svelte_config }) {
 				);
 
 				// regenerate nodes with the client manifest...
-				await build_server_nodes(
+				build_server_nodes(
 					out,
 					kit,
 					manifest_data,
@@ -1271,8 +1271,7 @@ async function kit({ svelte_config }) {
 					client_manifest,
 					assets_path,
 					client_chunks,
-					svelte_config.kit.output,
-					static_exports
+					svelte_config.kit.output
 				);
 
 				// ...and prerender

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

@@ -2,9 +2,21 @@ import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { Parser } from 'acorn';
 import { read } from '../../../utils/filesystem.js';
 
-const inheritable_page_options = new Set(['ssr', 'prerender', 'csr', 'trailingSlash', 'config']);
-
-const valid_page_options = new Set([...inheritable_page_options, 'entries', 'load']);
+const valid_page_options_array = /** @type {const} */ ([
+	'ssr',
+	'prerender',
+	'csr',
+	'trailingSlash',
+	'config',
+	'entries',
+	'load'
+]);
+
+/** @type {Set<string>} */
+const valid_page_options = new Set(valid_page_options_array);
+
+/** @typedef {typeof valid_page_options_array[number]} ValidPageOption */
+/** @typedef {Partial<Record<ValidPageOption, any>>} PageOptions */
 
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
@@ -18,11 +30,11 @@ const parser = Parser.extend(tsPlugin());
  * 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}
+ * @returns {PageOptions | null}
  */
 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 there's a chance there are no page exports or an unparseable
+	// export all declaration, then we can skip the AST parsing which is expensive
 	if (!skip_parsing_regex.test(input)) {
 		return {};
 	}
@@ -194,33 +206,56 @@ export function statically_analyse_page_options(filename, input) {
  * @param {import('acorn').Identifier | import('acorn').Literal} node
  * @returns {string}
  */
-export function get_name(node) {
+function get_name(node) {
 	return node.type === 'Identifier' ? node.name : /** @type {string} */ (node.value);
 }
 
 /**
- * @param {{
- *   resolve: (file: string) => Promise<Record<string, any>>;
- *   static_exports?: Map<string, { page_options: Record<string, any> | null, children: string[] }>;
- * }} opts
+ * Reads and statically analyses a file for page options
+ * @param {string} filepath
+ * @returns {PageOptions | null} Returns the page options for the file or `null` if unanalysable
  */
-export function create_node_analyser({ resolve, static_exports = new Map() }) {
+export function get_page_options(filepath) {
+	try {
+		const input = read(filepath);
+		const page_options = statically_analyse_page_options(filepath, input);
+		if (page_options === null) {
+			return null;
+		}
+
+		return page_options;
+	} catch {
+		return null;
+	}
+}
+
+export function create_node_analyser() {
+	const static_exports = new Map();
+
+	/**
+	 * @param {string | undefined} key
+	 * @param {PageOptions | null} page_options
+	 */
+	const cache = (key, page_options) => {
+		if (key) static_exports.set(key, { page_options, children: [] });
+	};
+
 	/**
 	 * Computes the final page options (may include load function as `load: null`; special case) for a node (if possible). Otherwise, returns `null`.
 	 * @param {import('types').PageNode} node
-	 * @returns {Promise<Record<string, any> | null>}
+	 * @returns {PageOptions | null}
 	 */
-	const get_page_options = async (node) => {
+	const crawl = (node) => {
 		const key = node.universal || node.server;
 		if (key && static_exports.has(key)) {
 			return { ...static_exports.get(key)?.page_options };
 		}
 
-		/** @type {Record<string, any>} */
+		/** @type {PageOptions} */
 		let page_options = {};
 
 		if (node.parent) {
-			const parent_options = await get_page_options(node.parent);
+			const parent_options = crawl(node.parent);
 
 			const parent_key = node.parent.universal || node.parent.server;
 			if (key && parent_key) {
@@ -230,9 +265,7 @@ export function create_node_analyser({ resolve, static_exports = new Map() }) {
 			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: [] });
-				}
+				cache(key, null);
 				return null;
 			}
 
@@ -240,43 +273,29 @@ export function create_node_analyser({ resolve, static_exports = new Map() }) {
 		}
 
 		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];
-				}
+			const server_page_options = get_page_options(node.server);
+			if (server_page_options === null) {
+				cache(key, null);
+				return null;
 			}
+			page_options = { ...page_options, ...server_page_options };
 		}
 
 		if (node.universal) {
-			const input = read(node.universal);
-			const universal_page_options = statically_analyse_page_options(node.universal, input);
-
+			const universal_page_options = get_page_options(node.universal);
 			if (universal_page_options === null) {
-				static_exports.set(node.universal, { page_options: null, children: [] });
+				cache(key, null);
 				return null;
 			}
-
 			page_options = { ...page_options, ...universal_page_options };
 		}
 
-		if (key) {
-			static_exports.set(key, { page_options, children: [] });
-		}
+		cache(key, page_options);
 
 		return page_options;
 	};
 
-	/**
-	 * @param {string} file
-	 */
-	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
+		get_page_options: crawl
 	};
 }

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

@@ -2,6 +2,7 @@
 /** @import { ResolveArgs } from './types.js' */
 import { base, assets, hash_routing } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
+import { get_navigation_intent } from '../../client/client.js';
 
 /**
  * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.kit.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
@@ -58,4 +59,41 @@ export function resolve(...args) {
 	);
 }
 
+/**
+ * Match a path or URL to a route ID and extracts any parameters.
+ *
+ * @example
+ * ```js
+ * import { match } from '$app/paths';
+ *
+ * const route = await match('/blog/hello-world');
+ *
+ * if (route?.id === '/blog/[slug]') {
+ * 	const slug = route.params.slug;
+ * 	const response = await fetch(`/api/posts/${slug}`);
+ * 	const post = await response.json();
+ * }
+ * ```
+ * @since 2.52.0
+ *
+ * @param {Pathname | URL | (string & {})} url
+ * @returns {Promise<{ id: RouteId, params: Record<string, string> } | null>}
+ */
+export async function match(url) {
+	if (typeof url === 'string') {
+		url = new URL(url, location.href);
+	}
+
+	const intent = await get_navigation_intent(url, false);
+
+	if (intent) {
+		return {
+			id: /** @type {RouteId} */ (intent.route.id),
+			params: intent.params
+		};
+	}
+
+	return null;
+}
+
 export { base, assets, resolve as resolveRoute };

package/src/runtime/app/paths/public.d.ts

@@ -1,7 +1,7 @@
 import { RouteId, Pathname, ResolvedPathname } from '$app/types';
 import { ResolveArgs } from './types.js';
 
-export { resolve, asset } from './client.js';
+export { resolve, asset, match } from './client.js';
 
 /**
  * A string that matches [`config.kit.paths.base`](https://svelte.dev/docs/kit/configuration#paths).

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

@@ -1,6 +1,9 @@
 import { base, assets, relative, initial_base } from './internal/server.js';
-import { resolve_route } from '../../../utils/routing.js';
+import { resolve_route, find_route } from '../../../utils/routing.js';
+import { decode_pathname } from '../../../utils/url.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
+import { manifest } from '__sveltekit/server';
+import { get_hooks } from '__SERVER__/internal.js';
 
 /** @type {import('./client.js').asset} */
 export function asset(file) {
@@ -27,4 +30,42 @@ export function resolve(id, params) {
 	return base + resolved;
 }
 
+/** @type {import('./client.js').match} */
+export async function match(url) {
+	const store = try_get_request_store();
+
+	if (typeof url === 'string') {
+		const origin = store?.event.url.origin ?? 'http://internal';
+		url = new URL(url, origin);
+	}
+
+	const { reroute } = await get_hooks();
+
+	let resolved_path = url.pathname;
+
+	try {
+		resolved_path = decode_pathname(
+			(await reroute?.({ url: new URL(url), fetch: store?.event.fetch ?? fetch })) ?? url.pathname
+		);
+	} catch {
+		return null;
+	}
+
+	if (base && resolved_path.startsWith(base)) {
+		resolved_path = resolved_path.slice(base.length) || '/';
+	}
+
+	const matchers = await manifest._.matchers();
+	const result = find_route(resolved_path, manifest._.routes, matchers);
+
+	if (result) {
+		return {
+			id: /** @type {import('$app/types').RouteId} */ (result.route.id),
+			params: result.params
+		};
+	}
+
+	return null;
+}
+
 export { base, assets, resolve as resolveRoute };

package/src/runtime/client/client.js

@@ -1401,7 +1401,7 @@ async function get_rerouted_url(url) {
  * @param {boolean} invalidating
  * @returns {Promise<import('./types.js').NavigationIntent | undefined>}
  */
-async function get_navigation_intent(url, invalidating) {
+export async function get_navigation_intent(url, invalidating) {
 	if (!url) return;
 	if (is_external_url(url, base, app.hash)) return;
 
@@ -1761,26 +1761,18 @@ async function navigate({
 	await svelte.tick();
 
 	// we reset scroll before dealing with focus, to avoid a flash of unscrolled content
-	let scroll = popped ? popped.scroll : noscroll ? scroll_state() : null;
+	/** @type {Element | null | ''} */
+	let deep_linked = null;
 
 	if (autoscroll) {
-		const deep_linked = url.hash && document.getElementById(get_id(url));
+		const scroll = popped ? popped.scroll : noscroll ? scroll_state() : null;
 		if (scroll) {
 			scrollTo(scroll.x, scroll.y);
-		} else if (deep_linked) {
+		} else if ((deep_linked = url.hash && document.getElementById(get_id(url)))) {
 			// Here we use `scrollIntoView` on the element instead of `scrollTo`
 			// because it natively supports the `scroll-margin` and `scroll-behavior`
 			// CSS properties.
 			deep_linked.scrollIntoView();
-
-			// Get target position at this point because with smooth scrolling the scroll position
-			// retrieved from current x/y above might be wrong (since we might not have arrived at the destination yet)
-			const { top, left } = deep_linked.getBoundingClientRect();
-
-			scroll = {
-				x: pageXOffset + left,
-				y: pageYOffset + top
-			};
 		} else {
 			scrollTo(0, 0);
 		}
@@ -1794,7 +1786,10 @@ async function navigate({
 		document.activeElement !== document.body;
 
 	if (!keepfocus && !changed_focus) {
-		reset_focus(url, scroll);
+		// We don't need to manually restore the scroll position if we're navigating
+		// to a fragment identifier. It is automatically done for us when we set the
+		// sequential navigation starting point with `location.replace`
+		reset_focus(url, !deep_linked);
 	}
 
 	autoscroll = true;
@@ -2999,9 +2994,9 @@ let resetting_focus = false;
 
 /**
  * @param {URL} url
- * @param {{ x: number, y: number } | null} scroll
+ * @param {boolean} [scroll]
  */
-function reset_focus(url, scroll = null) {
+function reset_focus(url, scroll = true) {
 	const autofocus = document.querySelector('[autofocus]');
 	if (autofocus) {
 		// @ts-ignore
@@ -3013,7 +3008,7 @@ function reset_focus(url, scroll = null) {
 		// starting point to the fragment identifier.
 		const id = get_id(url);
 		if (id && document.getElementById(id)) {
-			const { x, y } = scroll ?? scroll_state();
+			const { x, y } = scroll_state();
 
 			// `element.focus()` doesn't work on Safari and Firefox Ubuntu so we need
 			// to use this hack with `location.replace()` instead.
@@ -3028,9 +3023,9 @@ function reset_focus(url, scroll = null) {
 				// This is also needed to restore the original hash if we're using hash routing
 				history.replaceState(history_state, '', url);
 
-				// Scroll management has already happened earlier so we need to restore
+				// If scroll management has already happened earlier, we need to restore
 				// the scroll position after setting the sequential focus navigation starting point
-				scrollTo(x, y);
+				if (scroll) scrollTo(x, y);
 				resetting_focus = false;
 			});
 		} else {

package/src/runtime/client/remote-functions/form.svelte.js

@@ -110,6 +110,10 @@ export function form(id) {
 
 			submitted = true;
 
+			// Increment pending count immediately so that `pending` reflects
+			// the in-progress state during async preflight validation
+			pending_count++;
+
 			const validated = await preflight_schema?.['~standard'].validate(data);
 
 			if (validated?.issues) {
@@ -118,9 +122,15 @@ export function form(id) {
 					raw_issues,
 					validated.issues.map((issue) => normalize_issue(issue, false))
 				);
+				pending_count--;
 				return;
 			}
 
+			// Preflight passed - clear stale client-side preflight issues
+			if (preflight_schema) {
+				raw_issues = raw_issues.filter((issue) => issue.server);
+			}
+
 			// TODO 3.0 remove this warning
 			if (DEV) {
 				const error = () => {
@@ -174,9 +184,6 @@ export function form(id) {
 				entry.count++;
 			}
 
-			// Increment pending count when submission starts
-			pending_count++;
-
 			/** @type {Array<Query<any> | RemoteQueryOverride>} */
 			let updates = [];
 

package/src/runtime/form-utils.js

@@ -254,14 +254,30 @@ export async function deserialize_binary_form(request) {
 		const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
 		if (!file_offsets_buffer) throw deserialize_error('file offset table too short');
 
-		file_offsets = /** @type {Array<number>} */ (
-			JSON.parse(text_decoder.decode(file_offsets_buffer))
-		);
+		const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
+
+		if (
+			!Array.isArray(parsed_offsets) ||
+			parsed_offsets.some((n) => typeof n !== 'number' || !Number.isInteger(n) || n < 0)
+		) {
+			throw deserialize_error('invalid file offset table');
+		}
+
+		file_offsets = /** @type {Array<number>} */ (parsed_offsets);
 		files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
 	}
 
 	const [data, meta] = devalue.parse(text_decoder.decode(data_buffer), {
 		File: ([name, type, size, last_modified, index]) => {
+			if (
+				typeof name !== 'string' ||
+				typeof type !== 'string' ||
+				typeof size !== 'number' ||
+				typeof last_modified !== 'number' ||
+				typeof index !== 'number'
+			) {
+				throw deserialize_error('invalid file metadata');
+			}
 			if (files_start_offset + file_offsets[index] + size > content_length) {
 				throw deserialize_error('file data overflow');
 			}

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

@@ -1,8 +1,7 @@
 import { base, assets, relative } from '$app/paths/internal/server';
 import { text } from '@sveltejs/kit';
 import { s } from '../../../utils/misc.js';
-import { exec } from '../../../utils/routing.js';
-import { decode_params } from '../../../utils/url.js';
+import { find_route } from '../../../utils/routing.js';
 import { get_relative_path } from '../../utils.js';
 
 /**
@@ -69,26 +68,11 @@ export async function resolve_route(resolved_path, url, manifest) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
-	/** @type {import('types').SSRClientRoute | null} */
-	let route = null;
-	/** @type {Record<string, string>} */
-	let params = {};
-
 	const matchers = await manifest._.matchers();
+	const result = find_route(resolved_path, manifest._.client.routes, matchers);
 
-	for (const candidate of manifest._.client.routes) {
-		const match = candidate.pattern.exec(resolved_path);
-		if (!match) continue;
-
-		const matched = exec(match, candidate.params, matchers);
-		if (matched) {
-			route = candidate;
-			params = decode_params(matched);
-			break;
-		}
-	}
-
-	return create_server_routing_response(route, params, url, manifest).response;
+	return create_server_routing_response(result?.route ?? null, result?.params ?? {}, url, manifest)
+		.response;
 }
 
 /**

package/src/runtime/server/respond.js

@@ -15,8 +15,8 @@ import {
 	method_not_allowed,
 	redirect_response
 } from './utils.js';
-import { decode_pathname, decode_params, disable_search, normalize_path } from '../../utils/url.js';
-import { exec } from '../../utils/routing.js';
+import { decode_pathname, disable_search, normalize_path } from '../../utils/url.js';
+import { find_route } from '../../utils/routing.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';
@@ -309,18 +309,12 @@ export async function internal_respond(request, options, manifest, state) {
 	if (!state.prerendering?.fallback) {
 		// TODO this could theoretically break — should probably be inside a try-catch
 		const matchers = await manifest._.matchers();
+		const result = find_route(resolved_path, manifest._.routes, matchers);
 
-		for (const candidate of manifest._.routes) {
-			const match = candidate.pattern.exec(resolved_path);
-			if (!match) continue;
-
-			const matched = exec(match, candidate.params, matchers);
-			if (matched) {
-				route = candidate;
-				event.route = { id: route.id };
-				event.params = decode_params(matched);
-				break;
-			}
+		if (result) {
+			route = result.route;
+			event.route = { id: route.id };
+			event.params = result.params;
 		}
 	}
 

package/src/types/internal.d.ts

@@ -32,6 +32,7 @@ import {
 	TrailingSlash
 } from './private.js';
 import { Span } from '@opentelemetry/api';
+import type { PageOptions } from '../exports/vite/static_analysis/index.js';
 
 export interface ServerModule {
 	Server: typeof InternalServer;
@@ -214,6 +215,8 @@ export interface PageNode {
 	parent?: PageNode;
 	/** Filled with the pages that reference this layout (if this is a layout). */
 	child_pages?: PageNode[];
+	/** The final page options for a node if it was statically analysable */
+	page_options?: PageOptions | null;
 }
 
 export interface PrerenderDependency {
@@ -278,6 +281,8 @@ export interface RouteData {
 
 	endpoint: {
 		file: string;
+		/** The final page options for the endpoint if it was statically analysable */
+		page_options: PageOptions | null;
 	} | null;
 }
 

package/src/types/private.d.ts

@@ -240,6 +240,7 @@ export interface RouteSegment {
 	rest: boolean;
 }
 
+/** @default 'never' */
 export type TrailingSlash = 'never' | 'always' | 'ignore';
 
 export type IsAny<T> = 0 extends 1 & T ? true : false;

package/src/utils/css.js

@@ -1,5 +1,6 @@
 import MagicString from 'magic-string';
 import * as svelte from 'svelte/compiler';
+import { escape_for_interpolation } from './escape.js';
 
 /** @typedef {ReturnType<typeof import('svelte/compiler').parseCss>['children']} StyleSheetChildren */
 
@@ -59,6 +60,8 @@ export function fix_css_urls({
 		return css;
 	}
 
+	css = escape_for_interpolation(css);
+
 	// safe guard in case of trailing slashes (but this should never happen)
 	if (paths_assets.endsWith('/')) {
 		paths_assets = paths_assets.slice(0, -1);

package/src/utils/escape.js

@@ -60,3 +60,12 @@ export function escape_html(str, is_attr) {
 
 	return escaped_str;
 }
+
+/**
+ * Escapes backticks and dollar signs so that they can be safely used in template literals.
+ * @param {string} str
+ * @returns {string} escaped string
+ */
+export function escape_for_interpolation(str) {
+	return str.replaceAll('`', '\\`').replaceAll('$', '\\$');
+}

package/src/utils/routing.js

@@ -1,4 +1,5 @@
 import { BROWSER } from 'esm-env';
+import { decode_params } from './url.js';
 
 const param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
 
@@ -280,3 +281,27 @@ export function resolve_route(id, params) {
 export function has_server_load(node) {
 	return node.server?.load !== undefined || node.server?.trailingSlash !== undefined;
 }
+
+/**
+ * Find the first route that matches the given path
+ * @template {{pattern: RegExp, params: import('types').RouteParam[]}} Route
+ * @param {string} path - The decoded pathname to match
+ * @param {Route[]} routes
+ * @param {Record<string, import('@sveltejs/kit').ParamMatcher>} matchers
+ * @returns {{ route: Route, params: Record<string, string> } | null}
+ */
+export function find_route(path, routes, matchers) {
+	for (const route of routes) {
+		const match = route.pattern.exec(path);
+		if (!match) continue;
+
+		const matched = exec(match, route.params, matchers);
+		if (matched) {
+			return {
+				route,
+				params: decode_params(matched)
+			};
+		}
+	}
+	return null;
+}

package/src/version.js

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

package/types/index.d.ts

@@ -2395,6 +2395,7 @@ declare module '@sveltejs/kit' {
 		rest: boolean;
 	}
 
+	/** @default 'never' */
 	type TrailingSlash = 'never' | 'always' | 'ignore';
 
 	type IsAny<T> = 0 extends 1 & T ? true : false;
@@ -2472,6 +2473,8 @@ declare module '@sveltejs/kit' {
 		parent?: PageNode;
 		/** Filled with the pages that reference this layout (if this is a layout). */
 		child_pages?: PageNode[];
+		/** The final page options for a node if it was statically analysable */
+		page_options?: PageOptions | null;
 	}
 
 	type RecursiveRequired<T> = {
@@ -2516,6 +2519,8 @@ declare module '@sveltejs/kit' {
 
 		endpoint: {
 			file: string;
+			/** The final page options for the endpoint if it was statically analysable */
+			page_options: PageOptions | null;
 		} | null;
 	}
 
@@ -2765,6 +2770,9 @@ declare module '@sveltejs/kit' {
 	};
 	export type LessThan<TNumber extends number, TArray extends any[] = []> = TNumber extends TArray["length"] ? TArray[number] : LessThan<TNumber, [...TArray, TArray["length"]]>;
 	export type NumericRange<TStart extends number, TEnd extends number> = Exclude<TEnd | LessThan<TEnd>, LessThan<TStart>>;
+	type ValidPageOption = (typeof valid_page_options_array)[number];
+	type PageOptions = Partial<Record<ValidPageOption, any>>;
+	const valid_page_options_array: readonly ["ssr", "prerender", "csr", "trailingSlash", "config", "entries", "load"];
 	export const VERSION: string;
 	class HttpError_1 {
 		
@@ -3172,6 +3180,28 @@ declare module '$app/paths' {
 	 *
 	 * */
 	export function resolve<T extends RouteId | Pathname>(...args: ResolveArgs<T>): ResolvedPathname;
+	/**
+	 * Match a path or URL to a route ID and extracts any parameters.
+	 *
+	 * @example
+	 * ```js
+	 * import { match } from '$app/paths';
+	 *
+	 * const route = await match('/blog/hello-world');
+	 *
+	 * if (route?.id === '/blog/[slug]') {
+	 * 	const slug = route.params.slug;
+	 * 	const response = await fetch(`/api/posts/${slug}`);
+	 * 	const post = await response.json();
+	 * }
+	 * ```
+	 * @since 2.52.0
+	 *
+	 * */
+	export function match(url: Pathname | URL | (string & {})): Promise<{
+		id: RouteId;
+		params: Record<string, string>;
+	} | null>;
 
 	export {};
 }

package/types/index.d.ts.map

@@ -133,6 +133,9 @@
 		"invalid",
 		"isValidationError",
 		"normalizeUrl",
+		"ValidPageOption",
+		"PageOptions",
+		"valid_page_options_array",
 		"VERSION",
 		"sequence",
 		"getRequest",
@@ -165,6 +168,7 @@
 		"ResolveArgs",
 		"asset",
 		"resolve",
+		"match",
 		"read",
 		"getRequestEvent",
 		"RemotePrerenderInputsGenerator",
@@ -179,6 +183,7 @@
 		"../src/types/private.d.ts",
 		"../src/types/internal.d.ts",
 		"../src/exports/index.js",
+		"../src/exports/vite/static_analysis/index.js",
 		"../src/version.js",
 		"../src/exports/hooks/sequence.js",
 		"../src/exports/node/index.js",
@@ -215,8 +220,9 @@
 		null,
 		null,
 		null,
+		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }