@sveltejs/kit 1.0.0-next.359 → 1.0.0-next.361

package/assets/client/start.js

@@ -1140,7 +1140,11 @@ function create_client({ target, session, base, trailing_slash }) {
 							props = res.status === 204 ? {} : await res.json();
 						} else {
 							status = res.status;
-							error = new Error('Failed to load data');
+							try {
+								error = await res.json();
+							} catch (e) {
+								error = new Error('Failed to load data');
+							}
 						}
 					}
 

package/assets/server/index.js

@@ -20,6 +20,60 @@ function to_headers(object) {
 	return headers;
 }
 
+/**
+ * Given an Accept header and a list of possible content types, pick
+ * the most suitable one to respond with
+ * @param {string} accept
+ * @param {string[]} types
+ */
+function negotiate(accept, types) {
+	const parts = accept
+		.split(',')
+		.map((str, i) => {
+			const match = /([^/]+)\/([^;]+)(?:;q=([0-9.]+))?/.exec(str);
+			if (match) {
+				const [, type, subtype, q = '1'] = match;
+				return { type, subtype, q: +q, i };
+			}
+
+			throw new Error(`Invalid Accept header: ${accept}`);
+		})
+		.sort((a, b) => {
+			if (a.q !== b.q) {
+				return b.q - a.q;
+			}
+
+			if ((a.subtype === '*') !== (b.subtype === '*')) {
+				return a.subtype === '*' ? 1 : -1;
+			}
+
+			if ((a.type === '*') !== (b.type === '*')) {
+				return a.type === '*' ? 1 : -1;
+			}
+
+			return a.i - b.i;
+		});
+
+	let accepted;
+	let min_priority = Infinity;
+
+	for (const mimetype of types) {
+		const [type, subtype] = mimetype.split('/');
+		const priority = parts.findIndex(
+			(part) =>
+				(part.type === type || part.type === '*') &&
+				(part.subtype === subtype || part.subtype === '*')
+		);
+
+		if (priority !== -1 && priority < min_priority) {
+			accepted = mimetype;
+			min_priority = priority;
+		}
+	}
+
+	return accepted;
+}
+
 /**
  * Hash using djb2
  * @param {import('types').StrictBody} value
@@ -95,6 +149,47 @@ function normalize_request_method(event) {
 	return method === 'delete' ? 'del' : method; // 'delete' is a reserved word
 }
 
+/**
+ * Serialize an error into a JSON string, by copying its `name`, `message`
+ * and (in dev) `stack`, plus any custom properties, plus recursively
+ * serialized `cause` properties. This is necessary because
+ * `JSON.stringify(error) === '{}'`
+ * @param {Error} error
+ * @param {(error: Error) => string | undefined} get_stack
+ */
+function serialize_error(error, get_stack) {
+	return JSON.stringify(clone_error(error, get_stack));
+}
+
+/**
+ * @param {Error} error
+ * @param {(error: Error) => string | undefined} get_stack
+ */
+function clone_error(error, get_stack) {
+	const {
+		name,
+		message,
+		// this should constitute 'using' a var, since it affects `custom`
+		// eslint-disable-next-line
+		stack,
+		// @ts-expect-error i guess typescript doesn't know about error.cause yet
+		cause,
+		...custom
+	} = error;
+
+	/** @type {Record<string, any>} */
+	const object = { name, message, stack: get_stack(error) };
+
+	if (cause) object.cause = clone_error(cause, get_stack);
+
+	for (const key in custom) {
+		// @ts-expect-error
+		object[key] = custom[key];
+	}
+
+	return object;
+}
+
 /** @param {string} body */
 function error(body) {
 	return new Response(body, {
@@ -132,9 +227,10 @@ function is_text(content_type) {
 /**
  * @param {import('types').RequestEvent} event
  * @param {{ [method: string]: import('types').RequestHandler }} mod
+ * @param {import('types').SSROptions} options
  * @returns {Promise<Response>}
  */
-async function render_endpoint(event, mod) {
+async function render_endpoint(event, mod, options) {
 	const method = normalize_request_method(event);
 
 	/** @type {import('types').RequestHandler} */
@@ -193,9 +289,12 @@ async function render_endpoint(event, mod) {
 
 	const type = headers.get('content-type');
 
-	if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
+	if (
+		!is_text(type) &&
+		!(body instanceof Uint8Array || body instanceof ReadableStream || 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`
+			`${preface}: body must be an instance of string, Uint8Array or ReadableStream if content-type is not a supported textual content-type`
 		);
 	}
 
@@ -204,7 +303,8 @@ async function render_endpoint(event, mod) {
 
 	if (is_pojo(body) && (!type || type.startsWith('application/json'))) {
 		headers.set('content-type', 'application/json; charset=utf-8');
-		normalized_body = JSON.stringify(body);
+		normalized_body =
+			body instanceof Error ? serialize_error(body, options.get_stack) : JSON.stringify(body);
 	} else {
 		normalized_body = /** @type {import('types').StrictBody} */ (body);
 	}
@@ -1182,10 +1282,14 @@ async function render_response({
 		}
 	}
 
-	const stylesheets = new Set(options.manifest._.entry.css);
-	const modulepreloads = new Set(options.manifest._.entry.js);
+	const { entry } = options.manifest._;
+
+	const stylesheets = new Set(entry.stylesheets);
+	const modulepreloads = new Set(entry.imports);
+
 	/** @type {Map<string, string>} */
-	const styles = new Map();
+	// TODO if we add a client entry point one day, we will need to include inline_styles with the entry, otherwise stylesheets will be linked even if they are below inlineStyleThreshold
+	const inline_styles = new Map();
 
 	/** @type {Array<import('./types').Fetched>} */
 	const serialized_data = [];
@@ -1203,10 +1307,18 @@ async function render_response({
 	}
 
 	if (resolve_opts.ssr) {
-		branch.forEach(({ node, props, loaded, fetched, uses_credentials }) => {
-			if (node.css) node.css.forEach((url) => stylesheets.add(url));
-			if (node.js) node.js.forEach((url) => modulepreloads.add(url));
-			if (node.styles) Object.entries(node.styles).forEach(([k, v]) => styles.set(k, v));
+		for (const { node, props, loaded, fetched, uses_credentials } of branch) {
+			if (node.imports) {
+				node.imports.forEach((url) => modulepreloads.add(url));
+			}
+
+			if (node.stylesheets) {
+				node.stylesheets.forEach((url) => stylesheets.add(url));
+			}
+
+			if (node.inline_styles) {
+				Object.entries(await node.inline_styles()).forEach(([k, v]) => inline_styles.set(k, v));
+			}
 
 			// TODO probably better if `fetched` wasn't populated unless `hydrate`
 			if (fetched && page_config.hydrate) serialized_data.push(...fetched);
@@ -1214,7 +1326,7 @@ async function render_response({
 
 			cache = loaded?.cache;
 			is_private = cache?.private ?? uses_credentials;
-		});
+		}
 
 		const session = writable($session);
 
@@ -1275,8 +1387,6 @@ async function render_response({
 
 	let { head, html: body } = rendered;
 
-	const inlined_style = Array.from(styles.values()).join('\n');
-
 	await csp_ready;
 	const csp = new Csp(options.csp, {
 		dev: options.dev,
@@ -1288,7 +1398,7 @@ async function render_response({
 
 	// prettier-ignore
 	const init_app = `
-		import { start } from ${s(options.prefix + options.manifest._.entry.file)};
+		import { start } from ${s(options.prefix + entry.file)};
 		start({
 			target: document.querySelector('[data-sveltekit-hydrate="${target}"]').parentNode,
 			paths: ${s(options.paths)},
@@ -1300,7 +1410,7 @@ async function render_response({
 			trailing_slash: ${s(options.trailing_slash)},
 			hydrate: ${resolve_opts.ssr && page_config.hydrate ? `{
 				status: ${status},
-				error: ${serialize_error(error)},
+				error: ${error && serialize_error(error, e => e.stack)},
 				nodes: [${branch.map(({ node }) => node.index).join(', ')}],
 				params: ${devalue(event.params)},
 				routeId: ${s(event.routeId)}
@@ -1316,14 +1426,16 @@ async function render_response({
 		}
 	`;
 
-	if (inlined_style) {
+	if (inline_styles.size > 0) {
+		const content = Array.from(inline_styles.values()).join('\n');
+
 		const attributes = [];
 		if (options.dev) attributes.push(' data-sveltekit');
 		if (csp.style_needs_nonce) attributes.push(` nonce="${csp.nonce}"`);
 
-		csp.add_style(inlined_style);
+		csp.add_style(content);
 
-		head += `\n\t<style${attributes.join('')}>${inlined_style}</style>`;
+		head += `\n\t<style${attributes.join('')}>${content}</style>`;
 	}
 
 	// prettier-ignore
@@ -1338,7 +1450,7 @@ async function render_response({
 				attributes.push(`nonce="${csp.nonce}"`);
 			}
 
-			if (styles.has(dep)) {
+			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)"');
@@ -1419,10 +1531,6 @@ async function render_response({
 		headers.set('cache-control', `${is_private ? 'private' : 'public'}, max-age=${cache.maxage}`);
 	}
 
-	if (!options.floc) {
-		headers.set('permissions-policy', 'interest-cohort=()');
-	}
-
 	if (!state.prerendering) {
 		const csp_header = csp.get_header();
 		if (csp_header) {
@@ -1449,22 +1557,6 @@ function try_serialize(data, fail) {
 	}
 }
 
-// Ensure we return something truthy so the client will not re-render the page over the error
-
-/** @param {(Error & {frame?: string} & {loc?: object}) | undefined | null} error */
-function serialize_error(error) {
-	if (!error) return null;
-	let serialized = try_serialize(error);
-	if (!serialized) {
-		const { name, message, stack } = error;
-		serialized = try_serialize({ ...error, name, message, stack });
-	}
-	if (!serialized) {
-		serialized = '{}';
-	}
-	return serialized;
-}
-
 /*!
  * cookie
  * Copyright(c) 2012-2014 Roman Shtylman
@@ -2163,6 +2255,7 @@ async function load_node({
 				for (const [key, value] of event.request.headers) {
 					if (
 						key !== 'authorization' &&
+						key !== 'connection' &&
 						key !== 'cookie' &&
 						key !== 'host' &&
 						key !== 'if-none-match' &&
@@ -2395,7 +2488,7 @@ async function load_node({
 
 		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.entry})` : ''}`);
+			throw new Error(`load function must return a value${options.dev ? ` (${node.file})` : ''}`);
 		}
 	} else if (shadow.body) {
 		loaded = {
@@ -2469,22 +2562,23 @@ async function load_shadow_data(route, event, options, prerender) {
 		};
 
 		if (!is_get) {
-			const result = await handler(event);
-
-			// TODO remove for 1.0
-			// @ts-expect-error
-			if (result.fallthrough) {
-				throw new Error(
-					'fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-matching'
-				);
-			}
-
-			const { status, headers, body } = validate_shadow_output(result);
+			const { status, headers, body } = validate_shadow_output(await handler(event));
+			add_cookies(/** @type {string[]} */ (data.cookies), headers);
 			data.status = status;
 
-			add_cookies(/** @type {string[]} */ (data.cookies), headers);
+			// explicit errors cause an error page...
+			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.error = body;
+				}
 
-			// Redirects are respected...
+				return data;
+			}
+
+			// ...redirects are respected...
 			if (status >= 300 && status < 400) {
 				data.redirect = /** @type {string} */ (
 					headers instanceof Headers ? headers.get('location') : headers.location
@@ -2500,20 +2594,21 @@ async function load_shadow_data(route, event, options, prerender) {
 
 		const get = (method === 'head' && mod.head) || mod.get;
 		if (get) {
-			const result = await get(event);
-
-			// TODO remove for 1.0
-			// @ts-expect-error
-			if (result.fallthrough) {
-				throw new Error(
-					'fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-matching'
-				);
-			}
-
-			const { status, headers, body } = validate_shadow_output(result);
+			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.error = body;
+				}
+
+				return data;
+			}
+
 			if (status >= 400) {
 				data.error = new Error('Failed to load data');
 				return data;
@@ -2560,6 +2655,14 @@ function add_cookies(target, headers) {
  * @param {import('types').ShadowEndpointOutput} result
  */
 function validate_shadow_output(result) {
+	// TODO remove for 1.0
+	// @ts-expect-error
+	if (result.fallthrough) {
+		throw new Error(
+			'fallthrough is no longer supported. Use matchers instead: https://kit.svelte.dev/docs/routing#advanced-routing-matching'
+		);
+	}
+
 	const { status = 200, body = {} } = result;
 	let headers = result.headers || {};
 
@@ -2574,7 +2677,9 @@ function validate_shadow_output(result) {
 	}
 
 	if (!is_pojo(body)) {
-		throw new Error('Body returned from endpoint request handler must be a plain object');
+		throw new Error(
+			'Body returned from endpoint request handler must be a plain object or an Error'
+		);
 	}
 
 	return { status, headers, body };
@@ -2967,7 +3072,7 @@ async function render_page(event, route, options, state, resolve_opts) {
 		]);
 
 		if (type === 'application/json') {
-			return render_endpoint(event, await route.shadow());
+			return render_endpoint(event, await route.shadow(), options);
 		}
 	}
 
@@ -2983,58 +3088,6 @@ async function render_page(event, route, options, state, resolve_opts) {
 	});
 }
 
-/**
- * @param {string} accept
- * @param {string[]} types
- */
-function negotiate(accept, types) {
-	const parts = accept
-		.split(',')
-		.map((str, i) => {
-			const match = /([^/]+)\/([^;]+)(?:;q=([0-9.]+))?/.exec(str);
-			if (match) {
-				const [, type, subtype, q = '1'] = match;
-				return { type, subtype, q: +q, i };
-			}
-
-			throw new Error(`Invalid Accept header: ${accept}`);
-		})
-		.sort((a, b) => {
-			if (a.q !== b.q) {
-				return b.q - a.q;
-			}
-
-			if ((a.subtype === '*') !== (b.subtype === '*')) {
-				return a.subtype === '*' ? 1 : -1;
-			}
-
-			if ((a.type === '*') !== (b.type === '*')) {
-				return a.type === '*' ? 1 : -1;
-			}
-
-			return a.i - b.i;
-		});
-
-	let accepted;
-	let min_priority = Infinity;
-
-	for (const mimetype of types) {
-		const [type, subtype] = mimetype.split('/');
-		const priority = parts.findIndex(
-			(part) =>
-				(part.type === type || part.type === '*') &&
-				(part.subtype === subtype || part.subtype === '*')
-		);
-
-		if (priority !== -1 && priority < min_priority) {
-			accepted = mimetype;
-			min_priority = priority;
-		}
-	}
-
-	return accepted;
-}
-
 /**
  * @param {RegExpMatchArray} match
  * @param {string[]} names
@@ -3265,7 +3318,7 @@ async function respond(request, options, state) {
 					let response;
 
 					if (is_data_request && route.type === 'page' && route.shadow) {
-						response = await render_endpoint(event, await route.shadow());
+						response = await render_endpoint(event, await route.shadow(), options);
 
 						// loading data for a client-side transition is a special case
 						if (request.headers.has('x-sveltekit-load')) {
@@ -3287,7 +3340,7 @@ async function respond(request, options, state) {
 					} else {
 						response =
 							route.type === 'endpoint'
-								? await render_endpoint(event, await route.load())
+								? await render_endpoint(event, await route.load(), options)
 								: await render_page(event, route, options, state, resolve_opts);
 					}
 
@@ -3371,6 +3424,18 @@ async function respond(request, options, state) {
 
 		options.handle_error(error, event);
 
+		const type = negotiate(event.request.headers.get('accept') || 'text/html', [
+			'text/html',
+			'application/json'
+		]);
+
+		if (is_data_request || type === 'application/json') {
+			return new Response(serialize_error(error, options.get_stack), {
+				status: 500,
+				headers: { 'content-type': 'application/json; charset=utf-8' }
+			});
+		}
+
 		try {
 			const $session = await options.hooks.getSession(event);
 			return await respond_with_error({

package/dist/chunks/error.js

@@ -239,8 +239,6 @@ const options = object(
 				template: string(join('src', 'app.html'))
 			}),
 
-			floc: boolean(false),
-
 			// TODO: remove this for the 1.0 release
 			headers: error(
 				(keypath) =>

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.359');
+const prog = sade('svelte-kit').version('1.0.0-next.361');
 
 prog
 	.command('package')

package/dist/vite.js

@@ -4,7 +4,7 @@ import path__default, { join, dirname, resolve as resolve$1, normalize } from 'p
 import { a as load_template, $, c as coalesce_to_error, l as load_config } from './chunks/error.js';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import * as vite from 'vite';
-import { searchForWorkspaceRoot } 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 { pathToFileURL, URL as URL$1 } from 'url';
@@ -39,16 +39,15 @@ import 'node:fs';
 import 'node:path';
 
 /**
+ * @param {import('vite').ConfigEnv} config_env
  * @return {Promise<import('vite').UserConfig>}
  */
-async function get_vite_config() {
-	for (const file of ['vite.config.js', 'vite.config.mjs', 'vite.config.cjs']) {
-		if (fs__default.existsSync(file)) {
-			const config = await import(pathToFileURL(file).toString());
-			return config.default || config;
-		}
+async function get_vite_config(config_env) {
+	const config = (await loadConfigFromFile(config_env))?.config;
+	if (!config) {
+		throw new Error('Could not load Vite config');
 	}
-	throw new Error('Could not find vite.config.js');
+	return config;
 }
 
 /**
@@ -199,24 +198,47 @@ async function create_build(config) {
 
 /**
  * Adds transitive JS and CSS dependencies to the js and css inputs.
- * @param {string} file
  * @param {import('vite').Manifest} manifest
- * @param {Set<string>} css
- * @param {Set<string>} js
+ * @param {string} entry
+ * @param {boolean} add_dynamic_css
  */
-function find_deps$1(file, manifest, js, css) {
-	const chunk = manifest[file];
+function find_deps$1(manifest, entry, add_dynamic_css) {
+	/** @type {Set<string>} */
+	const imports = new Set();
 
-	if (js.has(chunk.file)) return;
-	js.add(chunk.file);
+	/** @type {Set<string>} */
+	const stylesheets = new Set();
 
-	if (chunk.css) {
-		chunk.css.forEach((file) => css.add(file));
-	}
+	/**
+	 * @param {string} file
+	 * @param {boolean} add_js
+	 */
+	function traverse(file, add_js) {
+		const chunk = manifest[file];
+
+		if (imports.has(chunk.file)) return;
+		if (add_js) imports.add(chunk.file);
+
+		if (chunk.css) {
+			chunk.css.forEach((file) => stylesheets.add(file));
+		}
+
+		if (chunk.imports) {
+			chunk.imports.forEach((file) => traverse(file, add_js));
+		}
 
-	if (chunk.imports) {
-		chunk.imports.forEach((file) => find_deps$1(file, manifest, js, css));
+		if (add_dynamic_css && chunk.dynamicImports) {
+			chunk.dynamicImports.forEach((file) => traverse(file, false));
+		}
 	}
+
+	traverse(entry, true);
+
+	return {
+		file: manifest[entry].file,
+		imports: Array.from(imports),
+		stylesheets: Array.from(stylesheets)
+	};
 }
 
 /**
@@ -331,7 +353,6 @@ export class Server {
 		this.options = {
 			csp: ${s(config.kit.csp)},
 			dev: false,
-			floc: ${config.kit.floc},
 			get_stack: error => String(error), // for security
 			handle_error: (error, event) => {
 				this.options.hooks.handleError({
@@ -390,6 +411,7 @@ export class Server {
  * @param {{
  *   cwd: string;
  *   config: import('types').ValidatedConfig
+ *   vite_config_env: import('vite').ConfigEnv
  *   manifest_data: import('types').ManifestData
  *   build_dir: string;
  *   output_dir: string;
@@ -398,7 +420,15 @@ export class Server {
  * @param {{ vite_manifest: import('vite').Manifest, assets: import('rollup').OutputAsset[] }} client
  */
 async function build_server(options, client) {
-	const { cwd, config, manifest_data, build_dir, output_dir, service_worker_entry_file } = options;
+	const {
+		cwd,
+		config,
+		vite_config_env,
+		manifest_data,
+		build_dir,
+		output_dir,
+		service_worker_entry_file
+	} = options;
 
 	let hooks_file = resolve_entry(config.kit.files.hooks);
 	if (!hooks_file || !fs__default.existsSync(hooks_file)) {
@@ -457,7 +487,7 @@ async function build_server(options, client) {
 		})
 	);
 
-	const vite_config = await get_vite_config();
+	const vite_config = await get_vite_config(vite_config_env);
 
 	const merged_config = merge_vite_configs(
 		get_default_config({ config, input, ssr: true, outDir: `${output_dir}/server` }),
@@ -491,26 +521,22 @@ async function build_server(options, client) {
 	});
 
 	manifest_data.components.forEach((component, i) => {
-		const file = `${output_dir}/server/nodes/${i}.js`;
-
-		const js = new Set();
-		const css = new Set();
-		find_deps$1(component, client.vite_manifest, js, css);
+		const entry = find_deps$1(client.vite_manifest, component, true);
 
 		const imports = [`import * as module from '../${vite_manifest[component].file}';`];
 
 		const exports = [
 			'export { module };',
 			`export const index = ${i};`,
-			`export const entry = '${client.vite_manifest[component].file}';`,
-			`export const js = ${s(Array.from(js))};`,
-			`export const css = ${s(Array.from(css))};`
+			`export const file = '${entry.file}';`,
+			`export const imports = ${s(entry.imports)};`,
+			`export const stylesheets = ${s(entry.stylesheets)};`
 		];
 
 		/** @type {string[]} */
 		const styles = [];
 
-		css.forEach((file) => {
+		entry.stylesheets.forEach((file) => {
 			if (stylesheet_lookup.has(file)) {
 				const index = stylesheet_lookup.get(file);
 				const name = `stylesheet_${index}`;
@@ -520,10 +546,11 @@ async function build_server(options, client) {
 		});
 
 		if (styles.length > 0) {
-			exports.push(`export const styles = {\n${styles.join(',\n')}\n};`);
+			exports.push(`export const inline_styles = () => ({\n${styles.join(',\n')}\n});`);
 		}
 
-		fs__default.writeFileSync(file, `${imports.join('\n')}\n\n${exports.join('\n')}\n`);
+		const out = `${output_dir}/server/nodes/${i}.js`;
+		fs__default.writeFileSync(out, `${imports.join('\n')}\n\n${exports.join('\n')}\n`);
 	});
 
 	return {
@@ -630,6 +657,7 @@ function normalize_path(path, trailing_slash) {
 /**
  * @param {{
  *   config: import('types').ValidatedConfig;
+ *   vite_config_env: import('vite').ConfigEnv;
  *   manifest_data: import('types').ManifestData;
  *   output_dir: string;
  *   service_worker_entry_file: string | null;
@@ -638,7 +666,7 @@ function normalize_path(path, trailing_slash) {
  * @param {import('vite').Manifest} client_manifest
  */
 async function build_service_worker(
-	{ config, manifest_data, output_dir, service_worker_entry_file },
+	{ config, vite_config_env, manifest_data, output_dir, service_worker_entry_file },
 	prerendered,
 	client_manifest
 ) {
@@ -687,7 +715,7 @@ async function build_service_worker(
 			.trim()
 	);
 
-	const vite_config = await get_vite_config();
+	const vite_config = await get_vite_config(vite_config_env);
 	const merged_config = merge_vite_configs(vite_config, {
 		base: assets_base(config.kit),
 		build: {
@@ -2038,8 +2066,8 @@ async function dev(vite, svelte_config) {
 			_: {
 				entry: {
 					file: `/@fs${runtime}/client/start.js`,
-					css: [],
-					js: []
+					imports: [],
+					stylesheets: []
 				},
 				nodes: manifest_data.components.map((id, index) => {
 					return async () => {
@@ -2048,43 +2076,46 @@ async function dev(vite, svelte_config) {
 						const module = /** @type {import('types').SSRComponent} */ (
 							await vite.ssrLoadModule(url, { fixStacktrace: false })
 						);
-						const node = await vite.moduleGraph.getModuleByUrl(url);
-
-						if (!node) throw new Error(`Could not find node for ${url}`);
-
-						const deps = new Set();
-						await find_deps(vite, node, deps);
-
-						/** @type {Record<string, string>} */
-						const styles = {};
-
-						for (const dep of deps) {
-							const parsed = new URL$1(dep.url, 'http://localhost/');
-							const query = parsed.searchParams;
-
-							if (
-								style_pattern.test(dep.file) ||
-								(query.has('svelte') && query.get('type') === 'style')
-							) {
-								try {
-									const mod = await vite.ssrLoadModule(dep.url, { fixStacktrace: false });
-									styles[dep.url] = mod.default;
-								} catch {
-									// this can happen with dynamically imported modules, I think
-									// because the Vite module graph doesn't distinguish between
-									// static and dynamic imports? TODO investigate, submit fix
-								}
-							}
-						}
 
 						return {
 							module,
 							index,
-							entry: url.endsWith('.svelte') ? url : url + '?import',
-							css: [],
-							js: [],
+							file: url.endsWith('.svelte') ? url : url + '?import',
+							imports: [],
+							stylesheets: [],
 							// in dev we inline all styles to avoid FOUC
-							styles
+							inline_styles: async () => {
+								const node = await vite.moduleGraph.getModuleByUrl(url);
+
+								if (!node) throw new Error(`Could not find node for ${url}`);
+
+								const deps = new Set();
+								await find_deps(vite, node, deps);
+
+								/** @type {Record<string, string>} */
+								const styles = {};
+
+								for (const dep of deps) {
+									const parsed = new URL$1(dep.url, 'http://localhost/');
+									const query = parsed.searchParams;
+
+									if (
+										style_pattern.test(dep.file) ||
+										(query.has('svelte') && query.get('type') === 'style')
+									) {
+										try {
+											const mod = await vite.ssrLoadModule(dep.url, { fixStacktrace: false });
+											styles[dep.url] = mod.default;
+										} catch {
+											// this can happen with dynamically imported modules, I think
+											// because the Vite module graph doesn't distinguish between
+											// static and dynamic imports? TODO investigate, submit fix
+										}
+									}
+								}
+
+								return styles;
+							}
 						};
 					};
 				}),
@@ -2280,7 +2311,6 @@ async function dev(vite, svelte_config) {
 					{
 						csp: svelte_config.kit.csp,
 						dev: true,
-						floc: svelte_config.kit.floc,
 						get_stack: (error) => {
 							return fix_stack_trace(error);
 						},
@@ -2418,6 +2448,10 @@ async function find_deps(vite, node, deps) {
 		if (node.ssrTransformResult.deps) {
 			node.ssrTransformResult.deps.forEach((url) => branches.push(add_by_url(url)));
 		}
+
+		if (node.ssrTransformResult.dynamicDeps) {
+			node.ssrTransformResult.dynamicDeps.forEach((url) => branches.push(add_by_url(url)));
+		}
 	} else {
 		node.importedModules.forEach((node) => branches.push(add(node)));
 	}
@@ -2794,9 +2828,15 @@ function kit() {
 	/** @type {import('vite').UserConfig} */
 	let vite_config;
 
+	/** @type {import('vite').ConfigEnv} */
+	let vite_config_env;
+
 	/** @type {import('types').ManifestData} */
 	let manifest_data;
 
+	/** @type {boolean} */
+	let is_build;
+
 	/**
 	 * @type {{
 	 *   build_dir: string;
@@ -2836,9 +2876,11 @@ function kit() {
 	return {
 		name: 'vite-plugin-svelte-kit',
 
-		async config(config, { command }) {
+		async config(config, config_env) {
 			vite_config = config;
+			vite_config_env = config_env;
 			svelte_config = await load_config();
+			is_build = config_env.command === 'build';
 
 			paths = {
 				build_dir: `${svelte_config.kit.outDir}/build`,
@@ -2846,7 +2888,7 @@ function kit() {
 				client_out_dir: `${svelte_config.kit.outDir}/output/client/${svelte_config.kit.appDir}`
 			};
 
-			if (command === 'build') {
+			if (is_build) {
 				process.env.VITE_SVELTEKIT_APP_VERSION = svelte_config.kit.version.name;
 				process.env.VITE_SVELTEKIT_APP_VERSION_FILE = `${svelte_config.kit.appDir}/version.json`;
 				process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = `${svelte_config.kit.version.pollInterval}`;
@@ -2906,17 +2948,24 @@ function kit() {
 		},
 
 		buildStart() {
-			rimraf(paths.build_dir);
-			mkdirp(paths.build_dir);
+			if (is_build) {
+				rimraf(paths.build_dir);
+				mkdirp(paths.build_dir);
 
-			rimraf(paths.output_dir);
-			mkdirp(paths.output_dir);
+				rimraf(paths.output_dir);
+				mkdirp(paths.output_dir);
+			}
 		},
 
 		async writeBundle(_options, bundle) {
 			const verbose = vite_config.logLevel === 'info';
 			const log = logger({ verbose });
 
+			fs__default.writeFileSync(
+				`${paths.client_out_dir}/version.json`,
+				JSON.stringify({ version: process.env.VITE_SVELTEKIT_APP_VERSION })
+			);
+
 			/** @type {import('rollup').OutputChunk[]} */
 			const chunks = [];
 			/** @type {import('rollup').OutputAsset[]} */
@@ -2935,25 +2984,14 @@ function kit() {
 				fs__default.readFileSync(`${paths.client_out_dir}/immutable/manifest.json`, 'utf-8')
 			);
 
-			const entry = posixify(
+			const entry_id = posixify(
 				path__default.relative(cwd, `${get_runtime_path(svelte_config.kit)}/client/start.js`)
 			);
-			const entry_js = new Set();
-			const entry_css = new Set();
-			find_deps$1(entry, vite_manifest, entry_js, entry_css);
 
-			fs__default.writeFileSync(
-				`${paths.client_out_dir}/version.json`,
-				JSON.stringify({ version: process.env.VITE_SVELTEKIT_APP_VERSION })
-			);
 			const client = {
 				assets,
 				chunks,
-				entry: {
-					file: vite_manifest[entry].file,
-					js: Array.from(entry_js),
-					css: Array.from(entry_css)
-				},
+				entry: find_deps$1(vite_manifest, entry_id, false),
 				vite_manifest
 			};
 			log.info(`Client build completed. Wrote ${chunks.length} chunks and ${assets.length} assets`);
@@ -2961,6 +2999,7 @@ function kit() {
 			const options = {
 				cwd,
 				config: svelte_config,
+				vite_config_env,
 				build_dir: paths.build_dir, // TODO just pass `paths`
 				manifest_data,
 				output_dir: paths.output_dir,
@@ -3044,7 +3083,7 @@ function kit() {
 		},
 
 		closeBundle() {
-			if (svelte_config.kit.prerender.enabled) {
+			if (is_build && 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
 				// https://github.com/sveltejs/kit/issues/5306

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.359",
+  "version": "1.0.0-next.361",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -81,7 +81,7 @@
   },
   "types": "types/index.d.ts",
   "engines": {
-    "node": ">=16.7"
+    "node": ">=16.9"
   },
   "scripts": {
     "build": "rollup -c && node scripts/cp.js src/runtime/components assets/components && npm run types",

package/types/index.d.ts

@@ -117,7 +117,6 @@ export interface KitConfig {
 		serviceWorker?: string;
 		template?: string;
 	};
-	floc?: boolean;
 	inlineStyleThreshold?: number;
 	methodOverride?: {
 		parameter?: string;
@@ -268,7 +267,7 @@ export interface ResolveOptions {
 	transformPage?: ({ html }: { html: string }) => MaybePromise<string>;
 }
 
-export type ResponseBody = JSONValue | Uint8Array | ReadableStream;
+export type ResponseBody = JSONValue | Uint8Array | ReadableStream | Error;
 
 export class Server {
 	constructor(manifest: SSRManifest);
@@ -284,8 +283,8 @@ export interface SSRManifest {
 	_: {
 		entry: {
 			file: string;
-			js: string[];
-			css: string[];
+			imports: string[];
+			stylesheets: string[];
 		};
 		nodes: SSRNodeLoader[];
 		routes: SSRRoute[];

package/types/internal.d.ts

@@ -51,8 +51,8 @@ export interface BuildData {
 		chunks: OutputChunk[];
 		entry: {
 			file: string;
-			js: string[];
-			css: string[];
+			imports: string[];
+			stylesheets: string[];
 		};
 		vite_manifest: import('vite').Manifest;
 	};
@@ -176,13 +176,6 @@ export interface ShadowEndpointOutput<Output extends JSONObject = JSONObject> {
 	body?: Output;
 }
 
-/**
- * The route key of a page with a matching endpoint — used to ensure the
- * client loads data from the right endpoint during client-side navigation
- * rather than a different route that happens to match the path
- */
-type ShadowKey = string;
-
 export interface ShadowRequestHandler<Output extends JSONObject = JSONObject> {
 	(event: RequestEvent): MaybePromise<ShadowEndpointOutput<Output>>;
 }
@@ -230,13 +223,13 @@ export interface SSRNode {
 	/** index into the `components` array in client-manifest.js */
 	index: number;
 	/** client-side module URL for this component */
-	entry: string;
-	/** external CSS files */
-	css: string[];
+	file: string;
 	/** external JS files */
-	js: string[];
+	imports: string[];
+	/** external CSS files */
+	stylesheets: string[];
 	/** inlined styles */
-	styles?: Record<string, string>;
+	inline_styles?: () => MaybePromise<Record<string, string>>;
 }
 
 export type SSRNodeLoader = () => Promise<SSRNode>;
@@ -244,7 +237,6 @@ export type SSRNodeLoader = () => Promise<SSRNode>;
 export interface SSROptions {
 	csp: ValidatedConfig['kit']['csp'];
 	dev: boolean;
-	floc: boolean;
 	get_stack: (error: Error) => string | undefined;
 	handle_error(error: Error & { frame?: string }, event: RequestEvent): void;
 	hooks: Hooks;