@sveltejs/kit 1.0.0-next.372 → 1.0.0-next.375

package/assets/client/start.js

@@ -17,10 +17,14 @@ function coalesce_to_error(err) {
 }
 
 /**
- * @param {import('types').LoadOutput} loaded
+ * @param {import('types').LoadOutput | void} loaded
  * @returns {import('types').NormalizedLoadOutput}
  */
 function normalize(loaded) {
+	if (!loaded) {
+		return {};
+	}
+
 	// TODO remove for 1.0
 	// @ts-expect-error
 	if (loaded.fallthrough) {
@@ -40,7 +44,10 @@ function normalize(loaded) {
 		const status = loaded.status;
 
 		if (!loaded.error && has_error_status) {
-			return { status: status || 500, error: new Error() };
+			return {
+				status: status || 500,
+				error: new Error(`${status}`)
+			};
 		}
 
 		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
@@ -1030,24 +1037,17 @@ function create_client({ target, session, base, trailing_slash }) {
 				});
 			}
 
-			let loaded;
-
 			if (import.meta.env.DEV) {
 				try {
 					lock_fetch();
-					loaded = await module.load.call(null, load_input);
+					node.loaded = normalize(await module.load.call(null, load_input));
 				} finally {
 					unlock_fetch();
 				}
 			} else {
-				loaded = await module.load.call(null, load_input);
-			}
-
-			if (!loaded) {
-				throw new Error('load function must return a value');
+				node.loaded = normalize(await module.load.call(null, load_input));
 			}
 
-			node.loaded = normalize(loaded);
 			if (node.loaded.stuff) node.stuff = node.loaded.stuff;
 			if (node.loaded.dependencies) {
 				node.loaded.dependencies.forEach(add_dependency);
@@ -1088,7 +1088,7 @@ function create_client({ target, session, base, trailing_slash }) {
 		let stuff = root_stuff;
 		let stuff_changed = false;
 
-		/** @type {number | undefined} */
+		/** @type {number} */
 		let status = 200;
 
 		/** @type {Error | null} */
@@ -1174,7 +1174,7 @@ function create_client({ target, session, base, trailing_slash }) {
 
 						if (node.loaded) {
 							if (node.loaded.error) {
-								status = node.loaded.status;
+								status = node.loaded.status ?? 500;
 								error = node.loaded.error;
 							}
 
@@ -1703,7 +1703,7 @@ function create_client({ target, session, base, trailing_slash }) {
 						if (node.loaded.error) {
 							if (error) throw node.loaded.error;
 							error_args = {
-								status: node.loaded.status,
+								status: node.loaded.status ?? 500,
 								error: node.loaded.error,
 								url,
 								routeId

package/assets/server/index.js

@@ -192,6 +192,11 @@ function clone_error(error, get_stack) {
 	return object;
 }
 
+/** @type {import('types').SSRErrorPage} */
+const GENERIC_ERROR = {
+	id: '__error'
+};
+
 /** @param {string} body */
 function error(body) {
 	return new Response(body, {
@@ -1369,6 +1374,14 @@ async function render_response({
 	}
 
 	if (resolve_opts.ssr) {
+		const leaf = /** @type {import('./types.js').Loaded} */ (branch.at(-1));
+
+		if (leaf.loaded.status) {
+			// explicit status returned from `load` or a page endpoint trumps
+			// initial status
+			status = leaf.loaded.status;
+		}
+
 		for (const { node, props, loaded, fetched, uses_credentials } of branch) {
 			if (node.imports) {
 				node.imports.forEach((url) => modulepreloads.add(url));
@@ -2096,10 +2109,14 @@ var parseString_1 = setCookie.exports.parseString = parseString;
 var splitCookiesString_1 = setCookie.exports.splitCookiesString = splitCookiesString;
 
 /**
- * @param {import('types').LoadOutput} loaded
+ * @param {import('types').LoadOutput | void} loaded
  * @returns {import('types').NormalizedLoadOutput}
  */
 function normalize(loaded) {
+	if (!loaded) {
+		return {};
+	}
+
 	// TODO remove for 1.0
 	// @ts-expect-error
 	if (loaded.fallthrough) {
@@ -2119,7 +2136,10 @@ function normalize(loaded) {
 		const status = loaded.status;
 
 		if (!loaded.error && has_error_status) {
-			return { status: status || 500, error: new Error() };
+			return {
+				status: status || 500,
+				error: new Error(`${status}`)
+			};
 		}
 
 		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
@@ -2205,7 +2225,7 @@ function path_matches(path, constraint) {
  *   event: import('types').RequestEvent;
  *   options: import('types').SSROptions;
  *   state: import('types').SSRState;
- *   route: import('types').SSRPage | null;
+ *   route: import('types').SSRPage | import('types').SSRErrorPage;
  *   node: import('types').SSRNode;
  *   $session: any;
  *   stuff: Record<string, any>;
@@ -2241,7 +2261,7 @@ async function load_node({
 	/** @type {import('set-cookie-parser').Cookie[]} */
 	const new_cookies = [];
 
-	/** @type {import('types').LoadOutput} */
+	/** @type {import('types').NormalizedLoadOutput} */
 	let loaded;
 
 	const should_prerender = node.module.prerender ?? options.prerender.default;
@@ -2264,12 +2284,10 @@ async function load_node({
 
 	if (shadow.error) {
 		loaded = {
-			status: shadow.status,
 			error: shadow.error
 		};
 	} else if (shadow.redirect) {
 		loaded = {
-			status: shadow.status,
 			redirect: shadow.redirect
 		};
 	} else if (module.load) {
@@ -2537,7 +2555,7 @@ async function load_node({
 				return proxy;
 			},
 			stuff: { ...stuff },
-			status: is_error ? status ?? null : null,
+			status: (is_error ? status : shadow.status) ?? null,
 			error: is_error ? error ?? null : null
 		};
 
@@ -2550,12 +2568,7 @@ async function load_node({
 			});
 		}
 
-		loaded = await module.load.call(null, load_input);
-
-		if (!loaded) {
-			// TODO do we still want to enforce this now that there's no fallthrough?
-			throw new Error(`load function must return a value${options.dev ? ` (${node.file})` : ''}`);
-		}
+		loaded = normalize(await module.load.call(null, load_input));
 	} else if (shadow.body) {
 		loaded = {
 			props: shadow.body
@@ -2564,6 +2577,8 @@ async function load_node({
 		loaded = {};
 	}
 
+	loaded.status = loaded.status ?? shadow.status;
+
 	// generate __data.json files when prerendering
 	if (shadow.body && state.prerendering) {
 		const pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
@@ -2579,7 +2594,7 @@ async function load_node({
 	return {
 		node,
 		props: shadow.body,
-		loaded: normalize(loaded),
+		loaded,
 		stuff: loaded.stuff || stuff,
 		fetched,
 		set_cookie_headers: new_cookies.map((new_cookie) => {
@@ -2622,7 +2637,7 @@ async function load_shadow_data(route, event, options, prerender) {
 
 		/** @type {import('types').ShadowData} */
 		const data = {
-			status: 200,
+			status: undefined,
 			cookies: [],
 			body: {}
 		};
@@ -2662,13 +2677,13 @@ async function load_shadow_data(route, event, options, prerender) {
 		if (get) {
 			const { status, headers, body } = validate_shadow_output(await get(event));
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
-			data.status = status;
 
 			if (body instanceof Error) {
 				if (status < 400) {
 					data.status = 500;
 					data.error = new Error('A non-error status code was returned with an error body');
 				} else {
+					data.status = status;
 					data.error = body;
 				}
 
@@ -2676,11 +2691,13 @@ async function load_shadow_data(route, event, options, prerender) {
 			}
 
 			if (status >= 400) {
+				data.status = status;
 				data.error = new Error('Failed to load data');
 				return data;
 			}
 
 			if (status >= 300) {
+				data.status = status;
 				data.redirect = /** @type {string} */ (
 					headers instanceof Headers ? headers.get('location') : headers.location
 				);
@@ -2790,7 +2807,7 @@ async function respond_with_error({
 					event,
 					options,
 					state,
-					route: null,
+					route: GENERIC_ERROR,
 					node: default_layout,
 					$session,
 					stuff: {},
@@ -2799,12 +2816,16 @@ async function respond_with_error({
 				})
 			);
 
+			if (layout_loaded.loaded.error) {
+				throw layout_loaded.loaded.error;
+			}
+
 			const error_loaded = /** @type {Loaded} */ (
 				await load_node({
 					event,
 					options,
 					state,
-					route: null,
+					route: GENERIC_ERROR,
 					node: default_error,
 					$session,
 					stuff: layout_loaded ? layout_loaded.stuff : {},
@@ -2969,7 +2990,8 @@ async function respond$1(opts) {
 					}
 
 					if (loaded.loaded.error) {
-						({ status, error } = loaded.loaded);
+						error = loaded.loaded.error;
+						status = loaded.loaded.status ?? 500;
 					}
 				} catch (err) {
 					const e = coalesce_to_error(err);
@@ -3448,6 +3470,12 @@ async function respond(request, options, state) {
 					}
 				}
 
+				if (state.initiator === GENERIC_ERROR) {
+					return new Response('Internal Server Error', {
+						status: 500
+					});
+				}
+
 				// if this request came direct from the user, rather than
 				// via a `fetch` in a `load`, render a 404 page
 				if (!state.initiator) {
@@ -3502,6 +3530,7 @@ async function respond(request, options, state) {
 			});
 		}
 
+		// TODO is this necessary? should we just return a plain 500 at this point?
 		try {
 			const $session = await options.hooks.getSession(event);
 			return await respond_with_error({

package/dist/chunks/error.js

@@ -623,7 +623,7 @@ async function load_config({ cwd = process.cwd() } = {}) {
  * @param {import('types').Config} config
  * @returns {import('types').ValidatedConfig}
  */
-function process_config(config, { cwd = process.cwd() }) {
+function process_config(config, { cwd = process.cwd() } = {}) {
 	const validated = validate_config(config);
 
 	validated.kit.outDir = path__default.resolve(cwd, validated.kit.outDir);

package/dist/chunks/sync.js

@@ -107,9 +107,25 @@ var other = {"application/prs.cww":["cww"],"application/vnd.1000minds.decision-m
 let Mime = Mime_1;
 var mime = new Mime(standard, other);
 
-const get_runtime_path = /** @param {import('types').ValidatedKitConfig} config */ (config) =>
-			posixify_path(path__default.join(config.outDir, 'runtime'))
-	;
+/**
+ * Get the prefix for the `runtime` directory, for use with import declarations
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function get_runtime_prefix(config) {
+	{
+		return posixify_path(path__default.join(config.outDir, 'runtime'));
+	}
+}
+
+/**
+ * Get the resolved path of the `runtime` directory
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function get_runtime_directory(config) {
+	{
+		return path__default.join(config.outDir, 'runtime');
+	}
+}
 
 /** @param {string} str */
 function posixify_path(str) {
@@ -285,7 +301,7 @@ const DEFAULT = 'default';
  */
 function create_manifest_data({
 	config,
-	fallback = `${get_runtime_path(config.kit)}/components`,
+	fallback = `${get_runtime_directory(config.kit)}/components`,
 	cwd = process.cwd()
 }) {
 	/** @type {import('types').RouteData[]} */
@@ -989,4 +1005,4 @@ var sync = /*#__PURE__*/Object.freeze({
   all: all
 });
 
-export { get_mime_lookup as a, all as b, sync as c, get_runtime_path as g, init as i, logger as l, parse_route_id as p, s, update as u };
+export { get_runtime_prefix as a, get_mime_lookup as b, all as c, sync as d, get_runtime_directory as g, init as i, logger as l, parse_route_id as p, s, update as u };

package/dist/cli.js

@@ -18,7 +18,7 @@ function handle_error(e) {
 	process.exit(1);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.372');
+const prog = sade('svelte-kit').version('1.0.0-next.375');
 
 prog
 	.command('package')
@@ -46,7 +46,7 @@ prog
 
 		try {
 			const config = await load_config();
-			const sync = await import('./chunks/sync.js').then(function (n) { return n.c; });
+			const sync = await import('./chunks/sync.js').then(function (n) { return n.d; });
 			sync.all(config);
 		} catch (error) {
 			handle_error(error);

package/dist/node/polyfills.js

@@ -10389,7 +10389,7 @@ function requireFetch () {
 	}
 
 	// https://fetch.spec.whatwg.org/#finalize-and-report-timing
-	function finalizeAndReportTiming (response, initiatorType) {
+	function finalizeAndReportTiming (response, initiatorType = 'other') {
 	  // 1. If response is an aborted network error, then return.
 	  if (response.type === 'error' && response.aborted) {
 	    return
@@ -11553,7 +11553,10 @@ function requireFetch () {
 	    // 2. Let forwardResponse be the result of running HTTP-network fetch
 	    // given httpFetchParams, includeCredentials, and isNewConnectionFetch.
 	    const forwardResponse = await httpNetworkFetch(
-	      httpFetchParams);
+	      httpFetchParams,
+	      includeCredentials,
+	      isNewConnectionFetch
+	    );
 
 	    // 3. If httpRequest’s method is unsafe and forwardResponse’s status is
 	    // in the range 200 to 399, inclusive, invalidate appropriate stored
@@ -11655,8 +11658,8 @@ function requireFetch () {
 	// https://fetch.spec.whatwg.org/#http-network-fetch
 	async function httpNetworkFetch (
 	  fetchParams,
-	  includeCredentials,
-	  forceNewConnection
+	  includeCredentials = false,
+	  forceNewConnection = false
 	) {
 	  assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
 

package/dist/node.js

@@ -4495,7 +4495,7 @@ try {
 const POOL_SIZE = 65536;
 
 /** @param {(Blob | Uint8Array)[]} parts */
-async function * toIterator (parts, clone) {
+async function * toIterator (parts, clone = true) {
   for (const part of parts) {
     if ('stream' in part) {
       yield * (/** @type {AsyncIterableIterator<Uint8Array>} */ (part.stream()));

package/dist/vite.js

@@ -6,7 +6,7 @@ import { svelte } from '@sveltejs/vite-plugin-svelte';
 import * as vite from 'vite';
 import { loadConfigFromFile, searchForWorkspaceRoot } from 'vite';
 import { p as posixify, m as mkdirp, r as rimraf } from './chunks/write_tsconfig.js';
-import { g as get_runtime_path, s, i as init, u as update, a as get_mime_lookup, p as parse_route_id, b as all, l as logger } from './chunks/sync.js';
+import { g as get_runtime_directory, s, i as init, a as get_runtime_prefix, u as update, b as get_mime_lookup, p as parse_route_id, c as all, l as logger } from './chunks/sync.js';
 import { pathToFileURL, URL as URL$1 } from 'url';
 import { installPolyfills } from './node/polyfills.js';
 import * as qs from 'querystring';
@@ -127,7 +127,7 @@ function get_aliases(config) {
 	/** @type {Record<string, string>} */
 	const alias = {
 		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
-		$app: `${get_runtime_path(config)}/app`,
+		$app: `${get_runtime_directory(config)}/app`,
 
 		// For now, we handle `$lib` specially here rather than make it a default value for
 		// `config.kit.alias` since it has special meaning for packaging, etc.
@@ -253,12 +253,13 @@ function find_deps$1(manifest, entry, add_dynamic_css) {
  */
 const get_default_config = function ({ config, input, ssr, outDir }) {
 	return {
+		appType: 'custom',
 		base: assets_base(config.kit),
 		build: {
 			cssCodeSplit: true,
 			manifest: true,
 			outDir,
-			polyfillDynamicImport: false,
+			polyfillModulePreload: false,
 			rollupOptions: {
 				input,
 				output: {
@@ -278,7 +279,6 @@ const get_default_config = function ({ config, input, ssr, outDir }) {
 		resolve: {
 			alias: get_aliases(config.kit)
 		},
-		// @ts-expect-error
 		ssr: {
 			// when developing against the Kit src code, we want to ensure that
 			// our dependencies are bundled so that apps don't need to install
@@ -302,6 +302,9 @@ function assets_base(config) {
 }
 
 /**
+ * vite.config.js will contain vite-plugin-svelte-kit, which kicks off the server and service
+ * worker builds in a hook. When running the server and service worker builds we must remove
+ * the SvelteKit plugin so that we do not kick off additional instances of these builds.
  * @param {import('vite').UserConfig} config
  */
 function remove_svelte_kit(config) {
@@ -482,7 +485,7 @@ async function build_server(options, client) {
 			config,
 			hooks: app_relative(hooks_file),
 			has_service_worker: config.kit.serviceWorker.register && !!service_worker_entry_file,
-			runtime: get_runtime_path(config.kit),
+			runtime: posixify(path__default.relative(build_dir, get_runtime_directory(config.kit))),
 			template: load_template(cwd, config)
 		})
 	);
@@ -1950,7 +1953,7 @@ function toHeaders(name, stats, isEtag) {
 	return headers;
 }
 
-function sirv (dir, opts) {
+function sirv (dir, opts={}) {
 	dir = resolve$1(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
@@ -2049,7 +2052,7 @@ async function dev(vite, vite_config, svelte_config) {
 
 	init(svelte_config);
 
-	const runtime = get_runtime_path(svelte_config.kit);
+	const runtime = get_runtime_prefix(svelte_config.kit);
 
 	process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = '0';
 
@@ -2077,7 +2080,7 @@ async function dev(vite, vite_config, svelte_config) {
 						const url = id.startsWith('..') ? `/@fs${path__default.posix.resolve(id)}` : `/${id}`;
 
 						const module = /** @type {import('types').SSRComponent} */ (
-							await vite.ssrLoadModule(url, { fixStacktrace: false })
+							await vite.ssrLoadModule(url)
 						);
 
 						return {
@@ -2107,7 +2110,7 @@ async function dev(vite, vite_config, svelte_config) {
 										(query.has('svelte') && query.get('type') === 'style')
 									) {
 										try {
-											const mod = await vite.ssrLoadModule(dep.url, { fixStacktrace: false });
+											const mod = await vite.ssrLoadModule(dep.url);
 											styles[dep.url] = mod.default;
 										} catch {
 											// this can happen with dynamically imported modules, I think
@@ -2135,7 +2138,7 @@ async function dev(vite, vite_config, svelte_config) {
 							shadow: route.shadow
 								? async () => {
 										const url = path__default.resolve(cwd$1, /** @type {string} */ (route.shadow));
-										return await vite.ssrLoadModule(url, { fixStacktrace: false });
+										return await vite.ssrLoadModule(url);
 								  }
 								: null,
 							a: route.a.map((id) => (id ? manifest_data.components.indexOf(id) : undefined)),
@@ -2151,7 +2154,7 @@ async function dev(vite, vite_config, svelte_config) {
 						types,
 						load: async () => {
 							const url = path__default.resolve(cwd$1, route.file);
-							return await vite.ssrLoadModule(url, { fixStacktrace: false });
+							return await vite.ssrLoadModule(url);
 						}
 					};
 				}),
@@ -2162,7 +2165,7 @@ async function dev(vite, vite_config, svelte_config) {
 					for (const key in manifest_data.matchers) {
 						const file = manifest_data.matchers[key];
 						const url = path__default.resolve(cwd$1, file);
-						const module = await vite.ssrLoadModule(url, { fixStacktrace: false });
+						const module = await vite.ssrLoadModule(url);
 
 						if (module.match) {
 							matchers[key] = module.match;
@@ -2252,9 +2255,7 @@ async function dev(vite, vite_config, svelte_config) {
 
 				/** @type {Partial<import('types').Hooks>} */
 				const user_hooks = resolve_entry(svelte_config.kit.files.hooks)
-					? await vite.ssrLoadModule(`/${svelte_config.kit.files.hooks}`, {
-							fixStacktrace: false
-					  })
+					? await vite.ssrLoadModule(`/${svelte_config.kit.files.hooks}`)
 					: {};
 
 				const handle = user_hooks.handle || (({ event, resolve }) => resolve(event));
@@ -2294,15 +2295,13 @@ async function dev(vite, vite_config, svelte_config) {
 				// can get loaded twice via different URLs, which causes failures. Might
 				// require changes to Vite to fix
 				const { default: root } = await vite.ssrLoadModule(
-					`/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/generated/root.svelte`))}`,
-					{ fixStacktrace: false }
+					`/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/generated/root.svelte`))}`
 				);
 
 				const paths = await vite.ssrLoadModule(
 					true
 						? `/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/runtime/paths.js`))}`
-						: `/@fs${runtime}/paths.js`,
-					{ fixStacktrace: false }
+						: `/@fs${runtime}/paths.js`
 				);
 
 				paths.set_paths({
@@ -2408,7 +2407,7 @@ async function dev(vite, vite_config, svelte_config) {
 }
 
 /** @param {import('http').ServerResponse} res */
-function not_found(res, message) {
+function not_found(res, message = 'Not found') {
 	res.statusCode = 404;
 	res.end(message);
 }
@@ -2417,12 +2416,7 @@ function not_found(res, message) {
  * @param {import('connect').Server} server
  */
 function remove_html_middlewares(server) {
-	const html_middlewares = [
-		'viteIndexHtmlMiddleware',
-		'vite404Middleware',
-		'viteSpaFallbackMiddleware',
-		'viteServeStaticMiddleware'
-	];
+	const html_middlewares = ['viteServeStaticMiddleware'];
 	for (let i = server.stack.length - 1; i > 0; i--) {
 		// @ts-expect-error using internals until https://github.com/vitejs/vite/pull/4640 is merged
 		if (html_middlewares.includes(server.stack[i].handle.name)) {
@@ -2789,8 +2783,9 @@ function scoped(scope, handler) {
 
 const cwd = process.cwd();
 
-/** @type {Record<string, any>} */
+/** @type {import('./types').EnforcedConfig} */
 const enforced_config = {
+	appType: true,
 	base: true,
 	build: {
 		cssCodeSplit: true,
@@ -2802,7 +2797,7 @@ const enforced_config = {
 		},
 		manifest: true,
 		outDir: true,
-		polyfillDynamicImport: true,
+		polyfillModulePreload: true,
 		rollupOptions: {
 			input: true,
 			output: {
@@ -2834,6 +2829,15 @@ function sveltekit() {
 }
 
 /**
+ * Returns the SvelteKit Vite plugin. Vite executes Rollup hooks as well as some of its own.
+ * Background reading is available at:
+ * - https://vitejs.dev/guide/api-plugin.html
+ * - https://rollupjs.org/guide/en/#plugin-development
+ *
+ * You can get an idea of the lifecycle by looking at the flow charts here:
+ * - https://rollupjs.org/guide/en/#build-hooks
+ * - https://rollupjs.org/guide/en/#output-generation-hooks
+ *
  * @return {import('vite').Plugin}
  */
 function kit() {
@@ -2870,12 +2874,14 @@ function kit() {
 	 */
 	let paths;
 
-	function create_client_config() {
+	let completed_build = false;
+
+	function vite_client_config() {
 		/** @type {Record<string, string>} */
 		const input = {
 			// Put unchanging assets in immutable directory. We don't set that in the
 			// outDir so that other plugins can add mutable assets to the bundle
-			start: `${get_runtime_path(svelte_config.kit)}/client/start.js`
+			start: `${get_runtime_directory(svelte_config.kit)}/client/start.js`
 		};
 
 		// This step is optional — Vite/Rollup will create the necessary chunks
@@ -2899,9 +2905,38 @@ function kit() {
 		});
 	}
 
+	/**
+	 * @param {import('rollup').OutputAsset[]} assets
+	 * @param {import('rollup').OutputChunk[]} chunks
+	 */
+	function client_build_info(assets, chunks) {
+		/** @type {import('vite').Manifest} */
+		const vite_manifest = JSON.parse(
+			fs__default.readFileSync(`${paths.client_out_dir}/manifest.json`, 'utf-8')
+		);
+
+		const entry_id = posixify(
+			path__default.relative(cwd, `${get_runtime_directory(svelte_config.kit)}/client/start.js`)
+		);
+
+		return {
+			assets,
+			chunks,
+			entry: find_deps$1(vite_manifest, entry_id, false),
+			vite_manifest
+		};
+	}
+
+	// TODO remove this for 1.0
+	check_vite_version();
+
 	return {
 		name: 'vite-plugin-svelte-kit',
 
+		/**
+		 * Build the SvelteKit-provided Vite config to be merged with the user's vite.config.js file.
+		 * @see https://vitejs.dev/guide/api-plugin.html#config
+		 */
 		async config(config, config_env) {
 			vite_config_env = config_env;
 			svelte_config = await load_config();
@@ -2920,7 +2955,7 @@ function kit() {
 
 				manifest_data = all(svelte_config).manifest_data;
 
-				const new_config = create_client_config();
+				const new_config = vite_client_config();
 
 				warn_overridden_config(config, new_config);
 
@@ -2928,13 +2963,15 @@ function kit() {
 			}
 
 			// dev and preview config can be shared
+			/** @type {import('vite').UserConfig} */
 			const result = {
+				appType: 'custom',
 				base: '/',
 				build: {
 					rollupOptions: {
 						// Vite dependency crawler needs an explicit JS entry point
 						// eventhough server otherwise works without it
-						input: `${get_runtime_path(svelte_config.kit)}/client/start.js`
+						input: `${get_runtime_directory(svelte_config.kit)}/client/start.js`
 					}
 				},
 				resolve: {
@@ -2966,10 +3003,16 @@ function kit() {
 			return result;
 		},
 
+		/**
+		 * Stores the final config.
+		 */
 		configResolved(config) {
 			vite_config = config;
 		},
 
+		/**
+		 * Clears the output directories.
+		 */
 		buildStart() {
 			if (is_build) {
 				rimraf(paths.build_dir);
@@ -2980,6 +3023,11 @@ function kit() {
 			}
 		},
 
+		/**
+		 * Vite builds a single bundle. We need three bundles: client, server, and service worker.
+		 * The user's package.json scripts will invoke the Vite CLI to execute the client build. We
+		 * then use this hook to kick off builds for the server and service worker.
+		 */
 		async writeBundle(_options, bundle) {
 			log = logger({
 				verbose: vite_config.logLevel === 'info'
@@ -2990,36 +3038,10 @@ function kit() {
 				JSON.stringify({ version: process.env.VITE_SVELTEKIT_APP_VERSION })
 			);
 
-			/** @type {import('rollup').OutputChunk[]} */
-			const chunks = [];
-			/** @type {import('rollup').OutputAsset[]} */
-			const assets = [];
-			for (const key of Object.keys(bundle)) {
-				// collect asset and output chunks
-				if (bundle[key].type === 'asset') {
-					assets.push(/** @type {import('rollup').OutputAsset} */ (bundle[key]));
-				} else {
-					chunks.push(/** @type {import('rollup').OutputChunk} */ (bundle[key]));
-				}
-			}
-
-			/** @type {import('vite').Manifest} */
-			const vite_manifest = JSON.parse(
-				fs__default.readFileSync(`${paths.client_out_dir}/manifest.json`, 'utf-8')
-			);
-
-			const entry_id = posixify(
-				path__default.relative(cwd, `${get_runtime_path(svelte_config.kit)}/client/start.js`)
-			);
-
-			const client = {
-				assets,
-				chunks,
-				entry: find_deps$1(vite_manifest, entry_id, false),
-				vite_manifest
-			};
+			const { assets, chunks } = collect_output(bundle);
 			log.info(`Client build completed. Wrote ${chunks.length} chunks and ${assets.length} assets`);
 
+			log.info('Building server');
 			const options = {
 				cwd,
 				config: svelte_config,
@@ -3029,13 +3051,9 @@ function kit() {
 				output_dir: paths.output_dir,
 				service_worker_entry_file: resolve_entry(svelte_config.kit.files.serviceWorker)
 			};
-
-			log.info('Building server');
-
+			const client = client_build_info(assets, chunks);
 			const server = await build_server(options, client);
 
-			process.env.SVELTEKIT_SERVER_BUILD_COMPLETED = 'true';
-
 			/** @type {import('types').BuildData} */
 			build_data = {
 				app_dir: svelte_config.kit.appDir,
@@ -3054,6 +3072,9 @@ function kit() {
 				})};\n`
 			);
 
+			process.env.SVELTEKIT_SERVER_BUILD_COMPLETED = 'true';
+			log.info('Prerendering');
+
 			const static_files = manifest_data.assets.map((asset) => posixify(asset.file));
 
 			const files = new Set([
@@ -3069,8 +3090,6 @@ function kit() {
 				}
 			});
 
-			log.info('Prerendering');
-
 			prerendered = await prerender({
 				config: svelte_config.kit,
 				entries: manifest_data.routes
@@ -3093,12 +3112,20 @@ function kit() {
 			console.log(
 				`\nRun ${$.bold().cyan('npm run preview')} to preview your production build locally.`
 			);
+
+			completed_build = true;
 		},
 
+		/**
+		 * Runs the adapter.
+		 */
 		async closeBundle() {
-			if (!is_build) {
-				return; // vite calls closeBundle when dev-server restarts, ignore that
+			if (!completed_build) {
+				// vite calls closeBundle when dev-server restarts, ignore that,
+				// and only adapt when build successfully completes.
+				return;
 			}
+
 			if (svelte_config.kit.adapter) {
 				const { adapt } = await import('./chunks/index2.js');
 				await adapt(svelte_config, build_data, prerendered, { log });
@@ -3112,30 +3139,70 @@ function kit() {
 
 			if (svelte_config.kit.prerender.enabled) {
 				// this is necessary to close any open db connections, etc.
-				// TODO: prerender in a subprocess so we can exit in isolation
+				// TODO: prerender in a subprocess so we can exit in isolation and then remove this
 				// https://github.com/sveltejs/kit/issues/5306
 				process.exit(0);
 			}
 		},
 
+		/**
+		 * Adds the SvelteKit middleware to do SSR in dev mode.
+		 * @see https://vitejs.dev/guide/api-plugin.html#configureserver
+		 */
 		async configureServer(vite) {
 			return await dev(vite, vite_config, svelte_config);
 		},
 
+		/**
+		 * Adds the SvelteKit middleware to do SSR in preview mode.
+		 * @see https://vitejs.dev/guide/api-plugin.html#configurepreviewserver
+		 */
 		configurePreviewServer(vite) {
 			return preview(vite, svelte_config, vite_config.preview.https ? 'https' : 'http');
 		}
 	};
 }
 
+function check_vite_version() {
+	let vite_major = 3;
+
+	try {
+		const pkg = JSON.parse(fs__default.readFileSync('package.json', 'utf-8'));
+		vite_major = +pkg.devDependencies['vite'].replace(/^[~^]/, '')[0];
+	} catch {
+		// do nothing
+	}
+
+	if (vite_major < 3) {
+		throw new Error(
+			`Vite version ${vite_major} is no longer supported. Please upgrade to version 3`
+		);
+	}
+}
+
+/** @param {import('rollup').OutputBundle} bundle */
+function collect_output(bundle) {
+	/** @type {import('rollup').OutputChunk[]} */
+	const chunks = [];
+	/** @type {import('rollup').OutputAsset[]} */
+	const assets = [];
+	for (const value of Object.values(bundle)) {
+		// collect asset and output chunks
+		if (value.type === 'asset') {
+			assets.push(value);
+		} else {
+			chunks.push(value);
+		}
+	}
+	return { assets, chunks };
+}
+
 /**
  * @param {Record<string, any>} config
  * @param {Record<string, any>} resolved_config
- * @param {string} [path]
- * @param {string[]} [out] used locally to compute the return value
  */
-function warn_overridden_config(config, resolved_config, path = '', out = []) {
-	const overridden = find_overridden_config(config, resolved_config, path, out);
+function warn_overridden_config(config, resolved_config) {
+	const overridden = find_overridden_config(config, resolved_config, enforced_config, '', []);
 	if (overridden.length > 0) {
 		console.log(
 			$.bold().red('The following Vite config options will be overridden by SvelteKit:')
@@ -3147,16 +3214,21 @@ function warn_overridden_config(config, resolved_config, path = '', out = []) {
 /**
  * @param {Record<string, any>} config
  * @param {Record<string, any>} resolved_config
+ * @param {import('./types').EnforcedConfig} enforced_config
  * @param {string} path
  * @param {string[]} out used locally to compute the return value
  */
-function find_overridden_config(config, resolved_config, path, out) {
+function find_overridden_config(config, resolved_config, enforced_config, path, out) {
 	for (const key in enforced_config) {
 		if (typeof config === 'object' && config !== null && key in config) {
-			if (enforced_config[key] === true && config[key] !== resolved_config[key]) {
-				out.push(path + key);
+			const enforced = enforced_config[key];
+
+			if (enforced === true) {
+				if (config[key] !== resolved_config[key]) {
+					out.push(path + key);
+				}
 			} else {
-				find_overridden_config(config[key], resolved_config[key], path + key + '.', out);
+				find_overridden_config(config[key], resolved_config[key], enforced, path + key + '.', out);
 			}
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.372",
+  "version": "1.0.0-next.375",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -10,12 +10,12 @@
   "homepage": "https://kit.svelte.dev",
   "type": "module",
   "dependencies": {
-    "@sveltejs/vite-plugin-svelte": "1.0.0-next.49",
+    "@sveltejs/vite-plugin-svelte": "^1.0.1",
     "chokidar": "^3.5.3",
     "sade": "^1.8.1"
   },
   "devDependencies": {
-    "@playwright/test": "^1.22.2",
+    "@playwright/test": "^1.23.3",
     "@rollup/plugin-replace": "^4.0.0",
     "@types/connect": "^3.4.35",
     "@types/cookie": "^0.5.1",
@@ -33,7 +33,7 @@
     "marked": "^4.0.16",
     "mime": "^3.0.0",
     "node-fetch": "^3.2.4",
-    "rollup": "^2.75.3",
+    "rollup": "^2.75.7",
     "selfsigned": "^2.0.1",
     "set-cookie-parser": "^2.4.8",
     "sirv": "^2.0.2",
@@ -45,11 +45,11 @@
     "typescript": "^4.7.4",
     "undici": "^5.6.1",
     "uvu": "^0.5.3",
-    "vite": "^2.9.13"
+    "vite": "^3.0.0"
   },
   "peerDependencies": {
     "svelte": "^3.44.0",
-    "vite": "^2.9.10"
+    "vite": "^3.0.0"
   },
   "bin": {
     "svelte-kit": "svelte-kit.js"

package/types/ambient.d.ts

@@ -80,7 +80,7 @@ declare module '$app/env' {
 	export const dev: boolean;
 
 	/**
-	 * The Vite.js mode the app is running in. Configure in `config.kit.vite.mode`.
+	 * The Vite.js mode the app is running in. Configure in [`vite.config.js`](https://vitejs.dev/config/shared-options.html#mode).
 	 * Vite.js loads the dotenv file associated with the provided mode, `.env.[mode]` or `.env.[mode].local`.
 	 * By default, `vite dev` runs with `mode=development` and `vite build` runs with `mode=production`.
 	 */

package/types/index.d.ts

@@ -151,7 +151,6 @@ export interface KitConfig {
 		name?: string;
 		pollInterval?: number;
 	};
-	vite?: import('vite').UserConfig | (() => MaybePromise<import('vite').UserConfig>);
 }
 
 export interface ExternalFetch {
@@ -183,7 +182,7 @@ export interface Load<
 	InputProps extends Record<string, any> = Record<string, any>,
 	OutputProps extends Record<string, any> = InputProps
 > {
-	(event: LoadEvent<Params, InputProps>): MaybePromise<LoadOutput<OutputProps>>;
+	(event: LoadEvent<Params, InputProps>): MaybePromise<LoadOutput<OutputProps> | void>;
 }
 
 export interface LoadEvent<

package/types/internal.d.ts

@@ -113,7 +113,7 @@ export interface MethodOverride {
 }
 
 export type NormalizedLoadOutput = {
-	status: number;
+	status?: number;
 	error?: Error;
 	redirect?: string;
 	props?: Record<string, any> | Promise<Record<string, any>>;
@@ -153,12 +153,9 @@ export interface PrerenderOptions {
 
 export type RecursiveRequired<T> = {
 	// Recursive implementation of TypeScript's Required utility type.
-	// Will recursively continue until it reaches primitive or union
-	// with a Function in it, except those commented below
+	// Will recursively continue until it reaches a primitive or Function
 	[K in keyof T]-?: Extract<T[K], Function> extends never // If it does not have a Function type
 		? RecursiveRequired<T[K]> // recursively continue through.
-		: K extends 'vite' // If it reaches the 'vite' key
-		? Extract<T[K], Function> // only take the Function type.
 		: T[K]; // Use the exact type for everything else
 };
 
@@ -293,6 +290,10 @@ export interface SSRPage {
 	b: Array<number | undefined>;
 }
 
+export interface SSRErrorPage {
+	id: '__error';
+}
+
 export interface SSRPagePart {
 	id: string;
 	load: SSRComponentLoader;
@@ -303,7 +304,7 @@ export type SSRRoute = SSREndpoint | SSRPage;
 export interface SSRState {
 	fallback?: string;
 	getClientAddress: () => string;
-	initiator?: SSRPage | null;
+	initiator?: SSRPage | SSRErrorPage;
 	platform?: any;
 	prerendering?: PrerenderOptions;
 }