@sveltejs/kit 1.0.0-next.213 → 1.0.0-next.217

package/assets/kit.js

@@ -1,5 +1,5 @@
 /**
- * @param {Record<string, string | string[]>} headers
+ * @param {Record<string, string | string[] | undefined>} headers
  * @param {string} key
  * @returns {string | undefined}
  * @throws {Error}
@@ -68,21 +68,24 @@ function is_string(s) {
 	return typeof s === 'string' || s instanceof String;
 }
 
+const text_types = new Set([
+	'application/xml',
+	'application/json',
+	'application/x-www-form-urlencoded',
+	'multipart/form-data'
+]);
+
 /**
  * Decides how the body should be parsed based on its mime type. Should match what's in parse_body
  *
  * @param {string | undefined | null} content_type The `content-type` header of a request/response.
  * @returns {boolean}
  */
-function is_content_type_textual(content_type) {
+function is_text(content_type) {
 	if (!content_type) return true; // defaults to json
-	const [type] = content_type.split(';'); // get the mime type
-	return (
-		type === 'text/plain' ||
-		type === 'application/json' ||
-		type === 'application/x-www-form-urlencoded' ||
-		type === 'multipart/form-data'
-	);
+	const type = content_type.split(';')[0].toLowerCase(); // get the mime type
+
+	return type.startsWith('text/') || type.endsWith('+xml') || text_types.has(type);
 }
 
 /**
@@ -121,9 +124,7 @@ async function render_endpoint(request, route, match) {
 	headers = lowercase_keys(headers);
 	const type = get_single_valued_header(headers, 'content-type');
 
-	const is_type_textual = is_content_type_textual(type);
-
-	if (!is_type_textual && !(body instanceof Uint8Array || is_string(body))) {
+	if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
 		return error(
 			`${preface}: body must be an instance of string or Uint8Array if content-type is not a supported textual content-type`
 		);

package/assets/runtime/app/navigation.js

@@ -1,4 +1,4 @@
-import { router as router$1 } from '../internal/singletons.js';
+import { renderer, router as router$1 } from '../internal/singletons.js';
 import { g as get_base_uri } from '../chunks/utils.js';
 
 const router = /** @type {import('../client/router').Router} */ (router$1);
@@ -12,11 +12,21 @@ function guard(name) {
 	};
 }
 
+const disableScrollHandling = import.meta.env.SSR
+	? guard('disableScrollHandling')
+	: disableScrollHandling_;
 const goto = import.meta.env.SSR ? guard('goto') : goto_;
 const invalidate = import.meta.env.SSR ? guard('invalidate') : invalidate_;
 const prefetch = import.meta.env.SSR ? guard('prefetch') : prefetch_;
 const prefetchRoutes = import.meta.env.SSR ? guard('prefetchRoutes') : prefetchRoutes_;
 
+/**
+ * @type {import('$app/navigation').goto}
+ */
+async function disableScrollHandling_() {
+	renderer.disable_scroll_handling();
+}
+
 /**
  * @type {import('$app/navigation').goto}
  */
@@ -52,4 +62,4 @@ async function prefetchRoutes_(pathnames) {
 	await Promise.all(promises);
 }
 
-export { goto, invalidate, prefetch, prefetchRoutes };
+export { disableScrollHandling, goto, invalidate, prefetch, prefetchRoutes };

package/assets/runtime/internal/singletons.js

@@ -1,9 +1,18 @@
 /** @type {import('./router').Router?} */
 let router;
 
-/** @param {import('./router').Router?} _ */
-function init(_) {
-	router = _;
+/** @type {import('./renderer').Renderer} */
+let renderer;
+
+/**
+ * @param {{
+ *   router: import('./router').Router?;
+ *   renderer: import('./renderer').Renderer;
+ * }} opts
+ */
+function init(opts) {
+	router = opts.router;
+	renderer = opts.renderer;
 }
 
-export { init, router };
+export { init, renderer, router };

package/assets/runtime/internal/start.js

@@ -1,6 +1,7 @@
 import Root from '../../generated/root.svelte';
 import { fallback, routes } from '../../generated/manifest.js';
 import { g as get_base_uri } from '../chunks/utils.js';
+import { tick } from 'svelte';
 import { writable } from 'svelte/store';
 import { init } from './singletons.js';
 import { set_paths } from '../paths.js';
@@ -162,16 +163,17 @@ class Router {
 
 			if (!this.owns(url)) return;
 
-			const noscroll = a.hasAttribute('sveltekit:noscroll');
+			// Check if new url only differs by hash
+			if (url.href.split('#')[0] === location.href.split('#')[0]) {
+				// Call `pushState` to add url to history so going back works.
+				// Also make a delay, otherwise the browser default behaviour would not kick in
+				setTimeout(() => history.pushState({}, '', url.href));
+				return;
+			}
 
-			const i1 = url_string.indexOf('#');
-			const i2 = location.href.indexOf('#');
-			const u1 = i1 >= 0 ? url_string.substring(0, i1) : url_string;
-			const u2 = i2 >= 0 ? location.href.substring(0, i2) : location.href;
 			history.pushState({}, '', url.href);
-			if (u1 === u2) {
-				window.dispatchEvent(new HashChangeEvent('hashchange'));
-			}
+
+			const noscroll = a.hasAttribute('sveltekit:noscroll');
 			this._navigate(url, noscroll ? scroll_state() : null, false, [], url.hash);
 			event.preventDefault();
 		});
@@ -466,6 +468,8 @@ class Renderer {
 		this.session_id = 1;
 		this.invalid = new Set();
 		this.invalidating = null;
+		this.autoscroll = true;
+		this.updating = false;
 
 		/** @type {import('./types').NavigationState} */
 		this.current = {
@@ -508,6 +512,16 @@ class Renderer {
 		ready = true;
 	}
 
+	disable_scroll_handling() {
+		if (import.meta.env.DEV && this.started && !this.updating) {
+			throw new Error('Can only disable scroll handling during navigation');
+		}
+
+		if (this.updating || !this.started) {
+			this.autoscroll = false;
+		}
+	}
+
 	/**
 	 * @param {{
 	 *   status: number;
@@ -637,6 +651,8 @@ class Renderer {
 			}
 		}
 
+		this.updating = true;
+
 		if (this.started) {
 			this.current = navigation_result.state;
 
@@ -646,7 +662,7 @@ class Renderer {
 			this._init(navigation_result);
 		}
 
-		// opts must be passed if we're navigating...
+		// opts must be passed if we're navigating
 		if (opts) {
 			const { hash, scroll, keepfocus } = opts;
 
@@ -655,26 +671,10 @@ class Renderer {
 				document.body.focus();
 			}
 
-			const old_page_y_offset = Math.round(pageYOffset);
-			const old_max_page_y_offset = document.documentElement.scrollHeight - innerHeight;
-
-			await 0;
-
-			const new_page_y_offset = Math.round(pageYOffset);
-			const new_max_page_y_offset = document.documentElement.scrollHeight - innerHeight;
-
-			// After `await 0`, the `onMount()` function in the component executed.
-			// Check if no scrolling happened on mount.
-			const no_scroll_happened =
-				// In most cases, we can compare whether `pageYOffset` changed between navigation
-				new_page_y_offset === Math.min(old_page_y_offset, new_max_page_y_offset) ||
-				// But if the page is scrolled to/near the bottom, the browser would also scroll
-				// to/near the bottom of the new page on navigation. Since we can't detect when this
-				// behaviour happens, we naively compare by the y offset from the bottom of the page.
-				old_max_page_y_offset - old_page_y_offset === new_max_page_y_offset - new_page_y_offset;
+			// need to render the DOM before we can scroll to the rendered elements
+			await tick();
 
-			// If there was no scrolling, we run on our custom scroll handling
-			if (no_scroll_happened) {
+			if (this.autoscroll) {
 				const deep_linked = hash && document.getElementById(hash.slice(1));
 				if (scroll) {
 					scrollTo(scroll.x, scroll.y);
@@ -688,12 +688,14 @@ class Renderer {
 				}
 			}
 		} else {
-			// ...they will not be supplied if we're simply invalidating
-			await 0;
+			// in this case we're simply invalidating
+			await tick();
 		}
 
 		this.loading.promise = null;
 		this.loading.id = null;
+		this.autoscroll = true;
+		this.updating = false;
 
 		if (!this.router) return;
 
@@ -1202,7 +1204,7 @@ async function start({ paths, target, session, route, spa, trailing_slash, hydra
 		  })
 		: null;
 
-	init(router);
+	init({ router, renderer });
 	set_paths(paths);
 
 	if (hydrate) await renderer.start(hydrate);

package/dist/chunks/error.js

@@ -9,13 +9,4 @@ function coalesce_to_error(err) {
 		: new Error(JSON.stringify(err));
 }
 
-/**
- * @param {Error} err
- * @param {any} errorCode
- * @return {err is Error & {code: any}}
- */
-function has_error_code(err, errorCode = undefined) {
-	return 'code' in err && (errorCode === undefined || /** @type {any} */ (err).code === errorCode);
-}
-
-export { coalesce_to_error as c, has_error_code as h };
+export { coalesce_to_error as c };

package/dist/chunks/index.js

@@ -12,7 +12,7 @@ import 'querystring';
 import { URL } from 'url';
 import require$$10 from 'vm';
 import vite from 'vite';
-import { r as resolve_entry, $, g as get_mime_lookup, a as rimraf, c as copy_assets, p as print_config_conflicts } from '../cli.js';
+import { r as resolve_entry, $, l as load_template, g as get_mime_lookup, a as rimraf, c as copy_assets, p as print_config_conflicts } from '../cli.js';
 import { c as create_manifest_data, a as create_app, d as deep_merge } from './index2.js';
 import { S as SVELTE_KIT, a as SVELTE_KIT_ASSETS } from './constants.js';
 import { respond } from '../ssr.js';
@@ -4407,8 +4407,7 @@ function create_plugin(config, output, cwd, amp) {
 								ssr: config.kit.ssr,
 								target: config.kit.target,
 								template: ({ head, body }) => {
-									let rendered = fs__default
-										.readFileSync(config.kit.files.template, 'utf8')
+									let rendered = load_template(cwd, config)
 										.replace('%svelte.head%', () => head)
 										.replace('%svelte.body%', () => body);
 

package/dist/chunks/index3.js

@@ -1,6 +1,6 @@
 import fs__default from 'fs';
 import path__default from 'path';
-import { p as print_config_conflicts, c as copy_assets, b as posixify, r as resolve_entry, m as mkdirp, a as rimraf } from '../cli.js';
+import { p as print_config_conflicts, c as copy_assets, b as posixify, r as resolve_entry, l as load_template, m as mkdirp, a as rimraf } from '../cli.js';
 import { d as deep_merge, a as create_app, c as create_manifest_data } from './index2.js';
 import { S as SVELTE_KIT } from './constants.js';
 import { g as generate_manifest } from './index4.js';
@@ -247,21 +247,22 @@ async function build_client({
 
 /**
  * @param {{
- *   runtime: string,
- *   hooks: string,
- *   config: import('types/config').ValidatedConfig,
- *   has_service_worker: boolean
+ *   cwd: string;
+ *   runtime: string;
+ *   hooks: string;
+ *   config: import('types/config').ValidatedConfig;
+ *   has_service_worker: boolean;
  * }} opts
  * @returns
  */
-const template = ({ config, hooks, runtime, has_service_worker }) => `
+const template = ({ cwd, config, hooks, runtime, has_service_worker }) => `
 import { respond } from '${runtime}';
 import root from './generated/root.svelte';
 import { set_paths, assets, base } from './runtime/paths.js';
 import { set_prerendering } from './runtime/env.js';
 import * as user_hooks from ${s(hooks)};
 
-const template = ({ head, body }) => ${s(fs__default.readFileSync(config.kit.files.template, 'utf-8'))
+const template = ({ head, body }) => ${s(load_template(cwd, config))
 	.replace('%svelte.head%', '" + head + "')
 	.replace('%svelte.body%', '" + body + "')};
 
@@ -415,6 +416,7 @@ async function build_server(
 	fs__default.writeFileSync(
 		input.app,
 		template({
+			cwd,
 			config,
 			hooks: app_relative(hooks_file),
 			runtime,

package/dist/chunks/index5.js

@@ -1,4 +1,4 @@
-import { m as mkdirp, a as rimraf, d as copy, $, l as logger } from '../cli.js';
+import { m as mkdirp, a as rimraf, d as copy, $, e as logger } from '../cli.js';
 import { S as SVELTE_KIT } from './constants.js';
 import { readFileSync, writeFileSync } from 'fs';
 import { resolve, join, dirname } from 'path';

package/dist/chunks/url.js

@@ -1,5 +1,5 @@
 /**
- * @param {Record<string, string | string[]>} headers
+ * @param {Record<string, string | string[] | undefined>} headers
  * @param {string} key
  * @returns {string | undefined}
  * @throws {Error}

package/dist/cli.js

@@ -1,12 +1,12 @@
-import fs__default, { existsSync } from 'fs';
 import sade from 'sade';
 import path__default, { relative } from 'path';
 import { exec as exec$1 } from 'child_process';
 import { createConnection, createServer } from 'net';
+import fs__default from 'fs';
 import * as url from 'url';
 import { fileURLToPath } from 'url';
 import { networkInterfaces, release } from 'os';
-import { c as coalesce_to_error, h as has_error_code } from './chunks/error.js';
+import { c as coalesce_to_error } from './chunks/error.js';
 
 let FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY=true;
 if (typeof process !== 'undefined') {
@@ -740,10 +740,10 @@ function assert_string(input, keypath) {
 
 /**
  * @param {string} cwd
- * @param {import('types/config').ValidatedConfig} validated
+ * @param {import('types/config').ValidatedConfig} config
  */
-function validate_template(cwd, validated) {
-	const { template } = validated.kit.files;
+function load_template(cwd, config) {
+	const { template } = config.kit.files;
 	const relative = path__default.relative(cwd, template);
 
 	if (fs__default.existsSync(template)) {
@@ -757,13 +757,19 @@ function validate_template(cwd, validated) {
 	} else {
 		throw new Error(`${relative} does not exist`);
 	}
+
+	return fs__default.readFileSync(template, 'utf-8');
 }
 
 async function load_config({ cwd = process.cwd() } = {}) {
-	const config_file_esm = path__default.join(cwd, 'svelte.config.js');
-	const config_file = fs__default.existsSync(config_file_esm)
-		? config_file_esm
-		: path__default.join(cwd, 'svelte.config.cjs');
+	const config_file = path__default.join(cwd, 'svelte.config.js');
+
+	if (!fs__default.existsSync(config_file)) {
+		throw new Error(
+			'You need to create a svelte.config.js file. See https://kit.svelte.dev/docs#configuration'
+		);
+	}
+
 	const config = await import(url.pathToFileURL(config_file).href);
 
 	const validated = validate_config(config.default);
@@ -775,10 +781,6 @@ async function load_config({ cwd = process.cwd() } = {}) {
 	validated.kit.files.serviceWorker = path__default.resolve(cwd, validated.kit.files.serviceWorker);
 	validated.kit.files.template = path__default.resolve(cwd, validated.kit.files.template);
 
-	validate_template(cwd, validated);
-
-	// TODO check all the `files` exist when the config is loaded?
-
 	return validated;
 }
 
@@ -787,17 +789,9 @@ async function load_config({ cwd = process.cwd() } = {}) {
  * @returns {import('types/config').ValidatedConfig}
  */
 function validate_config(config) {
-	const type = typeof config;
-
-	if (type === 'undefined') {
-		throw new Error(
-			'Your config is missing default exports. Make sure to include "export default config;"'
-		);
-	}
-
-	if (type !== 'object') {
+	if (typeof config !== 'object') {
 		throw new Error(
-			`Unexpected config type "${type}", make sure your default export is an object.`
+			'svelte.config.js must have a configuration object as its default export. See https://kit.svelte.dev/docs#configuration'
 		);
 	}
 
@@ -819,52 +813,17 @@ function print_config_conflicts(conflicts, pathPrefix = '', scope) {
 	});
 }
 
-async function get_config() {
-	// TODO this is temporary, for the benefit of early adopters
-	if (existsSync('svelte.config.cjs')) {
-		// prettier-ignore
-		console.error($.bold().red(
-			'svelte.config.cjs should be renamed to svelte.config.js and converted to an ES module. See https://kit.svelte.dev/docs#configuration for an example'
-		));
-	}
+/** @param {unknown} e */
+function handle_error(e) {
+	const error = coalesce_to_error(e);
 
-	if (existsSync('vite.config.js')) {
-		// prettier-ignore
-		console.error($.bold().red(
-			'Please remove vite.config.js and put Vite config in svelte.config.js: https://kit.svelte.dev/docs#configuration-vite'
-		));
-	}
-
-	try {
-		return await load_config();
-	} catch (err) {
-		const error = coalesce_to_error(err);
-		let message = error.message;
-
-		if (
-			has_error_code(error, 'MODULE_NOT_FOUND') &&
-			/Cannot find module svelte\.config\./.test(error.message)
-		) {
-			message = 'Missing svelte.config.js';
-		} else if (error.name === 'SyntaxError') {
-			message = 'Malformed svelte.config.js';
-		}
+	if (error.name === 'SyntaxError') throw error;
 
-		console.error($.bold().red(message));
-		if (error.stack) {
-			console.error($.grey(error.stack));
-		}
-		process.exit(1);
+	console.log($.bold().red(`> ${error.message}`));
+	if (error.stack) {
+		console.log($.gray(error.stack.split('\n').slice(1).join('\n')));
 	}
-}
 
-/** @param {unknown} error */
-function handle_error(error) {
-	const err = coalesce_to_error(error);
-	console.log($.bold().red(`> ${err.message}`));
-	if (err.stack) {
-		console.log($.gray(err.stack));
-	}
 	process.exit(1);
 }
 
@@ -887,7 +846,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.213');
+const prog = sade('svelte-kit').version('1.0.0-next.217');
 
 prog
 	.command('dev')
@@ -897,12 +856,12 @@ prog
 	.option('-H, --https', 'Use self-signed HTTPS certificate')
 	.option('-o, --open', 'Open a browser tab')
 	.action(async ({ port, host, https, open }) => {
-		process.env.NODE_ENV = process.env.NODE_ENV || 'development';
-		const config = await get_config();
+		try {
+			process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+			const config = await load_config();
 
-		const { dev } = await import('./chunks/index.js');
+			const { dev } = await import('./chunks/index.js');
 
-		try {
 			const cwd = process.cwd();
 
 			const { address_info, server_config } = await dev({
@@ -932,10 +891,10 @@ prog
 	.describe('Create a production build of your app')
 	.option('--verbose', 'Log more stuff', false)
 	.action(async ({ verbose }) => {
-		process.env.NODE_ENV = process.env.NODE_ENV || 'production';
-		const config = await get_config();
-
 		try {
+			process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+			const config = await load_config();
+
 			const { build } = await import('./chunks/index3.js');
 			const build_data = await build(config);
 
@@ -970,14 +929,14 @@ prog
 	.option('-H, --https', 'Use self-signed HTTPS certificate', false)
 	.option('-o, --open', 'Open a browser tab', false)
 	.action(async ({ port, host, https, open }) => {
-		await check_port(port);
+		try {
+			await check_port(port);
 
-		process.env.NODE_ENV = process.env.NODE_ENV || 'production';
-		const config = await get_config();
+			process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+			const config = await load_config();
 
-		const { preview } = await import('./chunks/index6.js');
+			const { preview } = await import('./chunks/index6.js');
 
-		try {
 			await preview({ port, host, config, https });
 
 			welcome({ port, host, https, open });
@@ -991,11 +950,11 @@ prog
 	.describe('Create a package')
 	.option('-d, --dir', 'Destination directory', 'package')
 	.action(async () => {
-		const config = await get_config();
+		try {
+			const config = await load_config();
 
-		const { make_package } = await import('./chunks/index7.js');
+			const { make_package } = await import('./chunks/index7.js');
 
-		try {
 			await make_package(config);
 		} catch (error) {
 			handle_error(error);
@@ -1039,7 +998,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.213'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.217'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';
@@ -1076,4 +1035,4 @@ function welcome({ port, host, https, open, loose, allow, cwd }) {
 	console.log('\n');
 }
 
-export { $, rimraf as a, posixify as b, copy_assets as c, copy as d, get_mime_lookup as g, logger as l, mkdirp as m, print_config_conflicts as p, resolve_entry as r, walk as w };
+export { $, rimraf as a, posixify as b, copy_assets as c, copy as d, logger as e, get_mime_lookup as g, load_template as l, mkdirp as m, print_config_conflicts as p, resolve_entry as r, walk as w };

package/dist/ssr.js

@@ -50,21 +50,24 @@ function is_string(s) {
 	return typeof s === 'string' || s instanceof String;
 }
 
+const text_types = new Set([
+	'application/xml',
+	'application/json',
+	'application/x-www-form-urlencoded',
+	'multipart/form-data'
+]);
+
 /**
  * Decides how the body should be parsed based on its mime type. Should match what's in parse_body
  *
  * @param {string | undefined | null} content_type The `content-type` header of a request/response.
  * @returns {boolean}
  */
-function is_content_type_textual(content_type) {
+function is_text(content_type) {
 	if (!content_type) return true; // defaults to json
-	const [type] = content_type.split(';'); // get the mime type
-	return (
-		type === 'text/plain' ||
-		type === 'application/json' ||
-		type === 'application/x-www-form-urlencoded' ||
-		type === 'multipart/form-data'
-	);
+	const type = content_type.split(';')[0].toLowerCase(); // get the mime type
+
+	return type.startsWith('text/') || type.endsWith('+xml') || text_types.has(type);
 }
 
 /**
@@ -103,9 +106,7 @@ async function render_endpoint(request, route, match) {
 	headers = lowercase_keys(headers);
 	const type = get_single_valued_header(headers, 'content-type');
 
-	const is_type_textual = is_content_type_textual(type);
-
-	if (!is_type_textual && !(body instanceof Uint8Array || is_string(body))) {
+	if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
 		return error(
 			`${preface}: body must be an instance of string or Uint8Array if content-type is not a supported textual content-type`
 		);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.213",
+  "version": "1.0.0-next.217",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -15,6 +15,7 @@
     "vite": "^2.7.2"
   },
   "devDependencies": {
+    "@playwright/test": "^1.17.1",
     "@rollup/plugin-replace": "^3.0.0",
     "@types/amphtml-validator": "^1.0.1",
     "@types/cookie": "^0.4.1",
@@ -24,6 +25,7 @@
     "@types/sade": "^1.7.3",
     "amphtml-validator": "^1.0.35",
     "cookie": "^0.4.1",
+    "cross-env": "^7.0.3",
     "devalue": "^2.0.1",
     "eslint": "^8.3.0",
     "kleur": "^4.1.4",
@@ -37,6 +39,7 @@
     "sirv": "^1.0.19",
     "svelte": "^3.44.2",
     "svelte-check": "^2.2.10",
+    "svelte-preprocess": "^4.9.8",
     "svelte2tsx": "~0.4.10",
     "tiny-glob": "^0.2.9",
     "uvu": "^0.5.2"
@@ -85,6 +88,10 @@
     "test": "npm run test:unit && npm run test:packaging && npm run test:integration",
     "test:unit": "uvu src \"(spec\\.js|test[\\\\/]index\\.js)\" -i packaging",
     "test:packaging": "uvu src/packaging \"(spec\\.js|test[\\\\/]index\\.js)\"",
-    "test:integration": "uvu test test.js"
+    "test:integration": "pnpm test:integration:amp && pnpm test:integration:basics && pnpm test:integration:options && pnpm test:integration:options-2",
+    "test:integration:amp": "cd test/apps/amp && pnpm test",
+    "test:integration:basics": "cd test/apps/basics && pnpm test",
+    "test:integration:options": "cd test/apps/options && pnpm test",
+    "test:integration:options-2": "cd test/apps/options-2 && pnpm test"
   }
 }

package/types/ambient-modules.d.ts

@@ -26,6 +26,11 @@ declare module '$app/env' {
 }
 
 declare module '$app/navigation' {
+	/**
+	 * Disable SvelteKit's built-in scroll handling for the current navigation, in case you need to manually control the scroll position.
+	 * This is generally discouraged, since it breaks user expectations.
+	 */
+	export function disableScrollHandling(): void;
 	/**
 	 * Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) to the specified href.
 	 *

package/types/endpoint.d.ts

@@ -5,7 +5,7 @@ type DefaultBody = JSONString | Uint8Array;
 
 export interface EndpointOutput<Body extends DefaultBody = DefaultBody> {
 	status?: number;
-	headers?: ResponseHeaders;
+	headers?: Partial<ResponseHeaders>;
 	body?: Body;
 }
 

package/types/hooks.d.ts

@@ -15,7 +15,7 @@ export interface ServerRequest<Locals = Record<string, any>, Body = unknown> {
 
 export interface ServerResponse {
 	status: number;
-	headers: ResponseHeaders;
+	headers: Partial<ResponseHeaders>;
 	body?: StrictBody;
 }