@sveltejs/kit 1.0.0-next.210 → 1.0.0-next.211

package/dist/chunks/index.js

@@ -1,29 +1,28 @@
-import require$$0$2, { EventEmitter } from 'events';
-import fs__default from 'fs';
 import path__default from 'path';
-import { URL } from 'url';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import require$$0$1 from 'util';
 import require$$0 from 'os';
+import fs__default from 'fs';
 import require$$2 from 'http';
 import require$$3 from 'https';
+import require$$0$2 from 'events';
 import require$$1 from 'child_process';
 import require$$0$3 from 'domain';
 import 'querystring';
+import { URL } from 'url';
 import require$$10 from 'vm';
-import CheapWatch from 'cheap-watch';
-import { r as rimraf, c as copy_assets, p as print_config_conflicts, g as get_mime_lookup, a as resolve_entry, $ } from '../cli.js';
 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 { 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';
-import { d as deep_merge, c as create_manifest_data, a as create_app } from './index2.js';
 import { __fetch_polyfill } from '../install-fetch.js';
 import { getRawBody } from '../node.js';
-import { S as SVELTE_KIT, a as SVELTE_KIT_ASSETS } from './constants.js';
 import { c as coalesce_to_error } from './error.js';
 import 'sade';
 import 'net';
-import './url.js';
 import './misc.js';
+import './url.js';
 import 'node:http';
 import 'node:https';
 import 'node:zlib';
@@ -4201,429 +4200,229 @@ function main() {
 
 amphtmlValidator.main = main;
 
-/** @typedef {{ cwd?: string, port: number, host?: string, https: boolean, config: import('types/config').ValidatedConfig }} Options */
-/** @typedef {import('types/internal').SSRComponent} SSRComponent */
-
-/** @param {Options} opts */
-function dev(opts) {
-	__fetch_polyfill();
-
-	return new Watcher(opts).init();
-}
-
-class Watcher extends EventEmitter {
-	/** @param {Options} opts */
-	constructor({ cwd = process.cwd(), port, host, https, config }) {
-		super();
-
-		/** @type {string} */
-		this.cwd = cwd;
-
-		/** @type {string} */
-		this.dir = path__default.resolve(cwd, `${SVELTE_KIT}/dev`);
-
-		this.port = port;
-		this.host = host;
-		this.https = https;
-
-		/** @type {import('types/config').ValidatedConfig} */
-		this.config = config;
-
-		/**
-		 * @type {vite.ViteDevServer | undefined}
-		 */
-		this.vite;
-
-		process.on('exit', () => {
-			this.close();
-		});
-	}
-
-	async init() {
-		rimraf(this.dir);
-		copy_assets(this.dir);
-		process.env.VITE_SVELTEKIT_AMP = this.config.kit.amp ? 'true' : '';
-
-		await this.init_filewatcher();
-		this.update();
-
-		await this.init_server();
-
-		return this;
-	}
-
-	async init_filewatcher() {
-		this.cheapwatch = new CheapWatch({
-			dir: this.config.kit.files.routes,
-			/** @type {({ path }: { path: string }) => boolean} */
-			filter: ({ path }) => path.split('/').every((part) => part[0] !== '_' || part[1] === '_')
-		});
-
-		await this.cheapwatch.init();
-
-		// not sure why TS doesn't understand that CheapWatch extends EventEmitter
-		this.cheapwatch.on('+', ({ isNew }) => {
-			if (isNew) this.update();
-		});
-
-		this.cheapwatch.on('-', () => {
-			this.update();
-		});
-	}
-
-	allowed_directories() {
-		return [
-			...new Set([
-				this.config.kit.files.assets,
-				this.config.kit.files.lib,
-				this.config.kit.files.routes,
-				path__default.resolve(this.cwd, 'src'),
-				path__default.resolve(this.cwd, SVELTE_KIT),
-				path__default.resolve(this.cwd, 'node_modules'),
-				path__default.resolve(vite.searchForWorkspaceRoot(this.cwd), 'node_modules')
-			])
-		];
-	}
-
-	async init_server() {
-		if (!this.manifest) throw new Error('Must call init() before init_server()');
-
-		/** @type {import('vite').UserConfig} */
-		const vite_config = (this.config.kit.vite && this.config.kit.vite()) || {};
-
-		const default_config = {
-			server: {
-				fs: {
-					allow: this.allowed_directories()
-				},
-				strictPort: true
-			}
-		};
-
-		// don't warn on overriding defaults
-		const [modified_vite_config] = deep_merge(default_config, vite_config);
-
-		const kit_plugin = await create_plugin(this.config, this.dir, this.https, () => {
-			if (!this.manifest) {
-				throw new Error('Manifest is not available');
-			}
-
-			return this.manifest;
-		});
-
-		/** @type {[any, string[]]} */
-		const [merged_config, conflicts] = deep_merge(modified_vite_config, {
-			configFile: false,
-			root: this.cwd,
-			resolve: {
-				alias: {
-					$app: path__default.resolve(`${this.dir}/runtime/app`),
-					$lib: this.config.kit.files.lib
-				}
-			},
-			build: {
-				rollupOptions: {
-					// Vite dependency crawler needs an explicit JS entry point
-					// eventhough server otherwise works without it
-					input: path__default.resolve(`${this.dir}/runtime/internal/start.js`)
-				}
-			},
-			plugins: [
-				svelte({
-					extensions: this.config.extensions,
-					emitCss: !this.config.kit.amp,
-					compilerOptions: {
-						hydratable: !!this.config.kit.hydrate
-					}
-				}),
-				kit_plugin
-			],
-			publicDir: this.config.kit.files.assets,
-			base: this.config.kit.paths.assets.startsWith('/') ? `${this.config.kit.paths.assets}/` : '/'
-		});
-
-		print_config_conflicts(conflicts, 'kit.vite.');
+/**
+ * @param {import('types/config').ValidatedConfig} config
+ * @param {string} output
+ * @param {string} cwd
+ * @param {import('amphtml-validator').Validator | false} amp
+ * @returns {import('vite').Plugin}
+ */
+function create_plugin(config, output, cwd, amp) {
+	return {
+		name: 'vite-plugin-svelte-kit',
 
-		// optional config from command-line flags
-		// these should take precedence, but not print conflict warnings
-		if (this.host) {
-			merged_config.server.host = this.host;
-		}
-		// https is already enabled then do nothing. it could be an object and we
-		// don't want to overwrite with a boolean
-		if (this.https && !merged_config.server.https) {
-			merged_config.server.https = this.https;
-		}
-		if (this.port) {
-			merged_config.server.port = this.port;
-		}
+		configureServer(vite) {
+			__fetch_polyfill();
 
-		this.vite = await vite.createServer(merged_config);
-		await this.vite.listen(this.port);
-	}
+			/** @type {import('types/app').SSRManifest} */
+			let manifest;
 
-	update() {
-		const manifest_data = create_manifest_data({
-			config: this.config,
-			output: this.dir,
-			cwd: this.cwd
-		});
+			function update_manifest() {
+				const manifest_data = create_manifest_data({ config, output, cwd });
 
-		create_app({
-			manifest_data,
-			output: this.dir,
-			cwd: this.cwd
-		});
+				create_app({ manifest_data, output, cwd });
 
-		/** @type {import('types/app').SSRManifest} */
-		this.manifest = {
-			appDir: this.config.kit.appDir,
-			assets: new Set(manifest_data.assets.map((asset) => asset.file)),
-			_: {
-				mime: get_mime_lookup(manifest_data),
-				entry: {
-					file: `/${SVELTE_KIT}/dev/runtime/internal/start.js`,
-					css: [],
-					js: []
-				},
-				nodes: manifest_data.components.map((id) => {
-					return async () => {
-						const url = `/${id}`;
-
-						if (!this.vite) throw new Error('Vite server has not been initialized');
-
-						const module = /** @type {SSRComponent} */ (await this.vite.ssrLoadModule(url));
-						const node = await this.vite.moduleGraph.getModuleByUrl(url);
-
-						if (!node) throw new Error(`Could not find node for ${url}`);
-
-						const deps = new Set();
-						find_deps(node, deps);
-
-						const styles = new Set();
-
-						for (const dep of deps) {
-							const parsed = new URL(dep.url, 'http://localhost/');
-							const query = parsed.searchParams;
-
-							// TODO what about .scss files, etc?
-							if (
-								dep.file.endsWith('.css') ||
-								(query.has('svelte') && query.get('type') === 'style')
-							) {
-								try {
-									const mod = await this.vite.ssrLoadModule(dep.url);
-									styles.add(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
+				manifest = {
+					appDir: config.kit.appDir,
+					assets: new Set(manifest_data.assets.map((asset) => asset.file)),
+					_: {
+						mime: get_mime_lookup(manifest_data),
+						entry: {
+							file: `/${SVELTE_KIT}/dev/runtime/internal/start.js`,
+							css: [],
+							js: []
+						},
+						nodes: manifest_data.components.map((id) => {
+							return async () => {
+								const url = `/${id}`;
+
+								const module = /** @type {import('types/internal').SSRComponent} */ (
+									await vite.ssrLoadModule(url)
+								);
+								const node = await vite.moduleGraph.getModuleByUrl(url);
+
+								if (!node) throw new Error(`Could not find node for ${url}`);
+
+								const deps = new Set();
+								find_deps(node, deps);
+
+								const styles = new Set();
+
+								for (const dep of deps) {
+									const parsed = new URL(dep.url, 'http://localhost/');
+									const query = parsed.searchParams;
+
+									// TODO what about .scss files, etc?
+									if (
+										dep.file.endsWith('.css') ||
+										(query.has('svelte') && query.get('type') === 'style')
+									) {
+										try {
+											const mod = await vite.ssrLoadModule(dep.url);
+											styles.add(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,
+									entry: url.endsWith('.svelte') ? url : url + '?import',
+									css: [],
+									js: [],
+									styles: Array.from(styles)
+								};
+							};
+						}),
+						routes: manifest_data.routes.map((route) => {
+							if (route.type === 'page') {
+								return {
+									type: 'page',
+									pattern: route.pattern,
+									params: get_params(route.params),
+									a: route.a.map((id) => manifest_data.components.indexOf(id)),
+									b: route.b.map((id) => manifest_data.components.indexOf(id))
+								};
 							}
-						}
 
-						return {
-							module,
-							entry: url.endsWith('.svelte') ? url : url + '?import',
-							css: [],
-							js: [],
-							styles: Array.from(styles)
-						};
-					};
-				}),
-				routes: manifest_data.routes.map((route) => {
-					if (route.type === 'page') {
-						return {
-							type: 'page',
-							pattern: route.pattern,
-							params: get_params(route.params),
-							a: route.a.map((id) => manifest_data.components.indexOf(id)),
-							b: route.b.map((id) => manifest_data.components.indexOf(id))
-						};
+							return {
+								type: 'endpoint',
+								pattern: route.pattern,
+								params: get_params(route.params),
+								load: async () => {
+									const url = path__default.resolve(cwd, route.file);
+									return await vite.ssrLoadModule(url);
+								}
+							};
+						})
 					}
-
-					return {
-						type: 'endpoint',
-						pattern: route.pattern,
-						params: get_params(route.params),
-						load: async () => {
-							if (!this.vite) throw new Error('Vite server has not been initialized');
-							const url = path__default.resolve(this.cwd, route.file);
-							return await this.vite.ssrLoadModule(url);
-						}
-					};
-				})
+				};
 			}
-		};
-	}
-
-	close() {
-		if (!this.vite || !this.cheapwatch) {
-			throw new Error('Cannot close server before it is initialized');
-		}
-
-		if (this.closed) return;
-		this.closed = true;
 
-		this.vite.close();
-		this.cheapwatch.close();
-	}
-}
+			update_manifest();
 
-/** @param {string[]} array */
-function get_params(array) {
-	// given an array of params like `['x', 'y', 'z']` for
-	// src/routes/[x]/[y]/[z]/svelte, create a function
-	// that turns a RegExpExecArray into ({ x, y, z })
+			vite.watcher.on('add', update_manifest);
+			vite.watcher.on('remove', update_manifest);
 
-	/** @param {RegExpExecArray} match */
-	const fn = (match) => {
-		/** @type {Record<string, string>} */
-		const params = {};
-		array.forEach((key, i) => {
-			if (key.startsWith('...')) {
-				params[key.slice(3)] = match[i + 1] || '';
-			} else {
-				params[key] = match[i + 1];
-			}
-		});
-		return params;
-	};
-
-	return fn;
-}
+			return () => {
+				remove_html_middlewares(vite.middlewares);
 
-/**
- * @param {import('types/config').ValidatedConfig} config
- * @param {string} dir
- * @param {boolean} https
- * @param {() => import('types/app').SSRManifest} get_manifest
- */
-async function create_plugin(config, dir, https, get_manifest) {
-	/**
-	 * @type {amp_validator.Validator?}
-	 */
-	const validator = config.kit.amp ? await amphtmlValidator.getInstance() : null;
-
-	/**
-	 * @param {vite.ViteDevServer} vite
-	 */
-	function create_kit_middleware(vite) {
-		/**
-		 * Use a named function for debugging
-		 * @type {import('connect').NextHandleFunction}
-		 */
-		return async function svelteKitMiddleware(req, res) {
-			try {
-				if (!req.url || !req.method) throw new Error('Incomplete request');
-				if (req.url === '/favicon.ico') return not_found(res);
-
-				const parsed = new URL(req.url, 'http://localhost/');
-				if (!parsed.pathname.startsWith(config.kit.paths.base)) return not_found(res);
-
-				/** @type {Partial<import('types/internal').Hooks>} */
-				const user_hooks = resolve_entry(config.kit.files.hooks)
-					? await vite.ssrLoadModule(`/${config.kit.files.hooks}`)
-					: {};
-
-				/** @type {import('types/internal').Hooks} */
-				const hooks = {
-					getSession: user_hooks.getSession || (() => ({})),
-					handle: user_hooks.handle || (({ request, resolve }) => resolve(request)),
-					handleError:
-						user_hooks.handleError ||
-						(({ /** @type {Error & { frame?: string }} */ error }) => {
-							console.error($.bold().red(error.message));
-							if (error.frame) {
-								console.error($.gray(error.frame));
-							}
-							if (error.stack) {
-								console.error($.gray(error.stack));
-							}
-						}),
-					externalFetch: user_hooks.externalFetch || fetch
-				};
+				vite.middlewares.use(async (req, res) => {
+					try {
+						if (!req.url || !req.method) throw new Error('Incomplete request');
+						if (req.url === '/favicon.ico') return not_found(res);
+
+						const parsed = new URL(req.url, 'http://localhost/');
+						if (!parsed.pathname.startsWith(config.kit.paths.base)) return not_found(res);
+
+						/** @type {Partial<import('types/internal').Hooks>} */
+						const user_hooks = resolve_entry(config.kit.files.hooks)
+							? await vite.ssrLoadModule(`/${config.kit.files.hooks}`)
+							: {};
+
+						/** @type {import('types/internal').Hooks} */
+						const hooks = {
+							getSession: user_hooks.getSession || (() => ({})),
+							handle: user_hooks.handle || (({ request, resolve }) => resolve(request)),
+							handleError:
+								user_hooks.handleError ||
+								(({ /** @type {Error & { frame?: string }} */ error }) => {
+									console.error($.bold().red(error.message));
+									if (error.frame) {
+										console.error($.gray(error.frame));
+									}
+									if (error.stack) {
+										console.error($.gray(error.stack));
+									}
+								}),
+							externalFetch: user_hooks.externalFetch || fetch
+						};
 
-				if (/** @type {any} */ (hooks).getContext) {
-					// TODO remove this for 1.0
-					throw new Error(
-						'The getContext hook has been removed. See https://kit.svelte.dev/docs#hooks'
-					);
-				}
+						if (/** @type {any} */ (hooks).getContext) {
+							// TODO remove this for 1.0
+							throw new Error(
+								'The getContext hook has been removed. See https://kit.svelte.dev/docs#hooks'
+							);
+						}
 
-				if (/** @type {any} */ (hooks).serverFetch) {
-					// TODO remove this for 1.0
-					throw new Error('The serverFetch hook has been renamed to externalFetch.');
-				}
+						if (/** @type {any} */ (hooks).serverFetch) {
+							// TODO remove this for 1.0
+							throw new Error('The serverFetch hook has been renamed to externalFetch.');
+						}
 
-				const root = (await vite.ssrLoadModule(`/${dir}/generated/root.svelte`)).default;
+						const root = (await vite.ssrLoadModule(`/${output}/generated/root.svelte`)).default;
 
-				const paths = await vite.ssrLoadModule(`/${SVELTE_KIT}/dev/runtime/paths.js`);
+						const paths = await vite.ssrLoadModule(`/${SVELTE_KIT}/dev/runtime/paths.js`);
 
-				paths.set_paths({
-					base: config.kit.paths.base,
-					assets: config.kit.paths.assets ? SVELTE_KIT_ASSETS : config.kit.paths.base
-				});
+						paths.set_paths({
+							base: config.kit.paths.base,
+							assets: config.kit.paths.assets ? SVELTE_KIT_ASSETS : config.kit.paths.base
+						});
 
-				let body;
+						let body;
 
-				try {
-					body = await getRawBody(req);
-				} catch (/** @type {any} */ err) {
-					res.statusCode = err.status || 400;
-					return res.end(err.reason || 'Invalid request body');
-				}
+						try {
+							body = await getRawBody(req);
+						} catch (/** @type {any} */ err) {
+							res.statusCode = err.status || 400;
+							return res.end(err.reason || 'Invalid request body');
+						}
 
-				const rendered = await respond(
-					{
-						url: new URL(`${https ? 'https' : 'http'}://${req.headers.host}${req.url}`),
-						headers: /** @type {import('types/helper').RequestHeaders} */ (req.headers),
-						method: req.method,
-						rawBody: body
-					},
-					{
-						amp: config.kit.amp,
-						dev: true,
-						floc: config.kit.floc,
-						get_stack: (error) => {
-							vite.ssrFixStacktrace(error);
-							return error.stack;
-						},
-						handle_error: (error, request) => {
-							vite.ssrFixStacktrace(error);
-							hooks.handleError({ error, request });
-						},
-						hooks,
-						hydrate: config.kit.hydrate,
-						manifest: get_manifest(),
-						paths: {
-							base: config.kit.paths.base,
-							assets: config.kit.paths.assets ? SVELTE_KIT_ASSETS : config.kit.paths.base
-						},
-						prefix: '',
-						prerender: config.kit.prerender.enabled,
-						read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
-						root,
-						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')
-								.replace('%svelte.head%', () => head)
-								.replace('%svelte.body%', () => body);
-
-							if (config.kit.amp && validator) {
-								const result = validator.validateString(rendered);
-
-								if (result.status !== 'PASS') {
-									const lines = rendered.split('\n');
-
-									/** @param {string} str */
-									const escape = (str) =>
-										str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-									rendered = `<!doctype html>
+						const rendered = await respond(
+							{
+								url: new URL(
+									`${vite.config.server.https ? 'https' : 'http'}://${req.headers.host}${req.url}`
+								),
+								headers: /** @type {import('types/helper').RequestHeaders} */ (req.headers),
+								method: req.method,
+								rawBody: body
+							},
+							{
+								amp: config.kit.amp,
+								dev: true,
+								floc: config.kit.floc,
+								get_stack: (error) => {
+									vite.ssrFixStacktrace(error);
+									return error.stack;
+								},
+								handle_error: (error, request) => {
+									vite.ssrFixStacktrace(error);
+									hooks.handleError({ error, request });
+								},
+								hooks,
+								hydrate: config.kit.hydrate,
+								manifest,
+								paths: {
+									base: config.kit.paths.base,
+									assets: config.kit.paths.assets ? SVELTE_KIT_ASSETS : config.kit.paths.base
+								},
+								prefix: '',
+								prerender: config.kit.prerender.enabled,
+								read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
+								root,
+								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')
+										.replace('%svelte.head%', () => head)
+										.replace('%svelte.body%', () => body);
+
+									if (amp) {
+										const result = amp.validateString(rendered);
+
+										if (result.status !== 'PASS') {
+											const lines = rendered.split('\n');
+
+											/** @param {string} str */
+											const escape = (str) =>
+												str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+											rendered = `<!doctype html>
 										<head>
 											<meta charset="utf-8" />
 											<meta name="viewport" content="width=device-width, initial-scale=1" />
@@ -4654,45 +4453,57 @@ async function create_plugin(config, dir, https, get_manifest) {
 											)
 											.join('\n\n')}
 									`;
-								}
-							}
+										}
+									}
 
-							return rendered;
-						},
-						trailing_slash: config.kit.trailingSlash
+									return rendered;
+								},
+								trailing_slash: config.kit.trailingSlash
+							}
+						);
+
+						if (rendered) {
+							res.writeHead(rendered.status, rendered.headers);
+							if (rendered.body) res.write(rendered.body);
+							res.end();
+						} else {
+							not_found(res);
+						}
+					} catch (e) {
+						const error = coalesce_to_error(e);
+						vite.ssrFixStacktrace(error);
+						res.statusCode = 500;
+						res.end(error.stack);
 					}
-				);
-
-				if (rendered) {
-					res.writeHead(rendered.status, rendered.headers);
-					if (rendered.body) res.write(rendered.body);
-					res.end();
-				} else {
-					not_found(res);
-				}
-			} catch (e) {
-				const error = coalesce_to_error(e);
-				vite.ssrFixStacktrace(error);
-				res.statusCode = 500;
-				res.end(error.stack);
-			}
-		};
-	}
-
-	return {
-		name: 'vite-plugin-svelte-kit',
-		/**
-		 * @param {import('vite').ViteDevServer} vite
-		 */
-		configureServer(vite) {
-			return () => {
-				remove_html_middlewares(vite.middlewares);
-				vite.middlewares.use(create_kit_middleware(vite));
+				});
 			};
 		}
 	};
 }
 
+/** @param {string[]} array */
+function get_params(array) {
+	// given an array of params like `['x', 'y', 'z']` for
+	// src/routes/[x]/[y]/[z]/svelte, create a function
+	// that turns a RegExpExecArray into ({ x, y, z })
+
+	/** @param {RegExpExecArray} match */
+	const fn = (match) => {
+		/** @type {Record<string, string>} */
+		const params = {};
+		array.forEach((key, i) => {
+			if (key.startsWith('...')) {
+				params[key.slice(3)] = match[i + 1] || '';
+			} else {
+				params[key] = match[i + 1];
+			}
+		});
+		return params;
+	};
+
+	return fn;
+}
+
 /** @param {import('http').ServerResponse} res */
 function not_found(res) {
 	res.statusCode = 404;
@@ -4729,4 +4540,100 @@ function find_deps(node, deps) {
 	}
 }
 
+/** @typedef {{
+ *   cwd: string,
+ *   port: number,
+ *   host?: string,
+ *   https: boolean,
+ *   config: import('types/config').ValidatedConfig
+ * }} Options */
+/** @typedef {import('types/internal').SSRComponent} SSRComponent */
+
+/** @param {Options} opts */
+async function dev({ cwd, port, host, https, config }) {
+	const output = path__default.resolve(cwd, `${SVELTE_KIT}/dev`);
+
+	rimraf(output);
+	copy_assets(output);
+
+	process.env.VITE_SVELTEKIT_AMP = config.kit.amp ? 'true' : '';
+
+	const [vite_config] = deep_merge(
+		{
+			server: {
+				fs: {
+					allow: [
+						...new Set([
+							config.kit.files.assets,
+							config.kit.files.lib,
+							config.kit.files.routes,
+							path__default.resolve(cwd, 'src'),
+							path__default.resolve(cwd, SVELTE_KIT),
+							path__default.resolve(cwd, 'node_modules'),
+							path__default.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
+						])
+					]
+				},
+				strictPort: true
+			}
+		},
+		config.kit.vite()
+	);
+
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(vite_config, {
+		configFile: false,
+		root: cwd,
+		resolve: {
+			alias: {
+				$app: path__default.resolve(`${output}/runtime/app`),
+				$lib: config.kit.files.lib
+			}
+		},
+		plugins: [
+			svelte({
+				extensions: config.extensions,
+				emitCss: !config.kit.amp,
+				compilerOptions: {
+					hydratable: !!config.kit.hydrate
+				}
+			}),
+			create_plugin(config, output, cwd, config.kit.amp && (await amphtmlValidator.getInstance()))
+		],
+		publicDir: config.kit.files.assets,
+		base: '/'
+	});
+
+	print_config_conflicts(conflicts, 'kit.vite.');
+
+	// optional config from command-line flags
+	// these should take precedence, but not print conflict warnings
+	if (host) {
+		merged_config.server.host = host;
+	}
+
+	// if https is already enabled then do nothing. it could be an object and we
+	// don't want to overwrite with a boolean
+	if (https && !merged_config.server.https) {
+		merged_config.server.https = https;
+	}
+
+	if (port) {
+		merged_config.server.port = port;
+	}
+
+	const server = await vite.createServer(merged_config);
+	await server.listen(port);
+
+	const address_info = /** @type {import('net').AddressInfo} */ (
+		/** @type {import('http').Server} */ (server.httpServer).address()
+	);
+
+	return {
+		address_info,
+		server_config: vite_config.server,
+		close: () => server.close()
+	};
+}
+
 export { dev };

package/dist/chunks/index3.js

@@ -1,6 +1,6 @@
 import fs__default, { writeFileSync } from 'fs';
 import path__default from 'path';
-import { p as print_config_conflicts, c as copy_assets, b as posixify, a as resolve_entry, r as rimraf, m as mkdirp } from '../cli.js';
+import { p as print_config_conflicts, c as copy_assets, b as posixify, r as resolve_entry, a as rimraf, m as mkdirp } 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';

package/dist/chunks/index5.js

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

package/dist/chunks/index7.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { createRequire } from 'module';
-import { r as rimraf, w as walk$1, $, m as mkdirp } from '../cli.js';
+import { a as rimraf, w as walk$1, $, m as mkdirp } from '../cli.js';
 import 'sade';
 import 'child_process';
 import 'net';

package/dist/cli.js

@@ -887,7 +887,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.210');
+const prog = sade('svelte-kit').version('1.0.0-next.211');
 
 prog
 	.command('dev')
@@ -903,37 +903,24 @@ prog
 		const { dev } = await import('./chunks/index.js');
 
 		try {
-			const watcher = await dev({ port, host, https, config });
+			const cwd = process.cwd();
 
-			watcher.on('stdout', (data) => {
-				process.stdout.write(data);
-			});
-
-			watcher.on('stderr', (data) => {
-				process.stderr.write(data);
+			const { address_info, server_config } = await dev({
+				cwd,
+				port,
+				host,
+				https,
+				config
 			});
 
-			if (!watcher.vite || !watcher.vite.httpServer) {
-				throw Error('Could not find server');
-			}
-			// we never start the server on a socket path, so address will be of type AddressInfo
-			const address_info = /** @type {import('net').AddressInfo} */ (
-				watcher.vite.httpServer.address()
-			);
-
-			const vite_config = config.kit.vite();
-
-			https = https || !!vite_config.server?.https;
-			open = open || !!vite_config.server?.open;
-
 			welcome({
 				port: address_info.port,
 				host: address_info.address,
-				https,
-				open,
-				loose: vite_config.server?.fs?.strict === false,
-				allow: watcher.allowed_directories(),
-				cwd: watcher.cwd
+				https: !!(https || server_config.https),
+				open: open || !!server_config.open,
+				loose: server_config.fs.strict === false,
+				allow: server_config.fs.allow,
+				cwd
 			});
 		} catch (error) {
 			handle_error(error);
@@ -1052,7 +1039,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.210'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.211'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';
@@ -1089,4 +1076,4 @@ function welcome({ port, host, https, open, loose, allow, cwd }) {
 	console.log('\n');
 }
 
-export { $, resolve_entry 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, rimraf as r, walk as w };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.210",
+  "version": "1.0.0-next.211",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -11,7 +11,6 @@
   "type": "module",
   "dependencies": {
     "@sveltejs/vite-plugin-svelte": "^1.0.0-next.32",
-    "cheap-watch": "^1.0.4",
     "sade": "^1.7.4",
     "vite": "^2.7.2"
   },