@sveltejs/kit 1.9.3 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.9.3",
+  "version": "1.11.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/src/core/env.js

@@ -1,4 +1,5 @@
 import { GENERATED_COMMENT } from '../constants.js';
+import { dedent } from './sync/utils.js';
 import { runtime_base } from './utils.js';
 
 /**
@@ -50,10 +51,13 @@ export function create_dynamic_module(type, dev_values) {
 export function create_static_types(id, env) {
 	const declarations = Object.keys(env[id])
 		.filter((k) => valid_identifier.test(k))
-		.map((k) => `\texport const ${k}: string;`)
-		.join('\n');
+		.map((k) => `export const ${k}: string;`);
 
-	return `declare module '$env/static/${id}' {\n${declarations}\n}`;
+	return dedent`
+		declare module '$env/static/${id}' {
+			${declarations.join('\n')}
+		}
+	`;
 }
 
 /**
@@ -65,19 +69,24 @@ export function create_static_types(id, env) {
 export function create_dynamic_types(id, env, prefix) {
 	const properties = Object.keys(env[id])
 		.filter((k) => valid_identifier.test(k))
-		.map((k) => `\t\t${k}: string;`);
+		.map((k) => `${k}: string;`);
 
 	const prefixed = `[key: \`${prefix}\${string}\`]`;
 
 	if (id === 'private') {
-		properties.push(`\t\t${prefixed}: undefined;`);
-		properties.push(`\t\t[key: string]: string | undefined;`);
+		properties.push(`${prefixed}: undefined;`);
+		properties.push(`[key: string]: string | undefined;`);
 	} else {
-		properties.push(`\t\t${prefixed}: string | undefined;`);
+		properties.push(`${prefixed}: string | undefined;`);
 	}
 
-	const declaration = `export const env: {\n${properties.join('\n')}\n\t}`;
-	return `declare module '$env/dynamic/${id}' {\n\t${declaration}\n}`;
+	return dedent`
+		declare module '$env/dynamic/${id}' {
+			export const env: {
+				${properties.join('\n')}
+			}
+		}
+	`;
 }
 
 export const reserved = new Set([

package/src/core/generate_manifest/index.js

@@ -3,6 +3,7 @@ import { get_mime_lookup } from '../utils.js';
 import { resolve_symlinks } from '../../exports/vite/build/utils.js';
 import { compact } from '../../utils/array.js';
 import { join_relative } from '../../utils/filesystem.js';
+import { dedent } from '../sync/utils.js';
 
 /**
  * Generates the data used to write the server-side manifest.js file. This data is used in the Vite
@@ -80,37 +81,41 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 	// prettier-ignore
 	// String representation of
 	/** @type {import('types').SSRManifest} */
-	return `{
-		appDir: ${s(build_data.app_dir)},
-		appPath: ${s(build_data.app_path)},
-		assets: new Set(${s(assets)}),
-		mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
-		_: {
-			client: ${s(build_data.client)},
-			nodes: [
-				${(node_paths).map(loader).join(',\n\t\t\t\t')}
-			],
-			routes: [
-				${routes.map(route => {
-					route.params.forEach(param => {
-						if (param.matcher) matchers.add(param.matcher);
-					});
+	return dedent`
+		{
+			appDir: ${s(build_data.app_dir)},
+			appPath: ${s(build_data.app_path)},
+			assets: new Set(${s(assets)}),
+			mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
+			_: {
+				client: ${s(build_data.client)},
+				nodes: [
+					${(node_paths).map(loader).join(',\n')}
+				],
+				routes: [
+					${routes.map(route => {
+						route.params.forEach(param => {
+							if (param.matcher) matchers.add(param.matcher);
+						});
 
-					if (!route.page && !route.endpoint) return;
+						if (!route.page && !route.endpoint) return;
 
-					return `{
-					id: ${s(route.id)},
-					pattern: ${route.pattern},
-					params: ${s(route.params)},
-					page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
-					endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
-				}`;
-				}).filter(Boolean).join(',\n\t\t\t\t')}
-			],
-			matchers: async () => {
-				${Array.from(matchers).map(type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`).join('\n\t\t\t\t')}
-				return { ${Array.from(matchers).join(', ')} };
+						return dedent`
+							{
+								id: ${s(route.id)},
+								pattern: ${route.pattern},
+								params: ${s(route.params)},
+								page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
+								endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
+							}
+						`;
+					}).filter(Boolean).join(',\n')}
+				],
+				matchers: async () => {
+					${Array.from(matchers).map(type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`).join('\n')}
+					return { ${Array.from(matchers).join(', ')} };
+				}
 			}
 		}
-	}`.replace(/^\t/gm, '');
+	`;
 }

package/src/core/postbuild/analyse.js

@@ -122,15 +122,7 @@ async function analyse({ manifest_path, env }) {
 				validate_common_exports(page.universal, page.universal_id);
 			}
 
-			const should_prerender = get_option(nodes, 'prerender');
-			prerender =
-				should_prerender === true ||
-				// Try prerendering if ssr is false and no server needed. Set it to 'auto' so that
-				// the route is not removed from the manifest, there could be a server load function.
-				// People can opt out of this behavior by explicitly setting prerender to false
-				(should_prerender !== false && get_option(nodes, 'ssr') === false && !page?.server?.actions
-					? 'auto'
-					: should_prerender ?? false);
+			prerender = get_option(nodes, 'prerender') ?? false;
 
 			config = get_config(nodes);
 		}

package/src/core/postbuild/crawl.js

@@ -1,3 +1,4 @@
+import { resolve } from '../../utils/url.js';
 import { decode } from './entities.js';
 
 const DOCTYPE = 'DOCTYPE';
@@ -12,8 +13,11 @@ const ATTRIBUTE_NAME = /[^\t\n\f />"'=]/;
 
 const WHITESPACE = /[\s\n\r]/;
 
-/** @param {string} html */
-export function crawl(html) {
+/**
+ * @param {string} html
+ * @param {string} base
+ */
+export function crawl(html, base) {
 	/** @type {string[]} */
 	const ids = [];
 
@@ -157,7 +161,11 @@ export function crawl(html) {
 							value = decode(value);
 
 							if (name === 'href') {
-								href = value;
+								if (tag === 'BASE') {
+									base = resolve(base, value);
+								} else {
+									href = resolve(base, value);
+								}
 							} else if (name === 'id') {
 								ids.push(value);
 							} else if (name === 'name') {
@@ -165,7 +173,7 @@ export function crawl(html) {
 							} else if (name === 'rel') {
 								rel = value;
 							} else if (name === 'src') {
-								if (value) hrefs.push(value);
+								if (value) hrefs.push(resolve(base, value));
 							} else if (name === 'srcset') {
 								const candidates = [];
 								let insideURL = true;
@@ -183,7 +191,7 @@ export function crawl(html) {
 								candidates.push(value);
 								for (const candidate of candidates) {
 									const src = candidate.split(WHITESPACE)[0];
-									if (src) hrefs.push(src);
+									if (src) hrefs.push(resolve(base, src));
 								}
 							}
 						} else {
@@ -195,7 +203,7 @@ export function crawl(html) {
 				}
 
 				if (href && !/\bexternal\b/i.test(rel)) {
-					hrefs.push(href);
+					hrefs.push(resolve(base, href));
 				}
 			}
 		}

package/src/core/postbuild/prerender.js

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { installPolyfills } from '../../exports/node/polyfills.js';
@@ -144,6 +144,13 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 	}
 
 	const files = new Set(walk(`${out}/client`).map(posixify));
+
+	const immutable = `${config.appDir}/immutable`;
+	if (existsSync(`${out}/server/${immutable}`)) {
+		for (const file of walk(`${out}/server/${immutable}`)) {
+			files.add(posixify(`${config.appDir}/immutable/${file}`));
+		}
+	}
 	const seen = new Set();
 	const written = new Set();
 
@@ -240,17 +247,14 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 		const headers = Object.fromEntries(response.headers);
 
 		if (config.prerender.crawl && headers['content-type'] === 'text/html') {
-			const { ids, hrefs } = crawl(body.toString());
+			const { ids, hrefs } = crawl(body.toString(), decoded);
 
 			actual_hashlinks.set(decoded, ids);
 
 			for (const href of hrefs) {
-				if (href.startsWith('data:')) continue;
-
-				const resolved = resolve(encoded, href);
-				if (!is_root_relative(resolved)) continue;
+				if (!is_root_relative(href)) continue;
 
-				const { pathname, search, hash } = new URL(resolved, 'http://localhost');
+				const { pathname, search, hash } = new URL(href, 'http://localhost');
 
 				if (search) {
 					// TODO warn that query strings have no effect on statically-exported pages

package/src/core/sync/utils.js

@@ -25,9 +25,46 @@ export function write(file, code) {
 	fs.writeFileSync(file, code);
 }
 
-/** @param {string} str */
-export function trim(str) {
-	const indentation = /** @type {RegExpExecArray} */ (/\n?([ \t]*)/.exec(str))[1];
-	const pattern = new RegExp(`^${indentation}`, 'gm');
-	return str.replace(pattern, '').trim();
+/** @type {WeakMap<TemplateStringsArray, { strings: string[], indents: string[] }>} */
+const dedent_map = new WeakMap();
+
+/**
+ * Allows indenting template strings without the extra indentation ending up in the result.
+ * Still allows indentation of lines relative to one another in the template string.
+ * @param {TemplateStringsArray} strings
+ * @param {any[]} values
+ */
+export function dedent(strings, ...values) {
+	let dedented = dedent_map.get(strings);
+
+	if (!dedented) {
+		const indentation = /** @type {RegExpExecArray} */ (/\n?([ \t]*)/.exec(strings[0]))[1];
+		const pattern = new RegExp(`^${indentation}`, 'gm');
+
+		dedented = {
+			strings: strings.map((str) => str.replace(pattern, '')),
+			indents: []
+		};
+
+		let current = '\n';
+
+		for (let i = 0; i < values.length; i += 1) {
+			const string = dedented.strings[i];
+			const match = /\n([ \t]*)$/.exec(string);
+
+			if (match) current = match[0];
+			dedented.indents[i] = current;
+		}
+
+		dedent_map.set(strings, dedented);
+	}
+
+	let str = dedented.strings[0];
+	for (let i = 0; i < values.length; i += 1) {
+		str += String(values[i]).replace(/\n/g, dedented.indents[i]) + dedented.strings[i + 1];
+	}
+
+	str = str.trim();
+
+	return str;
 }

package/src/core/sync/write_client_manifest.js

@@ -1,6 +1,6 @@
 import { relative_path, resolve_entry } from '../../utils/filesystem.js';
 import { s } from '../../utils/misc.js';
-import { trim, write_if_changed } from './utils.js';
+import { dedent, write_if_changed } from './utils.js';
 
 /**
  * Writes the client manifest to disk. The manifest is used to power the router. It contains the
@@ -45,75 +45,79 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			write_if_changed(`${output}/nodes/${i}.js`, generate_node(node));
 			return `() => import('./nodes/${i}')`;
 		})
-		.join(',\n\t');
+		.join(',\n');
 
 	const layouts_with_server_load = new Set();
 
-	const dictionary = `{
-		${manifest_data.routes
-			.map((route) => {
-				if (route.page) {
-					const errors = route.page.errors.slice(1).map((n) => n ?? '');
-					const layouts = route.page.layouts.slice(1).map((n) => n ?? '');
-
-					while (layouts.at(-1) === '') layouts.pop();
-					while (errors.at(-1) === '') errors.pop();
-
-					let leaf_has_server_load = false;
-					if (route.leaf) {
-						if (metadata) {
-							const i = /** @type {number} */ (indices.get(route.leaf));
-
-							leaf_has_server_load = metadata[i].has_server_load;
-						} else if (route.leaf.server) {
-							leaf_has_server_load = true;
+	const dictionary = dedent`
+		{
+			${manifest_data.routes
+				.map((route) => {
+					if (route.page) {
+						const errors = route.page.errors.slice(1).map((n) => n ?? '');
+						const layouts = route.page.layouts.slice(1).map((n) => n ?? '');
+
+						while (layouts.at(-1) === '') layouts.pop();
+						while (errors.at(-1) === '') errors.pop();
+
+						let leaf_has_server_load = false;
+						if (route.leaf) {
+							if (metadata) {
+								const i = /** @type {number} */ (indices.get(route.leaf));
+
+								leaf_has_server_load = metadata[i].has_server_load;
+							} else if (route.leaf.server) {
+								leaf_has_server_load = true;
+							}
 						}
-					}
 
-					// Encode whether or not the route uses server data
-					// using the ones' complement, to save space
-					const array = [`${leaf_has_server_load ? '~' : ''}${route.page.leaf}`];
+						// Encode whether or not the route uses server data
+						// using the ones' complement, to save space
+						const array = [`${leaf_has_server_load ? '~' : ''}${route.page.leaf}`];
 
-					// Encode whether or not the layout uses server data.
-					// It's a different method compared to pages because layouts
-					// are reused across pages, so we save space by doing it this way.
-					route.page.layouts.forEach((layout) => {
-						if (layout == undefined) return;
+						// Encode whether or not the layout uses server data.
+						// It's a different method compared to pages because layouts
+						// are reused across pages, so we save space by doing it this way.
+						route.page.layouts.forEach((layout) => {
+							if (layout == undefined) return;
 
-						let layout_has_server_load = false;
+							let layout_has_server_load = false;
 
-						if (metadata) {
-							layout_has_server_load = metadata[layout].has_server_load;
-						} else if (manifest_data.nodes[layout].server) {
-							layout_has_server_load = true;
-						}
+							if (metadata) {
+								layout_has_server_load = metadata[layout].has_server_load;
+							} else if (manifest_data.nodes[layout].server) {
+								layout_has_server_load = true;
+							}
 
-						if (layout_has_server_load) {
-							layouts_with_server_load.add(layout);
-						}
-					});
+							if (layout_has_server_load) {
+								layouts_with_server_load.add(layout);
+							}
+						});
 
-					// only include non-root layout/error nodes if they exist
-					if (layouts.length > 0 || errors.length > 0) array.push(`[${layouts.join(',')}]`);
-					if (errors.length > 0) array.push(`[${errors.join(',')}]`);
+						// only include non-root layout/error nodes if they exist
+						if (layouts.length > 0 || errors.length > 0) array.push(`[${layouts.join(',')}]`);
+						if (errors.length > 0) array.push(`[${errors.join(',')}]`);
 
-					return `${s(route.id)}: [${array.join(',')}]`;
-				}
-			})
-			.filter(Boolean)
-			.join(',\n\t\t')}
-	}`.replace(/^\t/gm, '');
+						return `${s(route.id)}: [${array.join(',')}]`;
+					}
+				})
+				.filter(Boolean)
+				.join(',\n')}
+		}
+	`;
 
 	const hooks_file = resolve_entry(kit.files.hooks.client);
 
 	write_if_changed(
 		`${output}/app.js`,
-		trim(`
+		dedent`
 			${hooks_file ? `import * as client_hooks from '${relative_path(output, hooks_file)}';` : ''}
 
 			export { matchers } from './matchers.js';
 
-			export const nodes = [${nodes}];
+			export const nodes = [
+				${nodes}
+			];
 
 			export const server_loads = [${[...layouts_with_server_load].join(',')}];
 
@@ -126,7 +130,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 			};
 
 			export { default as root } from '../root.svelte';
-		`)
+		`
 	);
 
 	// write matchers to a separate module so that we don't

package/src/core/sync/write_root.js

@@ -1,4 +1,4 @@
-import { trim, write_if_changed } from './utils.js';
+import { dedent, write_if_changed } from './utils.js';
 
 /**
  * @param {import('types').ManifestData} manifest_data
@@ -24,22 +24,20 @@ export function write_root(manifest_data, output) {
 	let pyramid = `<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} />`;
 
 	while (l--) {
-		pyramid = `
+		pyramid = dedent`
 			{#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')}
+					${pyramid}
 				</svelte:component>
 			{:else}
 				<svelte:component this={constructors[${l}]} bind:this={components[${l}]} data={data_${l}} {form} />
 			{/if}
-		`
-			.replace(/^\t\t\t/gm, '')
-			.trim();
+		`;
 	}
 
 	write_if_changed(
 		`${output}/root.svelte`,
-		trim(`
+		dedent`
 			<!-- This file is generated by @sveltejs/kit — do not edit it! -->
 			<script>
 				import { setContext, afterUpdate, onMount } from 'svelte';
@@ -52,7 +50,7 @@ export function write_root(manifest_data, output) {
 				export let constructors;
 				export let components = [];
 				export let form;
-				${levels.map((l) => `export let data_${l} = null;`).join('\n\t\t\t\t')}
+				${levels.map((l) => `export let data_${l} = null;`).join('\n')}
 
 				if (!browser) {
 					setContext('__svelte__', stores);
@@ -78,7 +76,7 @@ export function write_root(manifest_data, output) {
 				});
 			</script>
 
-			${pyramid.replace(/\n/g, '\n\t\t\t')}
+			${pyramid}
 
 			{#if mounted}
 				<div id="svelte-announcer" aria-live="assertive" aria-atomic="true" style="position: absolute; left: 0; top: 0; clip: rect(0 0 0 0); clip-path: inset(50%); overflow: hidden; white-space: nowrap; width: 1px; height: 1px">
@@ -87,6 +85,6 @@ export function write_root(manifest_data, output) {
 					{/if}
 				</div>
 			{/if}
-		`)
+		`
 	);
 }

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

@@ -592,7 +592,10 @@ export function tweak_types(content, is_server) {
 				});
 			}
 
-			if (node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+			if (
+				ts.canHaveModifiers(node) &&
+				ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+			) {
 				if (ts.isFunctionDeclaration(node) && node.name?.text && names.has(node.name?.text)) {
 					exports.set(node.name.text, node.name.text);
 				}

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

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import * as vite from 'vite';
+import { dedent } from '../../../core/sync/utils.js';
 import { s } from '../../../utils/misc.js';
 import { get_config_aliases } from '../utils.js';
 import { assets_base } from './utils.js';
@@ -32,30 +33,34 @@ export async function build_service_worker(
 
 	const service_worker = `${kit.outDir}/generated/service-worker.js`;
 
+	// in a service worker, `location` is the location of the service worker itself,
+	// which is guaranteed to be `<base>/service-worker.js`
+	const base = `location.pathname.split('/').slice(0, -1).join('/')`;
+
 	fs.writeFileSync(
 		service_worker,
-		`
+		dedent`
+			export const base = /*@__PURE__*/ ${base};
+
 			export const build = [
 				${Array.from(build)
-					.map((file) => `${s(`${kit.paths.base}/${file}`)}`)
-					.join(',\n\t\t\t\t')}
+					.map((file) => `base + ${s(`/${file}`)}`)
+					.join(',\n')}
 			];
 
 			export const files = [
 				${manifest_data.assets
 					.filter((asset) => kit.serviceWorker.files(asset.file))
-					.map((asset) => `${s(`${kit.paths.base}/${asset.file}`)}`)
-					.join(',\n\t\t\t\t')}
+					.map((asset) => `base + ${s(`/${asset.file}`)}`)
+					.join(',\n')}
 			];
 
 			export const prerendered = [
-				${prerendered.paths.map((path) => s(path)).join(',\n\t\t\t\t')}
+				${prerendered.paths.map((path) => `base + ${s(path.replace(kit.paths.base, ''))}`).join(',\n')}
 			];
 
 			export const version = ${s(kit.version.name)};
 		`
-			.replace(/^\t{3}/gm, '')
-			.trim()
 	);
 
 	await vite.build({

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

@@ -175,15 +175,20 @@ export async function dev(vite, vite_config, svelte_config) {
 							const styles = {};
 
 							for (const dep of deps) {
-								const parsed = new URL(dep.url, 'http://localhost/');
-								const query = parsed.searchParams;
+								const url = new URL(dep.url, 'http://localhost/');
+								const query = url.searchParams;
 
 								if (
 									isCSSRequest(dep.file) ||
 									(query.has('svelte') && query.get('type') === 'style')
 								) {
+									// setting `?inline` to load CSS modules as css string
+									query.set('inline', '');
+
 									try {
-										const mod = await loud_ssr_load_module(dep.url);
+										const mod = await loud_ssr_load_module(
+											`${url.pathname}${url.search}${url.hash}`
+										);
 										styles[dep.url] = mod.default;
 									} catch {
 										// this can happen with dynamically imported modules, I think

package/src/exports/vite/index.js

@@ -24,6 +24,7 @@ import prerender from '../../core/postbuild/prerender.js';
 import analyse from '../../core/postbuild/analyse.js';
 import { s } from '../../utils/misc.js';
 import { hash } from '../../runtime/hash.js';
+import { dedent } from '../../core/sync/utils.js';
 
 export { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
 
@@ -334,7 +335,10 @@ function kit({ svelte_config }) {
 
 		async load(id, options) {
 			const browser = !options?.ssr;
-			const global = `globalThis.__sveltekit_${version_hash}`;
+
+			const global = is_build
+				? `globalThis.__sveltekit_${version_hash}`
+				: `globalThis.__sveltekit_dev`;
 
 			if (options?.ssr === false && process.env.TEST !== 'true') {
 				const normalized_cwd = vite.normalizePath(cwd);
@@ -354,13 +358,16 @@ function kit({ svelte_config }) {
 			switch (id) {
 				case '\0$env/static/private':
 					return create_static_module('$env/static/private', env.private);
+
 				case '\0$env/static/public':
 					return create_static_module('$env/static/public', env.public);
+
 				case '\0$env/dynamic/private':
 					return create_dynamic_module(
 						'private',
 						vite_config_env.command === 'serve' ? env.private : undefined
 					);
+
 				case '\0$env/dynamic/public':
 					// populate `$env/dynamic/public` from `window`
 					if (browser) {
@@ -371,6 +378,7 @@ function kit({ svelte_config }) {
 						'public',
 						vite_config_env.command === 'serve' ? env.public : undefined
 					);
+
 				case '\0$service-worker':
 					return create_service_worker_module(svelte_config);
 
@@ -383,40 +391,47 @@ function kit({ svelte_config }) {
 					// for the sake of things like Vitest which may import this module
 					// outside the context of a page
 					if (browser) {
-						return `export const base = ${global}?.base ?? ${s(base)};
-export const assets = ${global}?.assets ?? ${assets ? s(assets) : 'base'};`;
+						return dedent`
+							export const base = ${global}?.base ?? ${s(base)};
+							export const assets = ${global}?.assets ?? ${assets ? s(assets) : 'base'};
+						`;
 					}
 
-					return `export let base = ${s(base)};
-export let assets = ${assets ? s(assets) : 'base'};
+					return dedent`
+						export let base = ${s(base)};
+						export let assets = ${assets ? s(assets) : 'base'};
 
-export const relative = ${svelte_config.kit.paths.relative};
+						export const relative = ${svelte_config.kit.paths.relative};
 
-const initial = { base, assets };
+						const initial = { base, assets };
 
-export function override(paths) {
-	base = paths.base;
-	assets = paths.assets;
-}
+						export function override(paths) {
+							base = paths.base;
+							assets = paths.assets;
+						}
 
-export function reset() {
-	base = initial.base;
-	assets = initial.assets;
-}
+						export function reset() {
+							base = initial.base;
+							assets = initial.assets;
+						}
 
-/** @param {string} path */
-export function set_assets(path) {
-	assets = initial.assets = path;
-}`;
+						/** @param {string} path */
+						export function set_assets(path) {
+							assets = initial.assets = path;
+						}
+					`;
 
 				case '\0__sveltekit/environment':
 					const { version } = svelte_config.kit;
-					return `export const version = ${s(version.name)};
-export let building = false;
 
-export function set_building() {
-	building = true;
-}`;
+					return dedent`
+						export const version = ${s(version.name)};
+						export let building = false;
+
+						export function set_building() {
+							building = true;
+						}
+					`;
 			}
 		}
 	};
@@ -863,18 +878,18 @@ function find_overridden_config(config, resolved_config, enforced_config, path,
 /**
  * @param {import('types').ValidatedConfig} config
  */
-const create_service_worker_module = (config) => `
-if (typeof self === 'undefined' || self instanceof ServiceWorkerGlobalScope === false) {
-	throw new Error('This module can only be imported inside a service worker');
-}
+const create_service_worker_module = (config) => dedent`
+	if (typeof self === 'undefined' || self instanceof ServiceWorkerGlobalScope === false) {
+		throw new Error('This module can only be imported inside a service worker');
+	}
 
-export const build = [];
-export const files = [
-	${create_assets(config)
-		.filter((asset) => config.kit.serviceWorker.files(asset.file))
-		.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
-		.join(',\n\t\t\t\t')}
-];
-export const prerendered = [];
-export const version = ${s(config.kit.version.name)};
+	export const build = [];
+	export const files = [
+		${create_assets(config)
+			.filter((asset) => config.kit.serviceWorker.files(asset.file))
+			.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
+			.join(',\n')}
+	];
+	export const prerendered = [];
+	export const version = ${s(config.kit.version.name)};
 `;

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

@@ -108,8 +108,31 @@ export async function preview(vite, vite_config, svelte_config) {
 				let prerendered = is_file(filename);
 
 				if (!prerendered) {
-					filename += filename.endsWith('/') ? 'index.html' : '.html';
-					prerendered = is_file(filename);
+					const has_trailing_slash = pathname.endsWith('/');
+					const html_filename = `${filename}${has_trailing_slash ? 'index.html' : '.html'}`;
+
+					let redirect;
+
+					if (is_file(html_filename)) {
+						filename = html_filename;
+						prerendered = true;
+					} else if (has_trailing_slash) {
+						if (is_file(filename.slice(0, -1) + '.html')) {
+							redirect = pathname.slice(0, -1);
+						}
+					} else if (is_file(filename + '/index.html')) {
+						redirect = pathname + '/';
+					}
+
+					if (redirect) {
+						res.writeHead(307, {
+							location: redirect
+						});
+
+						res.end();
+
+						return;
+					}
 				}
 
 				if (prerendered) {

package/src/runtime/client/client.js

@@ -177,6 +177,14 @@ export function create_client(app, target) {
 		});
 	}
 
+	function persist_state() {
+		update_scroll_positions(current_history_index);
+		storage.set(SCROLL_KEY, scroll_positions);
+
+		capture_snapshot(current_history_index);
+		storage.set(SNAPSHOT_KEY, snapshots);
+	}
+
 	/**
 	 * @param {string | URL} url
 	 * @param {{ noScroll?: boolean; replaceState?: boolean; keepFocus?: boolean; state?: any; invalidateAll?: boolean }} opts
@@ -379,17 +387,7 @@ export function create_client(app, target) {
 			// need to render the DOM before we can scroll to the rendered elements and do focus management
 			await tick();
 
-			const changed_focus =
-				// reset focus only if any manual focus management didn't override it
-				document.activeElement !== activeElement &&
-				// also refocus when activeElement is body already because the
-				// focus event might not have been fired on it yet
-				document.activeElement !== document.body;
-
-			if (!keepfocus && !changed_focus) {
-				await reset_focus();
-			}
-
+			// we reset scroll before dealing with focus, to avoid a flash of unscrolled content
 			if (autoscroll) {
 				const deep_linked =
 					url.hash && document.getElementById(decodeURIComponent(url.hash.slice(1)));
@@ -404,6 +402,17 @@ export function create_client(app, target) {
 					scrollTo(0, 0);
 				}
 			}
+
+			const changed_focus =
+				// reset focus only if any manual focus management didn't override it
+				document.activeElement !== activeElement &&
+				// also refocus when activeElement is body already because the
+				// focus event might not have been fired on it yet
+				document.activeElement !== document.body;
+
+			if (!keepfocus && !changed_focus) {
+				await reset_focus();
+			}
 		} else {
 			await tick();
 		}
@@ -1180,6 +1189,15 @@ export function create_client(app, target) {
 				route
 			});
 		}
+
+		if (__SVELTEKIT_DEV__) {
+			console.error(
+				'An error occurred while loading the page. This will cause a full page reload. (This message will only appear during development.)'
+			);
+
+			debugger;
+		}
+
 		return await native_navigation(url);
 	}
 
@@ -1410,14 +1428,19 @@ export function create_client(app, target) {
 				goto(result.location, { invalidateAll: true }, []);
 			} else {
 				/** @type {Record<string, any>} */
-				const props = {
-					form: result.data,
+				root.$set({
+					// this brings Svelte's view of the world in line with SvelteKit's
+					// after use:enhance reset the form....
+					form: null,
 					page: { ...page, form: result.data, status: result.status }
-				};
-				root.$set(props);
+				});
+
+				// ...so that setting the `form` prop takes effect and isn't ignored
+				await tick();
+				root.$set({ form: result.data });
 
 				if (result.type === 'success') {
-					tick().then(reset_focus);
+					reset_focus();
 				}
 			}
 		},
@@ -1432,6 +1455,8 @@ export function create_client(app, target) {
 			addEventListener('beforeunload', (e) => {
 				let should_block = false;
 
+				persist_state();
+
 				if (!navigating) {
 					// If we're navigating, beforeNavigate was already called. If we end up in here during navigation,
 					// it's due to an external or full-page-reload link, for which we don't want to call the hook again.
@@ -1461,11 +1486,7 @@ export function create_client(app, target) {
 
 			addEventListener('visibilitychange', () => {
 				if (document.visibilityState === 'hidden') {
-					update_scroll_positions(current_history_index);
-					storage.set(SCROLL_KEY, scroll_positions);
-
-					capture_snapshot(current_history_index);
-					storage.set(SNAPSHOT_KEY, snapshots);
+					persist_state();
 				}
 			});
 
@@ -1515,11 +1536,14 @@ export function create_client(app, target) {
 
 				// Ignore the following but fire beforeNavigate
 				if (external || options.reload) {
-					const navigation = before_navigate({ url, type: 'link' });
-					if (!navigation) {
+					if (before_navigate({ url, type: 'link' })) {
+						// set `navigating` to `true` to prevent `beforeNavigate` callbacks
+						// being called when the page unloads
+						navigating = true;
+					} else {
 						event.preventDefault();
 					}
-					navigating = true;
+
 					return;
 				}
 

package/src/runtime/server/cookie.js

@@ -27,26 +27,6 @@ export function get_cookies(request, url, trailing_slash) {
 	// Emulate browser-behavior: if the cookie is set at '/foo/bar', its path is '/foo'
 	const default_path = normalized_url.split('/').slice(0, -1).join('/') || '/';
 
-	if (__SVELTEKIT_DEV__) {
-		// TODO this could theoretically be wrong if the cookie was set unencoded?
-		const initial_decoded_cookies = parse(header, { decode: decodeURIComponent });
-		// Remove all cookies that no longer exist according to the request
-		for (const name of Object.keys(cookie_paths)) {
-			cookie_paths[name] = new Set(
-				[...cookie_paths[name]].filter(
-					(path) => !path_matches(normalized_url, path) || name in initial_decoded_cookies
-				)
-			);
-		}
-		// Add all new cookies we might not have seen before
-		for (const name in initial_decoded_cookies) {
-			cookie_paths[name] = cookie_paths[name] ?? new Set();
-			if (![...cookie_paths[name]].some((path) => path_matches(normalized_url, path))) {
-				cookie_paths[name].add(default_path);
-			}
-		}
-	}
-
 	/** @type {Record<string, import('./page/types').Cookie>} */
 	const new_cookies = {};
 
@@ -82,20 +62,43 @@ export function get_cookies(request, url, trailing_slash) {
 			const req_cookies = parse(header, { decode: decoder });
 			const cookie = req_cookies[name]; // the decoded string or undefined
 
-			if (!__SVELTEKIT_DEV__ || cookie) {
-				return cookie;
+			// in development, if the cookie was set during this session with `cookies.set`,
+			// but at a different path, warn the user. (ignore cookies from request headers,
+			// since we don't know which path they were set at)
+			if (__SVELTEKIT_DEV__ && !cookie) {
+				const paths = Array.from(cookie_paths[name] ?? []).filter((path) => {
+					// we only care about paths that are _more_ specific than the current path
+					return path_matches(path, url.pathname) && path !== url.pathname;
+				});
+
+				if (paths.length > 0) {
+					console.warn(
+						// prettier-ignore
+						`'${name}' cookie does not exist for ${url.pathname}, but was previously set at ${conjoin([...paths])}. Did you mean to set its 'path' to '/' instead?`
+					);
+				}
 			}
 
-			const paths = new Set([...(cookie_paths[name] ?? [])]);
-			if (c) {
-				paths.add(c.options.path ?? default_path);
-			}
-			if (paths.size > 0) {
-				console.warn(
-					// prettier-ignore
-					`Cookie with name '${name}' was not found at path '${url.pathname}', but a cookie with that name exists at these paths: '${[...paths].join("', '")}'. Did you mean to set its 'path' to '/' instead?`
-				);
+			return cookie;
+		},
+
+		/**
+		 * @param {import('cookie').CookieParseOptions} opts
+		 */
+		getAll(opts) {
+			const decoder = opts?.decode || decodeURIComponent;
+			const cookies = parse(header, { decode: decoder });
+
+			for (const c of Object.values(new_cookies)) {
+				if (
+					domain_matches(url.hostname, c.options.domain) &&
+					path_matches(url.pathname, c.options.path)
+				) {
+					cookies[c.name] = c.value;
+				}
 			}
+
+			return Object.entries(cookies).map(([name, value]) => ({ name, value }));
 		},
 
 		/**
@@ -122,18 +125,11 @@ export function get_cookies(request, url, trailing_slash) {
 					throw new Error(`Cookie "${name}" is too large, and will be discarded by the browser`);
 				}
 
-				cookie_paths[name] = cookie_paths[name] ?? new Set();
+				cookie_paths[name] ??= new Set();
+
 				if (!value) {
-					if (!cookie_paths[name].has(path) && cookie_paths[name].size > 0) {
-						const paths = `'${Array.from(cookie_paths[name]).join("', '")}'`;
-						console.warn(
-							`Trying to delete cookie '${name}' at path '${path}', but a cookie with that name only exists at these paths: ${paths}.`
-						);
-					}
 					cookie_paths[name].delete(path);
 				} else {
-					// We could also emit a warning here if the cookie already exists at a different path,
-					// but that's more likely a false positive because it's valid to set the same name at different paths
 					cookie_paths[name].add(path);
 				}
 			}
@@ -236,3 +232,11 @@ export function add_cookies_to_headers(headers, cookies) {
 		headers.append('set-cookie', serialize(name, value, options));
 	}
 }
+
+/**
+ * @param {string[]} array
+ */
+function conjoin(array) {
+	if (array.length <= 2) return array.join(' and ');
+	return `${array.slice(0, -1).join(', ')} and ${array.at(-1)}`;
+}

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

@@ -79,38 +79,13 @@ export async function render_page(event, page, options, manifest, state, resolve
 		// it's crucial that we do this before returning the non-SSR response, otherwise
 		// SvelteKit will erroneously believe that the path has been prerendered,
 		// causing functions to be omitted from the manifesst generated later
-		const should_prerender = get_option(nodes, 'prerender');
-
+		const should_prerender = get_option(nodes, 'prerender') ?? false;
 		if (should_prerender) {
 			const mod = leaf_node.server;
 			if (mod?.actions) {
 				throw new Error('Cannot prerender pages with actions');
 			}
 		} else if (state.prerendering) {
-			// Try to render the shell when ssr is false and prerendering not explicitly disabled.
-			// People can opt out of this behavior by explicitly setting prerender to false.
-			if (
-				should_prerender !== false &&
-				get_option(nodes, 'ssr') === false &&
-				!leaf_node.server?.actions
-			) {
-				return await render_response({
-					branch: [],
-					fetched: [],
-					page_config: {
-						ssr: false,
-						csr: get_option(nodes, 'csr') ?? true
-					},
-					status,
-					error: null,
-					event,
-					options,
-					manifest,
-					state,
-					resolve_opts
-				});
-			}
-
 			// if the page isn't marked as prerenderable, then bail out at this point
 			return new Response(undefined, {
 				status: 204

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

@@ -235,20 +235,20 @@ export async function render_response({
 	for (const dep of stylesheets) {
 		const path = prefixed(dep);
 
-		if (resolve_opts.preload({ type: 'css', path })) {
-			const attributes = ['rel="stylesheet"'];
-
-			if (inline_styles.has(dep)) {
-				// don't load stylesheets that are already inlined
-				// include them in disabled state so that Vite can detect them and doesn't try to add them
-				attributes.push('disabled', 'media="(max-width: 0)"');
-			} else {
+		const attributes = ['rel="stylesheet"'];
+
+		if (inline_styles.has(dep)) {
+			// don't load stylesheets that are already inlined
+			// include them in disabled state so that Vite can detect them and doesn't try to add them
+			attributes.push('disabled', 'media="(max-width: 0)"');
+		} else {
+			if (resolve_opts.preload({ type: 'css', path })) {
 				const preload_atts = ['rel="preload"', 'as="style"'];
 				link_header_preloads.add(`<${encodeURI(path)}>; ${preload_atts.join(';')}; nopush`);
 			}
-
-			head += `\n\t\t<link href="${path}" ${attributes.join(' ')}>`;
 		}
+
+		head += `\n\t\t<link href="${path}" ${attributes.join(' ')}>`;
 	}
 
 	for (const dep of fonts) {
@@ -268,7 +268,7 @@ export async function render_response({
 		}
 	}
 
-	const global = `__sveltekit_${options.version_hash}`;
+	const global = __SVELTEKIT_DEV__ ? `__sveltekit_dev` : `__sveltekit_${options.version_hash}`;
 
 	const { data, chunks } = get_data(
 		event,

package/src/runtime/server/respond.js

@@ -213,7 +213,7 @@ export async function respond(request, options, manifest, state) {
 
 			if (normalized !== url.pathname && !state.prerendering?.fallback) {
 				return new Response(undefined, {
-					status: 301,
+					status: 308,
 					headers: {
 						'x-sveltekit-normalize': '1',
 						location:

package/src/utils/routing.js

@@ -157,7 +157,7 @@ export function exec(match, params, matchers) {
 			// and the next value is defined, otherwise the buffer will cause us to skip values
 			const next_param = params[i + 1];
 			const next_value = values[i + 1];
-			if (next_param && !next_param.rest && next_value) {
+			if (next_param && !next_param.rest && next_param.optional && next_value) {
 				buffered = 0;
 			}
 			continue;

package/src/utils/streaming.js

@@ -23,22 +23,29 @@ function defer() {
  * }}
  */
 export function create_async_iterator() {
-	let deferred = defer();
+	let deferred = [defer()];
 
 	return {
 		iterator: {
 			[Symbol.asyncIterator]() {
 				return {
-					next: () => deferred.promise
+					next: async () => {
+						const next = await deferred[0].promise;
+						if (!next.done) deferred.shift();
+						return next;
+					}
 				};
 			}
 		},
 		push: (value) => {
-			deferred.fulfil({ value, done: false });
-			deferred = defer();
+			deferred[deferred.length - 1].fulfil({
+				value,
+				done: false
+			});
+			deferred.push(defer());
 		},
 		done: () => {
-			deferred.fulfil({ done: true });
+			deferred[deferred.length - 1].fulfil({ done: true });
 		}
 	};
 }

package/types/ambient.d.ts

@@ -326,6 +326,11 @@ declare module '$app/stores' {
  * This module is only available to [service workers](https://kit.svelte.dev/docs/service-workers).
  */
 declare module '$service-worker' {
+	/**
+	 * The `base` path of the deployment. Typically this is equivalent to `config.kit.paths.base`, but it is calculated from `location.pathname` meaning that it will continue to work correctly if the site is deployed to a subdirectory.
+	 * Note that there is a `base` but no `assets`, since service workers cannot be used if `config.kit.paths.assets` is specified.
+	 */
+	export const base: string;
 	/**
 	 * An array of URL strings representing the files generated by Vite, suitable for caching with `cache.addAll(build)`.
 	 * During development, this is an empty array.

package/types/index.d.ts

@@ -198,7 +198,13 @@ export interface Cookies {
 	get(name: string, opts?: import('cookie').CookieParseOptions): string | undefined;
 
 	/**
-	 * Sets a cookie. This will add a `set-cookie` header to the response, but also make the cookie available via `cookies.get` during the current request.
+	 * Gets all cookies that were previously set with `cookies.set`, or from the request headers.
+	 * @param opts the options, passed directily to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)
+	 */
+	getAll(opts?: import('cookie').CookieParseOptions): Array<{ name: string; value: string }>;
+
+	/**
+	 * Sets a cookie. This will add a `set-cookie` header to the response, but also make the cookie available via `cookies.get` or `cookies.getAll` during the current request.
 	 *
 	 * The `httpOnly` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`.
 	 *
@@ -452,6 +458,8 @@ export interface KitConfig {
 		 *
 		 * If `true`, `base` and `assets` imported from `$app/paths` will be replaced with relative asset paths during server-side rendering, resulting in portable HTML.
 		 * If `false`, `%sveltekit.assets%` and references to build artifacts will always be root-relative paths, unless `paths.assets` is an external URL
+		 *
+		 * If your app uses a `<base>` element, you should set this to `false`, otherwise asset URLs will incorrectly be resolved against the `<base>` URL rather than the current page.
 		 * @default undefined
 		 */
 		relative?: boolean | undefined;
@@ -566,7 +574,22 @@ export interface KitConfig {
 	 */
 	version?: {
 		/**
-		 * The current app version string. If specified, this must be deterministic (e.g. a commit ref rather than `Math.random()` or `Date.now().toString()`), otherwise defaults to a timestamp of the build
+		 * The current app version string. If specified, this must be deterministic (e.g. a commit ref rather than `Math.random()` or `Date.now().toString()`), otherwise defaults to a timestamp of the build.
+		 *
+		 * For example, to use the current commit hash, you could do use `git rev-parse HEAD`:
+		 *
+		 * ```js
+		 * /// file: svelte.config.js
+		 * import * as child_process from 'node:child_process';
+		 *
+		 * export default {
+		 *   kit: {
+		 *     version: {
+		 *       name: child_process.execSync('git rev-parse HEAD').toString().trim()
+		 *     }
+		 *   }
+		 * };
+		 * ```
 		 */
 		name?: string;
 		/**