@sveltejs/kit 1.0.0-next.215 → 1.0.0-next.219

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`
 		);
@@ -743,10 +744,18 @@ async function render_response({
 		headers['permissions-policy'] = 'interest-cohort=()';
 	}
 
+	const segments = url.pathname.slice(options.paths.base.length).split('/').slice(2);
+	const assets =
+		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
+
 	return {
 		status,
 		headers,
-		body: options.template({ head, body })
+		body: options.template({
+			head,
+			body,
+			assets
+		})
 	};
 }
 
@@ -1213,53 +1222,53 @@ async function load_node({
  * }} opts
  */
 async function respond_with_error({ request, options, state, $session, status, error }) {
-	const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
-	const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
-
-	/** @type {Record<string, string>} */
-	const params = {}; // error page has no params
+	try {
+		const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
+		const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
 
-	// error pages don't fall through, so we know it's not undefined
-	const loaded = /** @type {Loaded} */ (
-		await load_node({
-			request,
-			options,
-			state,
-			route: null,
-			url: request.url, // TODO this is redundant, no?
-			params,
-			node: default_layout,
-			$session,
-			stuff: {},
-			prerender_enabled: is_prerender_enabled(options, default_error, state),
-			is_leaf: false,
-			is_error: false
-		})
-	);
+		/** @type {Record<string, string>} */
+		const params = {}; // error page has no params
 
-	const branch = [
-		loaded,
-		/** @type {Loaded} */ (
+		// error pages don't fall through, so we know it's not undefined
+		const loaded = /** @type {Loaded} */ (
 			await load_node({
 				request,
 				options,
 				state,
 				route: null,
-				url: request.url,
+				url: request.url, // TODO this is redundant, no?
 				params,
-				node: default_error,
+				node: default_layout,
 				$session,
-				stuff: loaded ? loaded.stuff : {},
+				stuff: {},
 				prerender_enabled: is_prerender_enabled(options, default_error, state),
 				is_leaf: false,
-				is_error: true,
-				status,
-				error
+				is_error: false
 			})
-		)
-	];
+		);
+
+		const branch = [
+			loaded,
+			/** @type {Loaded} */ (
+				await load_node({
+					request,
+					options,
+					state,
+					route: null,
+					url: request.url,
+					params,
+					node: default_error,
+					$session,
+					stuff: loaded ? loaded.stuff : {},
+					prerender_enabled: is_prerender_enabled(options, default_error, state),
+					is_leaf: false,
+					is_error: true,
+					status,
+					error
+				})
+			)
+		];
 
-	try {
 		return await render_response({
 			options,
 			$session,
@@ -1896,16 +1905,30 @@ async function respond(incoming, options, state = {}) {
 				}
 			}
 		});
-	} catch (/** @type {unknown} */ err) {
-		const e = coalesce_to_error(err);
+	} catch (/** @type {unknown} */ e) {
+		const error = coalesce_to_error(e);
 
-		options.handle_error(e, request);
+		options.handle_error(error, request);
 
-		return {
-			status: 500,
-			headers: {},
-			body: options.dev ? e.stack : e.message
-		};
+		try {
+			const $session = await options.hooks.getSession(request);
+			return await respond_with_error({
+				request,
+				options,
+				state,
+				$session,
+				status: 500,
+				error
+			});
+		} catch (/** @type {unknown} */ e) {
+			const error = coalesce_to_error(e);
+
+			return {
+				status: 500,
+				headers: {},
+				body: options.dev ? error.stack : error.message
+			};
+		}
 	}
 }
 

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';
@@ -661,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;
 
@@ -670,7 +671,8 @@ class Renderer {
 				document.body.focus();
 			}
 
-			await 0;
+			// need to render the DOM before we can scroll to the rendered elements
+			await tick();
 
 			if (this.autoscroll) {
 				const deep_linked = hash && document.getElementById(hash.slice(1));
@@ -686,8 +688,8 @@ 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;

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';
@@ -4406,11 +4406,11 @@ function create_plugin(config, output, cwd, amp) {
 								router: config.kit.router,
 								ssr: config.kit.ssr,
 								target: config.kit.target,
-								template: ({ head, body }) => {
-									let rendered = fs__default
-										.readFileSync(config.kit.files.template, 'utf8')
+								template: ({ head, body, assets }) => {
+									let rendered = load_template(cwd, config)
 										.replace('%svelte.head%', () => head)
-										.replace('%svelte.body%', () => body);
+										.replace('%svelte.body%', () => body)
+										.replace(/%svelte\.assets%/g, assets);
 
 									if (amp) {
 										const result = amp.validateString(rendered);

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,23 +247,25 @@ 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, assets }) => ${s(load_template(cwd, config))
 	.replace('%svelte.head%', '" + head + "')
-	.replace('%svelte.body%', '" + body + "')};
+	.replace('%svelte.body%', '" + body + "')
+	.replace(/%svelte\.assets%/g, '" + assets + "')};
 
 let read = null;
 
@@ -415,6 +417,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';
@@ -470,6 +470,8 @@ function create_builder({ cwd, config, build_data, log }) {
 		mkdirp,
 		copy,
 
+		appDir: config.kit.appDir,
+
 		createEntries(fn) {
 			generated_manifest = true;
 

package/dist/chunks/index6.js

@@ -16,6 +16,19 @@ import 'node:util';
 import 'node:url';
 import 'net';
 
+function totalist(dir, callback, pre='') {
+	dir = resolve('.', dir);
+	let arr = readdirSync(dir);
+	let i=0, abs, stats;
+	for (; i < arr.length; i++) {
+		abs = join(dir, arr[i]);
+		stats = statSync(abs);
+		stats.isDirectory()
+			? totalist(abs, callback, join(pre, arr[i]))
+			: callback(join(pre, arr[i]), abs, stats);
+	}
+}
+
 /**
  * @typedef ParsedURL
  * @type {import('.').ParsedURL}
@@ -55,19 +68,6 @@ function parse(req) {
 	return req._parsedUrl = { pathname, search, query, raw };
 }
 
-function list(dir, callback, pre='') {
-	dir = resolve('.', dir);
-	let arr = readdirSync(dir);
-	let i=0, abs, stats;
-	for (; i < arr.length; i++) {
-		abs = join(dir, arr[i]);
-		stats = statSync(abs);
-		stats.isDirectory()
-			? list(abs, callback, join(pre, arr[i]))
-			: callback(join(pre, arr[i]), abs, stats);
-	}
-}
-
 const mimes = {
   "ez": "application/andrew-inset",
   "aw": "application/applixware",
@@ -625,7 +625,7 @@ function sirv (dir, opts={}) {
 	else if (cc && opts.maxAge === 0) cc += ',must-revalidate';
 
 	if (!opts.dev) {
-		list(dir, (name, abs, stats) => {
+		totalist(dir, (name, abs, stats) => {
 			if (/\.well-known[\\+\/]/.test(name)) ; // keep
 			else if (!opts.dotfiles && /(^\.|[\\+|\/+]\.)/.test(name)) return;
 

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.215');
+const prog = sade('svelte-kit').version('1.0.0-next.219');
 
 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.215'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.219'}\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`
 		);
@@ -712,10 +713,18 @@ async function render_response({
 		headers['permissions-policy'] = 'interest-cohort=()';
 	}
 
+	const segments = url.pathname.slice(options.paths.base.length).split('/').slice(2);
+	const assets =
+		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
+
 	return {
 		status,
 		headers,
-		body: options.template({ head, body })
+		body: options.template({
+			head,
+			body,
+			assets
+		})
 	};
 }
 
@@ -1143,53 +1152,53 @@ async function load_node({
  * }} opts
  */
 async function respond_with_error({ request, options, state, $session, status, error }) {
-	const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
-	const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
-
-	/** @type {Record<string, string>} */
-	const params = {}; // error page has no params
+	try {
+		const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
+		const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
 
-	// error pages don't fall through, so we know it's not undefined
-	const loaded = /** @type {Loaded} */ (
-		await load_node({
-			request,
-			options,
-			state,
-			route: null,
-			url: request.url, // TODO this is redundant, no?
-			params,
-			node: default_layout,
-			$session,
-			stuff: {},
-			prerender_enabled: is_prerender_enabled(options, default_error, state),
-			is_leaf: false,
-			is_error: false
-		})
-	);
+		/** @type {Record<string, string>} */
+		const params = {}; // error page has no params
 
-	const branch = [
-		loaded,
-		/** @type {Loaded} */ (
+		// error pages don't fall through, so we know it's not undefined
+		const loaded = /** @type {Loaded} */ (
 			await load_node({
 				request,
 				options,
 				state,
 				route: null,
-				url: request.url,
+				url: request.url, // TODO this is redundant, no?
 				params,
-				node: default_error,
+				node: default_layout,
 				$session,
-				stuff: loaded ? loaded.stuff : {},
+				stuff: {},
 				prerender_enabled: is_prerender_enabled(options, default_error, state),
 				is_leaf: false,
-				is_error: true,
-				status,
-				error
+				is_error: false
 			})
-		)
-	];
+		);
+
+		const branch = [
+			loaded,
+			/** @type {Loaded} */ (
+				await load_node({
+					request,
+					options,
+					state,
+					route: null,
+					url: request.url,
+					params,
+					node: default_error,
+					$session,
+					stuff: loaded ? loaded.stuff : {},
+					prerender_enabled: is_prerender_enabled(options, default_error, state),
+					is_leaf: false,
+					is_error: true,
+					status,
+					error
+				})
+			)
+		];
 
-	try {
 		return await render_response({
 			options,
 			$session,
@@ -1826,16 +1835,30 @@ async function respond(incoming, options, state = {}) {
 				}
 			}
 		});
-	} catch (/** @type {unknown} */ err) {
-		const e = coalesce_to_error(err);
+	} catch (/** @type {unknown} */ e) {
+		const error = coalesce_to_error(e);
 
-		options.handle_error(e, request);
+		options.handle_error(error, request);
 
-		return {
-			status: 500,
-			headers: {},
-			body: options.dev ? e.stack : e.message
-		};
+		try {
+			const $session = await options.hooks.getSession(request);
+			return await respond_with_error({
+				request,
+				options,
+				state,
+				$session,
+				status: 500,
+				error
+			});
+		} catch (/** @type {unknown} */ e) {
+			const error = coalesce_to_error(e);
+
+			return {
+				status: 500,
+				headers: {},
+				body: options.dev ? error.stack : error.message
+			};
+		}
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.215",
+  "version": "1.0.0-next.219",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -36,9 +36,10 @@
     "port-authority": "^1.1.2",
     "rollup": "^2.60.2",
     "selfsigned": "^1.10.11",
-    "sirv": "^1.0.19",
+    "sirv": "^2.0.0",
     "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"

package/types/config.d.ts

@@ -38,6 +38,8 @@ export interface Builder {
 	rimraf(dir: string): void;
 	mkdirp(dir: string): void;
 
+	appDir: string;
+
 	/**
 	 * Create entry points that map to individual functions
 	 * @param fn A function that groups a set of routes into an entry point

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;
 }
 

package/types/internal.d.ts

@@ -144,7 +144,7 @@ export interface SSRRenderOptions {
 	service_worker?: string;
 	ssr: boolean;
 	target: string;
-	template({ head, body }: { head: string; body: string }): string;
+	template({ head, body, assets }: { head: string; body: string; assets: string }): string;
 	trailing_slash: TrailingSlash;
 }