@sveltejs/kit 1.0.0-next.344 → 1.0.0-next.347

package/dist/chunks/index.js

@@ -1,546 +1,1360 @@
-import path__default from 'path';
-import { svelte } from '@sveltejs/vite-plugin-svelte';
+import fs__default, { readFileSync, writeFileSync } from 'fs';
+import path__default, { join, dirname } from 'path';
+import { p as posixify, m as mkdirp, r as rimraf } from './filesystem.js';
+import { all } from './sync.js';
+import { g as get_aliases, p as print_config_conflicts, r as resolve_entry, a as get_runtime_path, l as load_template } from '../cli.js';
+import { g as generate_manifest } from './index2.js';
 import * as vite from 'vite';
+import { s } from './misc.js';
 import { d as deep_merge } from './object.js';
-import { g as get_runtime_path, r as resolve_entry, $, l as load_template, c as coalesce_to_error, a as get_mime_lookup, b as load_config, d as get_aliases, p as print_config_conflicts } from '../cli.js';
-import fs__default from 'fs';
-import { URL } from 'url';
-import { S as SVELTE_KIT_ASSETS, s as sirv } from './constants.js';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import { pathToFileURL, URL as URL$1 } from 'url';
 import { installPolyfills } from '../node/polyfills.js';
-import { init, update } from './sync.js';
-import { getRequest, setResponse } from '../node.js';
-import { p as posixify } from './filesystem.js';
-import { p as parse_route_id } from './misc.js';
-import 'sade';
-import 'child_process';
-import 'net';
+import './write_tsconfig.js';
 import 'chokidar';
+import 'net';
+import 'child_process';
+import 'sade';
 import 'os';
-import 'querystring';
 import 'node:http';
 import 'node:https';
 import 'node:zlib';
 import 'node:stream';
+import 'node:buffer';
 import 'node:util';
 import 'node:url';
+import 'node:net';
+import 'node:fs';
+import 'node:path';
 import 'crypto';
-import './write_tsconfig.js';
-import 'stream';
 
-// Vite doesn't expose this so we just copy the list for now
-// https://github.com/vitejs/vite/blob/3edd1af56e980aef56641a5a51cf2932bb580d41/packages/vite/src/node/plugins/css.ts#L96
-const style_pattern = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)$/;
+const absolute = /^([a-z]+:)?\/?\//;
+const scheme = /^[a-z]+:/;
+
+/**
+ * @param {string} base
+ * @param {string} path
+ */
+function resolve(base, path) {
+	if (scheme.test(path)) return path;
 
-const cwd$1 = process.cwd();
+	const base_match = absolute.exec(base);
+	const path_match = absolute.exec(path);
+
+	if (!base_match) {
+		throw new Error(`bad base path: "${base}"`);
+	}
+
+	const baseparts = path_match ? [] : base.slice(base_match[0].length).split('/');
+	const pathparts = path_match ? path.slice(path_match[0].length).split('/') : path.split('/');
+
+	baseparts.pop();
+
+	for (let i = 0; i < pathparts.length; i += 1) {
+		const part = pathparts[i];
+		if (part === '.') continue;
+		else if (part === '..') baseparts.pop();
+		else baseparts.push(part);
+	}
+
+	const prefix = (path_match && path_match[0]) || (base_match && base_match[0]) || '';
+
+	return `${prefix}${baseparts.join('/')}`;
+}
+
+/** @param {string} path */
+function is_root_relative(path) {
+	return path[0] === '/' && path[1] !== '/';
+}
 
 /**
- * @param {import('types').ValidatedConfig} config
- * @returns {Promise<import('vite').Plugin>}
+ * @param {string} path
+ * @param {import('types').TrailingSlash} trailing_slash
  */
-async function create_plugin(config) {
+function normalize_path(path, trailing_slash) {
+	if (path === '/' || trailing_slash === 'ignore') return path;
+
+	if (trailing_slash === 'never') {
+		return path.endsWith('/') ? path.slice(0, -1) : path;
+	} else if (trailing_slash === 'always' && !path.endsWith('/')) {
+		return path + '/';
+	}
+
+	return path;
+}
+
+/**
+ * @typedef {import('rollup').RollupOutput} RollupOutput
+ * @typedef {import('rollup').OutputChunk} OutputChunk
+ * @typedef {import('rollup').OutputAsset} OutputAsset
+ */
+
+/** @param {import('vite').UserConfig} config */
+async function create_build(config) {
+	const { output } = /** @type {RollupOutput} */ (await vite.build(config));
+
+	const chunks = output.filter(
+		/** @returns {output is OutputChunk} */ (output) => output.type === 'chunk'
+	);
+
+	const assets = output.filter(
+		/** @returns {output is OutputAsset} */ (output) => output.type === 'asset'
+	);
+
+	return { chunks, assets };
+}
+
+/**
+ * @param {string} file
+ * @param {import('vite').Manifest} manifest
+ * @param {Set<string>} css
+ * @param {Set<string>} js
+ */
+function find_deps(file, manifest, js, css) {
+	const chunk = manifest[file];
+
+	if (js.has(chunk.file)) return;
+	js.add(chunk.file);
+
+	if (chunk.css) {
+		chunk.css.forEach((file) => css.add(file));
+	}
+
+	if (chunk.imports) {
+		chunk.imports.forEach((file) => find_deps(file, manifest, js, css));
+	}
+}
+
+/**
+ * @param {{
+ *   client_out_dir?: string;
+ *   config: import('types').ValidatedConfig;
+ *   input: Record<string, string>;
+ *   output_dir: string;
+ *   ssr: boolean;
+ * }} options
+ * @return {import('vite').UserConfig}
+ */
+const get_default_config = function ({ client_out_dir, config, input, output_dir, ssr }) {
 	return {
-		name: 'vite-plugin-svelte-kit',
-
-		async configureServer(vite) {
-			installPolyfills();
-
-			init(config);
-
-			const runtime = get_runtime_path(config);
-
-			process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = '0';
-
-			/** @type {import('types').Respond} */
-			const respond = (await import(`${runtime}/server/index.js`)).respond;
-
-			/** @type {import('types').SSRManifest} */
-			let manifest;
-
-			function update_manifest() {
-				const { manifest_data } = update(config);
-
-				manifest = {
-					appDir: config.kit.appDir,
-					assets: new Set(manifest_data.assets.map((asset) => asset.file)),
-					mimeTypes: get_mime_lookup(manifest_data),
-					_: {
-						entry: {
-							file: `/@fs${runtime}/client/start.js`,
-							css: [],
-							js: []
-						},
-						nodes: manifest_data.components.map((id) => {
-							return async () => {
-								const url = id.startsWith('..') ? `/@fs${path__default.posix.resolve(id)}` : `/${id}`;
-
-								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(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
-										}
-									}
-								}
+		base: assets_base(config),
+		build: {
+			cssCodeSplit: true,
+			manifest: true,
+			outDir: ssr ? `${output_dir}/server` : `${client_out_dir}/immutable`,
+			polyfillDynamicImport: false,
+			rollupOptions: {
+				input,
+				output: {
+					format: 'esm',
+					entryFileNames: ssr ? '[name].js' : '[name]-[hash].js',
+					chunkFileNames: 'chunks/[name]-[hash].js',
+					assetFileNames: 'assets/[name]-[hash][extname]'
+				},
+				preserveEntrySignatures: 'strict'
+			},
+			ssr
+		},
+		plugins: [
+			svelte({
+				...config,
+				compilerOptions: {
+					...config.compilerOptions,
+					hydratable: !!config.kit.browser.hydrate
+				},
+				configFile: false
+			})
+		],
+		// prevent Vite copying the contents of `config.kit.files.assets`,
+		// if it happens to be 'public' instead of 'static'
+		publicDir: false,
+		resolve: {
+			alias: get_aliases(config)
+		}
+	};
+};
 
-								return {
-									module,
-									entry: url.endsWith('.svelte') ? url : url + '?import',
-									css: [],
-									js: [],
-									// in dev we inline all styles to avoid FOUC
-									styles
-								};
-							};
-						}),
-						routes: manifest_data.routes.map((route) => {
-							const { pattern, names, types } = parse_route_id(route.id);
-
-							if (route.type === 'page') {
-								return {
-									type: 'page',
-									id: route.id,
-									pattern,
-									names,
-									types,
-									shadow: route.shadow
-										? async () => {
-												const url = path__default.resolve(cwd$1, /** @type {string} */ (route.shadow));
-												return await vite.ssrLoadModule(url, { fixStacktrace: false });
-										  }
-										: null,
-									a: route.a.map((id) => (id ? manifest_data.components.indexOf(id) : undefined)),
-									b: route.b.map((id) => (id ? manifest_data.components.indexOf(id) : undefined))
-								};
-							}
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @returns {string}
+ */
+function assets_base(config) {
+	// TODO this is so that Vite's preloading works. Unfortunately, it fails
+	// during `svelte-kit preview`, because we use a local asset path. This
+	// may be fixed in Vite 3: https://github.com/vitejs/vite/issues/2009
+	const { base, assets } = config.kit.paths;
+	return `${assets || base}/${config.kit.appDir}/immutable/`;
+}
 
-							return {
-								type: 'endpoint',
-								id: route.id,
-								pattern,
-								names,
-								types,
-								load: async () => {
-									const url = path__default.resolve(cwd$1, route.file);
-									return await vite.ssrLoadModule(url, { fixStacktrace: false });
-								}
-							};
-						}),
-						matchers: async () => {
-							/** @type {Record<string, import('types').ParamMatcher>} */
-							const matchers = {};
-
-							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 });
-
-								if (module.match) {
-									matchers[key] = module.match;
-								} else {
-									throw new Error(`${file} does not export a \`match\` function`);
-								}
-							}
+/**
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   manifest_data: import('types').ManifestData;
+ *   output_dir: string;
+ *   service_worker_entry_file: string | null;
+ * }} options
+ * @param {import('types').Prerendered} prerendered
+ * @param {import('vite').Manifest} client_manifest
+ */
+async function build_service_worker(
+	{ config, manifest_data, output_dir, service_worker_entry_file },
+	prerendered,
+	client_manifest
+) {
+	const build = new Set();
+	for (const key in client_manifest) {
+		const { file, css = [], assets = [] } = client_manifest[key];
+		build.add(file);
+		css.forEach((file) => build.add(file));
+		assets.forEach((file) => build.add(file));
+	}
 
-							return matchers;
-						}
+	const service_worker = `${config.kit.outDir}/generated/service-worker.js`;
+
+	fs__default.writeFileSync(
+		service_worker,
+		`
+			// TODO remove for 1.0
+			export const timestamp = {
+				toString: () => {
+					throw new Error('\`timestamp\` has been removed from $service-worker. Use \`version\` instead');
+				}
+			};
+
+			export const build = [
+				${Array.from(build)
+					.map((file) => `${s(`${config.kit.paths.base}/${config.kit.appDir}/immutable/${file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
+
+			export const files = [
+				${manifest_data.assets
+					.filter((asset) => config.kit.serviceWorker.files(asset.file))
+					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
+
+			export const prerendered = [
+				${prerendered.paths
+					.map((path) => s(normalize_path(path, config.kit.trailingSlash)))
+					.join(',\n\t\t\t\t')}
+			];
+
+			export const version = ${s(config.kit.version.name)};
+		`
+			.replace(/^\t{3}/gm, '')
+			.trim()
+	);
+
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(await config.kit.vite(), {
+		base: assets_base(config),
+		build: {
+			lib: {
+				entry: service_worker_entry_file,
+				name: 'app',
+				formats: ['es']
+			},
+			rollupOptions: {
+				output: {
+					entryFileNames: 'service-worker.js'
+				}
+			},
+			outDir: `${output_dir}/client`,
+			emptyOutDir: false
+		},
+		resolve: {
+			alias: {
+				'$service-worker': service_worker,
+				$lib: config.kit.files.lib
+			}
+		}
+	});
+
+	print_config_conflicts(conflicts, 'kit.vite.', 'build_service_worker');
+
+	await vite.build(merged_config);
+}
+
+/**
+ * @param {{
+ *   cwd: string;
+ *   config: import('types').ValidatedConfig;
+ *   manifest_data: import('types').ManifestData;
+ *   output_dir: string;
+ *   client_entry_file: string;
+ * }} options
+ */
+async function build_client(options) {
+	const { cwd, config, manifest_data, output_dir, client_entry_file } = options;
+
+	process.env.VITE_SVELTEKIT_APP_VERSION = config.kit.version.name;
+	process.env.VITE_SVELTEKIT_APP_VERSION_FILE = `${config.kit.appDir}/version.json`;
+	process.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL = `${config.kit.version.pollInterval}`;
+
+	const client_out_dir = `${output_dir}/client/${config.kit.appDir}`;
+
+	/** @type {Record<string, string>} */
+	const input = {
+		start: path__default.resolve(cwd, client_entry_file)
+	};
+
+	// This step is optional — Vite/Rollup will create the necessary chunks
+	// for everything regardless — but it means that entry chunks reflect
+	// their location in the source code, which is helpful for debugging
+	manifest_data.components.forEach((file) => {
+		const resolved = path__default.resolve(cwd, file);
+		const relative = path__default.relative(config.kit.files.routes, resolved);
+
+		const name = relative.startsWith('..')
+			? path__default.basename(file)
+			: posixify(path__default.join('pages', relative));
+		input[name] = resolved;
+	});
+
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(
+		await config.kit.vite(),
+		get_default_config({ ...options, client_out_dir, input, ssr: false })
+	);
+
+	print_config_conflicts(conflicts, 'kit.vite.', 'build_client');
+
+	const { chunks, assets } = await create_build(merged_config);
+
+	/** @type {import('vite').Manifest} */
+	const vite_manifest = JSON.parse(
+		fs__default.readFileSync(`${client_out_dir}/immutable/manifest.json`, 'utf-8')
+	);
+
+	const entry = posixify(client_entry_file);
+	const entry_js = new Set();
+	const entry_css = new Set();
+	find_deps(entry, vite_manifest, entry_js, entry_css);
+
+	fs__default.writeFileSync(
+		`${client_out_dir}/version.json`,
+		JSON.stringify({ version: process.env.VITE_SVELTEKIT_APP_VERSION })
+	);
+
+	return {
+		assets,
+		chunks,
+		entry: {
+			file: vite_manifest[entry].file,
+			js: Array.from(entry_js),
+			css: Array.from(entry_css)
+		},
+		vite_manifest
+	};
+}
+
+/**
+ * @param {{
+ *   hooks: string;
+ *   config: import('types').ValidatedConfig;
+ *   has_service_worker: boolean;
+ *   runtime: string;
+ *   template: string;
+ * }} opts
+ */
+const server_template = ({ config, hooks, has_service_worker, runtime, template }) => `
+import root from '__GENERATED__/root.svelte';
+import { respond } from '${runtime}/server/index.js';
+import { set_paths, assets, base } from '${runtime}/paths.js';
+import { set_prerendering } from '${runtime}/env.js';
+
+const template = ({ head, body, assets, nonce }) => ${s(template)
+	.replace('%sveltekit.head%', '" + head + "')
+	.replace('%sveltekit.body%', '" + body + "')
+	.replace(/%sveltekit\.assets%/g, '" + assets + "')
+	.replace(/%sveltekit\.nonce%/g, '" + nonce + "')};
+
+let read = null;
+
+set_paths(${s(config.kit.paths)});
+
+let default_protocol = 'https';
+
+// allow paths to be globally overridden
+// in svelte-kit preview and in prerendering
+export function override(settings) {
+	default_protocol = settings.protocol || default_protocol;
+	set_paths(settings.paths);
+	set_prerendering(settings.prerendering);
+	read = settings.read;
+}
+
+export class Server {
+	constructor(manifest) {
+		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({
+					error,
+					event,
+
+					// TODO remove for 1.0
+					// @ts-expect-error
+					get request() {
+						throw new Error('request in handleError has been replaced with event. See https://github.com/sveltejs/kit/pull/3384 for details');
 					}
-				};
+				});
+				error.stack = this.options.get_stack(error);
+			},
+			hooks: null,
+			hydrate: ${s(config.kit.browser.hydrate)},
+			manifest,
+			method_override: ${s(config.kit.methodOverride)},
+			paths: { base, assets },
+			prefix: assets + '/${config.kit.appDir}/immutable/',
+			prerender: {
+				default: ${config.kit.prerender.default},
+				enabled: ${config.kit.prerender.enabled}
+			},
+			read,
+			root,
+			service_worker: ${has_service_worker ? "base + '/service-worker.js'" : 'null'},
+			router: ${s(config.kit.browser.router)},
+			template,
+			template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
+			trailing_slash: ${s(config.kit.trailingSlash)}
+		};
+	}
+
+	async respond(request, options = {}) {
+		if (!(request instanceof Request)) {
+			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
+		}
+
+		if (!this.options.hooks) {
+			const module = await import(${s(hooks)});
+			this.options.hooks = {
+				getSession: module.getSession || (() => ({})),
+				handle: module.handle || (({ event, resolve }) => resolve(event)),
+				handleError: module.handleError || (({ error }) => console.error(error.stack)),
+				externalFetch: module.externalFetch || fetch
+			};
+		}
+
+		return respond(request, this.options, options);
+	}
+}
+`;
+
+/**
+ * @param {{
+ *   cwd: string;
+ *   config: import('types').ValidatedConfig
+ *   manifest_data: import('types').ManifestData
+ *   build_dir: string;
+ *   output_dir: string;
+ *   service_worker_entry_file: string | null;
+ * }} options
+ * @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;
+
+	let hooks_file = resolve_entry(config.kit.files.hooks);
+	if (!hooks_file || !fs__default.existsSync(hooks_file)) {
+		hooks_file = path__default.join(config.kit.outDir, 'build/hooks.js');
+		fs__default.writeFileSync(hooks_file, '');
+	}
+
+	/** @type {Record<string, string>} */
+	const input = {
+		index: `${build_dir}/index.js`
+	};
+
+	// add entry points for every endpoint...
+	manifest_data.routes.forEach((route) => {
+		const file = route.type === 'endpoint' ? route.file : route.shadow;
+
+		if (file) {
+			const resolved = path__default.resolve(cwd, file);
+			const relative = path__default.relative(config.kit.files.routes, resolved);
+			const name = posixify(path__default.join('entries/endpoints', relative.replace(/\.js$/, '')));
+			input[name] = resolved;
+		}
+	});
+
+	// ...and every component used by pages...
+	manifest_data.components.forEach((file) => {
+		const resolved = path__default.resolve(cwd, file);
+		const relative = path__default.relative(config.kit.files.routes, resolved);
+
+		const name = relative.startsWith('..')
+			? posixify(path__default.join('entries/fallbacks', path__default.basename(file)))
+			: posixify(path__default.join('entries/pages', relative));
+		input[name] = resolved;
+	});
+
+	// ...and every matcher
+	Object.entries(manifest_data.matchers).forEach(([key, file]) => {
+		const name = posixify(path__default.join('entries/matchers', key));
+		input[name] = path__default.resolve(cwd, file);
+	});
+
+	/** @type {(file: string) => string} */
+	const app_relative = (file) => {
+		const relative_file = path__default.relative(build_dir, path__default.resolve(cwd, file));
+		return relative_file[0] === '.' ? relative_file : `./${relative_file}`;
+	};
+
+	fs__default.writeFileSync(
+		input.index,
+		server_template({
+			config,
+			hooks: app_relative(hooks_file),
+			has_service_worker: config.kit.serviceWorker.register && !!service_worker_entry_file,
+			runtime: get_runtime_path(config),
+			template: load_template(cwd, config)
+		})
+	);
+
+	/** @type {import('vite').UserConfig} */
+	const vite_config = await config.kit.vite();
+
+	const default_config = {
+		build: {
+			target: 'node14.8'
+		},
+		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
+			// them as peerDependencies
+			noExternal: []
+				
+		}
+	};
+
+	// don't warn on overriding defaults
+	const [modified_vite_config] = deep_merge(default_config, vite_config);
+
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(
+		modified_vite_config,
+		get_default_config({ ...options, input, ssr: true })
+	);
+
+	print_config_conflicts(conflicts, 'kit.vite.', 'build_server');
+
+	process.env.VITE_SVELTEKIT_ADAPTER_NAME = config.kit.adapter?.name;
+
+	const { chunks } = await create_build(merged_config);
+
+	/** @type {import('vite').Manifest} */
+	const vite_manifest = JSON.parse(fs__default.readFileSync(`${output_dir}/server/manifest.json`, 'utf-8'));
+
+	mkdirp(`${output_dir}/server/nodes`);
+	mkdirp(`${output_dir}/server/stylesheets`);
+
+	const stylesheet_lookup = new Map();
+
+	client.assets.forEach((asset) => {
+		if (asset.fileName.endsWith('.css')) {
+			if (asset.source.length < config.kit.inlineStyleThreshold) {
+				const index = stylesheet_lookup.size;
+				const file = `${output_dir}/server/stylesheets/${index}.js`;
+
+				fs__default.writeFileSync(file, `// ${asset.fileName}\nexport default ${s(asset.source)};`);
+				stylesheet_lookup.set(asset.fileName, index);
 			}
+		}
+	});
+
+	manifest_data.components.forEach((component, i) => {
+		const file = `${output_dir}/server/nodes/${i}.js`;
+
+		const js = new Set();
+		const css = new Set();
+		find_deps(component, client.vite_manifest, js, css);
+
+		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))};`
+		];
+
+		/** @type {string[]} */
+		const styles = [];
 
-			/** @param {Error} error */
-			function fix_stack_trace(error) {
-				return error.stack ? vite.ssrRewriteStacktrace(error.stack) : error.stack;
+		css.forEach((file) => {
+			if (stylesheet_lookup.has(file)) {
+				const index = stylesheet_lookup.get(file);
+				const name = `stylesheet_${index}`;
+				imports.push(`import ${name} from '../stylesheets/${index}.js';`);
+				styles.push(`\t${s(file)}: ${name}`);
 			}
+		});
 
-			update_manifest();
+		if (styles.length > 0) {
+			exports.push(`export const styles = {\n${styles.join(',\n')}\n};`);
+		}
+
+		fs__default.writeFileSync(file, `${imports.join('\n')}\n\n${exports.join('\n')}\n`);
+	});
+
+	return {
+		chunks,
+		vite_manifest,
+		methods: get_methods(cwd, chunks, manifest_data)
+	};
+}
+
+/** @type {Record<string, string>} */
+const method_names = {
+	get: 'get',
+	head: 'head',
+	post: 'post',
+	put: 'put',
+	del: 'delete',
+	patch: 'patch'
+};
+
+/**
+ * @param {string} cwd
+ * @param {import('rollup').OutputChunk[]} output
+ * @param {import('types').ManifestData} manifest_data
+ */
+function get_methods(cwd, output, manifest_data) {
+	/** @type {Record<string, string[]>} */
+	const lookup = {};
+	output.forEach((chunk) => {
+		if (!chunk.facadeModuleId) return;
+		const id = chunk.facadeModuleId.slice(cwd.length + 1);
+		lookup[id] = chunk.exports;
+	});
 
-			vite.watcher.on('add', update_manifest);
-			vite.watcher.on('unlink', update_manifest);
+	/** @type {Record<string, import('types').HttpMethod[]>} */
+	const methods = {};
+	manifest_data.routes.forEach((route) => {
+		const file = route.type === 'endpoint' ? route.file : route.shadow;
 
-			const assets = config.kit.paths.assets ? SVELTE_KIT_ASSETS : config.kit.paths.base;
-			const asset_server = sirv(config.kit.files.assets, {
-				dev: true,
-				etag: true,
-				maxAge: 0,
-				extensions: []
+		if (file && lookup[file]) {
+			methods[file] = lookup[file]
+				.map((x) => /** @type {import('types').HttpMethod} */ (method_names[x]))
+				.filter(Boolean);
+		}
+	});
+
+	return methods;
+}
+
+/** @typedef {{
+ *   fn: () => Promise<any>,
+ *   fulfil: (value: any) => void,
+ *   reject: (error: Error) => void
+ * }} Task */
+
+/** @param {number} concurrency */
+function queue(concurrency) {
+	/** @type {Task[]} */
+	const tasks = [];
+
+	let current = 0;
+
+	/** @type {(value?: any) => void} */
+	let fulfil;
+
+	/** @type {(error: Error) => void} */
+	let reject;
+
+	let closed = false;
+
+	const done = new Promise((f, r) => {
+		fulfil = f;
+		reject = r;
+	});
+
+	done.catch(() => {
+		// this is necessary in case a catch handler is never added
+		// to the done promise by the user
+	});
+
+	function dequeue() {
+		if (current < concurrency) {
+			const task = tasks.shift();
+
+			if (task) {
+				current += 1;
+				const promise = Promise.resolve(task.fn());
+
+				promise
+					.then(task.fulfil, (err) => {
+						task.reject(err);
+						reject(err);
+					})
+					.then(() => {
+						current -= 1;
+						dequeue();
+					});
+			} else if (current === 0) {
+				closed = true;
+				fulfil();
+			}
+		}
+	}
+
+	return {
+		/** @param {() => any} fn */
+		add: (fn) => {
+			if (closed) throw new Error('Cannot add tasks to a queue that has ended');
+
+			const promise = new Promise((fulfil, reject) => {
+				tasks.push({ fn, fulfil, reject });
 			});
 
-			return () => {
-				const serve_static_middleware = vite.middlewares.stack.find(
-					(middleware) =>
-						/** @type {function} */ (middleware.handle).name === 'viteServeStaticMiddleware'
-				);
+			dequeue();
+			return promise;
+		},
 
-				remove_html_middlewares(vite.middlewares);
+		done: () => {
+			if (current === 0) {
+				closed = true;
+				fulfil();
+			}
 
-				vite.middlewares.use(async (req, res) => {
-					try {
-						if (!req.url || !req.method) throw new Error('Incomplete request');
+			return done;
+		}
+	};
+}
 
-						const base = `${vite.config.server.https ? 'https' : 'http'}://${
-							req.headers[':authority'] || req.headers.host
-						}`;
+const DOCTYPE = 'DOCTYPE';
+const CDATA_OPEN = '[CDATA[';
+const CDATA_CLOSE = ']]>';
+const COMMENT_OPEN = '--';
+const COMMENT_CLOSE = '-->';
 
-						const decoded = decodeURI(new URL(base + req.url).pathname);
+const TAG_OPEN = /[a-zA-Z]/;
+const TAG_CHAR = /[a-zA-Z0-9]/;
+const ATTRIBUTE_NAME = /[^\t\n\f />"'=]/;
 
-						if (decoded.startsWith(assets)) {
-							const pathname = decoded.slice(assets.length);
-							const file = config.kit.files.assets + pathname;
+const WHITESPACE = /[\s\n\r]/;
 
-							if (fs__default.existsSync(file) && !fs__default.statSync(file).isDirectory()) {
-								const has_correct_case = fs__default.realpathSync.native(file) === path__default.resolve(file);
+/** @param {string} html */
+function crawl(html) {
+	/** @type {string[]} */
+	const hrefs = [];
 
-								if (has_correct_case) {
-									req.url = encodeURI(pathname); // don't need query/hash
-									asset_server(req, res);
-									return;
-								}
-							}
+	let i = 0;
+	main: while (i < html.length) {
+		const char = html[i];
+
+		if (char === '<') {
+			if (html[i + 1] === '!') {
+				i += 2;
+
+				if (html.slice(i, i + DOCTYPE.length).toUpperCase() === DOCTYPE) {
+					i += DOCTYPE.length;
+					while (i < html.length) {
+						if (html[i++] === '>') {
+							continue main;
 						}
+					}
+				}
 
-						if (!decoded.startsWith(config.kit.paths.base)) {
-							return not_found(res, `Not found (did you mean ${config.kit.paths.base + req.url}?)`);
+				// skip cdata
+				if (html.slice(i, i + CDATA_OPEN.length) === CDATA_OPEN) {
+					i += CDATA_OPEN.length;
+					while (i < html.length) {
+						if (html.slice(i, i + CDATA_CLOSE.length) === CDATA_CLOSE) {
+							i += CDATA_CLOSE.length;
+							continue main;
 						}
 
-						/** @type {Partial<import('types').Hooks>} */
-						const user_hooks = resolve_entry(config.kit.files.hooks)
-							? await vite.ssrLoadModule(`/${config.kit.files.hooks}`, { fixStacktrace: false })
-							: {};
-
-						const handle = user_hooks.handle || (({ event, resolve }) => resolve(event));
-
-						/** @type {import('types').Hooks} */
-						const hooks = {
-							getSession: user_hooks.getSession || (() => ({})),
-							handle,
-							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'
-							);
+						i += 1;
+					}
+				}
+
+				// skip comments
+				if (html.slice(i, i + COMMENT_OPEN.length) === COMMENT_OPEN) {
+					i += COMMENT_OPEN.length;
+					while (i < html.length) {
+						if (html.slice(i, i + COMMENT_CLOSE.length) === COMMENT_CLOSE) {
+							i += COMMENT_CLOSE.length;
+							continue main;
 						}
 
-						if (/** @type {any} */ (hooks).serverFetch) {
-							// TODO remove this for 1.0
-							throw new Error('The serverFetch hook has been renamed to externalFetch.');
+						i += 1;
+					}
+				}
+			}
+
+			// parse opening tags
+			const start = ++i;
+			if (TAG_OPEN.test(html[start])) {
+				while (i < html.length) {
+					if (!TAG_CHAR.test(html[i])) {
+						break;
+					}
+
+					i += 1;
+				}
+
+				const tag = html.slice(start, i).toUpperCase();
+
+				if (tag === 'SCRIPT' || tag === 'STYLE') {
+					while (i < html.length) {
+						if (
+							html[i] === '<' &&
+							html[i + 1] === '/' &&
+							html.slice(i + 2, i + 2 + tag.length).toUpperCase() === tag
+						) {
+							continue main;
 						}
 
-						// TODO the / prefix will probably fail if outDir is outside the cwd (which
-						// could be the case in a monorepo setup), but without it these modules
-						// 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, `${config.kit.outDir}/generated/root.svelte`))}`,
-							{ fixStacktrace: false }
-						);
-
-						const paths = await vite.ssrLoadModule(
-							true
-								? `/${posixify(path__default.relative(cwd$1, `${config.kit.outDir}/runtime/paths.js`))}`
-								: `/@fs${runtime}/paths.js`,
-							{ fixStacktrace: false }
-						);
-
-						paths.set_paths({
-							base: config.kit.paths.base,
-							assets
-						});
+						i += 1;
+					}
+				}
 
-						let request;
+				let href = '';
+				let rel = '';
 
-						try {
-							request = await getRequest(base, req);
-						} catch (/** @type {any} */ err) {
-							res.statusCode = err.status || 400;
-							return res.end(err.reason || 'Invalid request body');
+				while (i < html.length) {
+					const start = i;
+
+					const char = html[start];
+					if (char === '>') break;
+
+					if (ATTRIBUTE_NAME.test(char)) {
+						i += 1;
+
+						while (i < html.length) {
+							if (!ATTRIBUTE_NAME.test(html[i])) {
+								break;
+							}
+
+							i += 1;
 						}
 
-						const template = load_template(cwd$1, config);
-
-						const rendered = await respond(
-							request,
-							{
-								csp: config.kit.csp,
-								dev: true,
-								floc: config.kit.floc,
-								get_stack: (error) => {
-									return fix_stack_trace(error);
-								},
-								handle_error: (error, event) => {
-									hooks.handleError({
-										error: new Proxy(error, {
-											get: (target, property) => {
-												if (property === 'stack') {
-													return fix_stack_trace(error);
-												}
-
-												return Reflect.get(target, property, target);
-											}
-										}),
-										event,
-
-										// TODO remove for 1.0
-										// @ts-expect-error
-										get request() {
-											throw new Error(
-												'request in handleError has been replaced with event. See https://github.com/sveltejs/kit/pull/3384 for details'
-											);
+						const name = html.slice(start, i).toLowerCase();
+
+						while (WHITESPACE.test(html[i])) i += 1;
+
+						if (html[i] === '=') {
+							i += 1;
+							while (WHITESPACE.test(html[i])) i += 1;
+
+							let value;
+
+							if (html[i] === "'" || html[i] === '"') {
+								const quote = html[i++];
+
+								const start = i;
+								let escaped = false;
+
+								while (i < html.length) {
+									if (!escaped) {
+										const char = html[i];
+
+										if (html[i] === quote) {
+											break;
 										}
-									});
-								},
-								hooks,
-								hydrate: config.kit.browser.hydrate,
-								manifest,
-								method_override: config.kit.methodOverride,
-								paths: {
-									base: config.kit.paths.base,
-									assets
-								},
-								prefix: '',
-								prerender: {
-									default: config.kit.prerender.default,
-									enabled: config.kit.prerender.enabled
-								},
-								read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
-								root,
-								router: config.kit.browser.router,
-								template: ({ head, body, assets, nonce }) => {
-									return (
-										template
-											.replace(/%sveltekit\.assets%/g, assets)
-											.replace(/%sveltekit\.nonce%/g, nonce)
-											// head and body must be replaced last, in case someone tries to sneak in %sveltekit.assets% etc
-											.replace('%sveltekit.head%', () => head)
-											.replace('%sveltekit.body%', () => body)
-									);
-								},
-								template_contains_nonce: template.includes('%sveltekit.nonce%'),
-								trailing_slash: config.kit.trailingSlash
-							},
-							{
-								getClientAddress: () => {
-									const { remoteAddress } = req.socket;
-									if (remoteAddress) return remoteAddress;
-									throw new Error('Could not determine clientAddress');
+
+										if (char === '\\') {
+											escaped = true;
+										}
+									}
+
+									i += 1;
 								}
+
+								value = html.slice(start, i);
+							} else {
+								const start = i;
+								while (html[i] !== '>' && !WHITESPACE.test(html[i])) i += 1;
+								value = html.slice(start, i);
+
+								i -= 1;
 							}
-						);
 
-						if (rendered.status === 404) {
-							// @ts-expect-error
-							serve_static_middleware.handle(req, res, () => {
-								setResponse(res, rendered);
-							});
+							if (name === 'href') {
+								href = value;
+							} else if (name === 'rel') {
+								rel = value;
+							} else if (name === 'src') {
+								hrefs.push(value);
+							} else if (name === 'srcset') {
+								const candidates = [];
+								let insideURL = true;
+								value = value.trim();
+								for (let i = 0; i < value.length; i++) {
+									if (value[i] === ',' && (!insideURL || (insideURL && value[i + 1] === ' '))) {
+										candidates.push(value.slice(0, i));
+										value = value.substring(i + 1).trim();
+										i = 0;
+										insideURL = true;
+									} else if (value[i] === ' ') {
+										insideURL = false;
+									}
+								}
+								candidates.push(value);
+								for (const candidate of candidates) {
+									const src = candidate.split(WHITESPACE)[0];
+									hrefs.push(src);
+								}
+							}
 						} else {
-							setResponse(res, rendered);
+							i -= 1;
 						}
-					} catch (e) {
-						const error = coalesce_to_error(e);
-						vite.ssrFixStacktrace(error);
-						res.statusCode = 500;
-						res.end(error.stack);
 					}
-				});
-			};
+
+					i += 1;
+				}
+
+				if (href && !/\bexternal\b/i.test(rel)) {
+					hrefs.push(href);
+				}
+			}
 		}
-	};
-}
 
-/** @param {import('http').ServerResponse} res */
-function not_found(res, message = 'Not found') {
-	res.statusCode = 404;
-	res.end(message);
+		i += 1;
+	}
+
+	return hrefs;
 }
 
 /**
- * @param {import('connect').Server} server
+ * Inside a script element, only `</script` and `<!--` hold special meaning to the HTML parser.
+ *
+ * The first closes the script element, so everything after is treated as raw HTML.
+ * The second disables further parsing until `-->`, so the script element might be unexpectedly
+ * kept open until until an unrelated HTML comment in the page.
+ *
+ * U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR are escaped for the sake of pre-2018
+ * browsers.
+ *
+ * @see tests for unsafe parsing examples.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#restrictions-for-contents-of-script-elements
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#cdata-rcdata-restrictions
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#script-data-state
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#script-data-double-escaped-state
+ * @see https://github.com/tc39/proposal-json-superset
+ * @type {Record<string, string>}
+ */
+const render_json_payload_script_dict = {
+	'<': '\\u003C',
+	'\u2028': '\\u2028',
+	'\u2029': '\\u2029'
+};
+
+new RegExp(
+	`[${Object.keys(render_json_payload_script_dict).join('')}]`,
+	'g'
+);
+
+/**
+ * When inside a double-quoted attribute value, only `&` and `"` hold special meaning.
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#attribute-value-(double-quoted)-state
+ * @type {Record<string, string>}
  */
-function remove_html_middlewares(server) {
-	const html_middlewares = [
-		'viteIndexHtmlMiddleware',
-		'vite404Middleware',
-		'viteSpaFallbackMiddleware',
-		'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)) {
-			server.stack.splice(i, 1);
+const escape_html_attr_dict = {
+	'&': '&amp;',
+	'"': '&quot;'
+};
+
+const escape_html_attr_regex = new RegExp(
+	// special characters
+	`[${Object.keys(escape_html_attr_dict).join('')}]|` +
+		// high surrogate without paired low surrogate
+		'[\\ud800-\\udbff](?![\\udc00-\\udfff])|' +
+		// a valid surrogate pair, the only match with 2 code units
+		// we match it so that we can match unpaired low surrogates in the same pass
+		// TODO: use lookbehind assertions once they are widely supported: (?<![\ud800-udbff])[\udc00-\udfff]
+		'[\\ud800-\\udbff][\\udc00-\\udfff]|' +
+		// unpaired low surrogate (see previous match)
+		'[\\udc00-\\udfff]',
+	'g'
+);
+
+/**
+ * Formats a string to be used as an attribute's value in raw HTML.
+ *
+ * It escapes unpaired surrogates (which are allowed in js strings but invalid in HTML), escapes
+ * characters that are special in attributes, and surrounds the whole string in double-quotes.
+ *
+ * @param {string} str
+ * @returns {string} Escaped string surrounded by double-quotes.
+ * @example const html = `<tag data-value=${escape_html_attr('value')}>...</tag>`;
+ */
+function escape_html_attr(str) {
+	const escaped_str = str.replace(escape_html_attr_regex, (match) => {
+		if (match.length === 2) {
+			// valid surrogate pair
+			return match;
 		}
+
+		return escape_html_attr_dict[match] ?? `&#${match.charCodeAt(0)};`;
+	});
+
+	return `"${escaped_str}"`;
+}
+
+/**
+ * @typedef {import('types').PrerenderErrorHandler} PrerenderErrorHandler
+ * @typedef {import('types').PrerenderOnErrorValue} OnError
+ * @typedef {import('types').Logger} Logger
+ */
+
+/** @type {(details: Parameters<PrerenderErrorHandler>[0] ) => string} */
+function format_error({ status, path, referrer, referenceType }) {
+	return `${status} ${path}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+}
+
+/** @type {(log: Logger, onError: OnError) => PrerenderErrorHandler} */
+function normalise_error_handler(log, onError) {
+	switch (onError) {
+		case 'continue':
+			return (details) => {
+				log.error(format_error(details));
+			};
+		case 'fail':
+			return (details) => {
+				throw new Error(format_error(details));
+			};
+		default:
+			return onError;
 	}
 }
 
+const OK = 2;
+const REDIRECT = 3;
+
 /**
- * @param {import('vite').ViteDevServer} vite
- * @param {import('vite').ModuleNode} node
- * @param {Set<import('vite').ModuleNode>} deps
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   entries: string[];
+ *   files: Set<string>;
+ *   log: Logger;
+ * }} opts
  */
-async function find_deps(vite, node, deps) {
-	// since `ssrTransformResult.deps` contains URLs instead of `ModuleNode`s, this process is asynchronous.
-	// instead of using `await`, we resolve all branches in parallel.
-	/** @type {Promise<void>[]} */
-	const branches = [];
-
-	/** @param {import('vite').ModuleNode} node */
-	async function add(node) {
-		if (!deps.has(node)) {
-			deps.add(node);
-			await find_deps(vite, node, deps);
-		}
+async function prerender({ config, entries, files, log }) {
+	/** @type {import('types').Prerendered} */
+	const prerendered = {
+		pages: new Map(),
+		assets: new Map(),
+		redirects: new Map(),
+		paths: []
+	};
+
+	if (!config.kit.prerender.enabled) {
+		return prerendered;
 	}
 
-	/** @param {string} url */
-	async function add_by_url(url) {
-		const node = await vite.moduleGraph.getModuleByUrl(url);
+	installPolyfills();
+
+	const server_root = join(config.kit.outDir, 'output');
+
+	/** @type {import('types').ServerModule} */
+	const { Server, override } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
+	const { manifest } = await import(pathToFileURL(`${server_root}/server/manifest.js`).href);
+
+	override({
+		paths: config.kit.paths,
+		prerendering: true,
+		read: (file) => readFileSync(join(config.kit.files.assets, file))
+	});
+
+	const server = new Server(manifest);
+
+	const error = normalise_error_handler(log, config.kit.prerender.onError);
 
-		if (node) {
-			await add(node);
+	const q = queue(config.kit.prerender.concurrency);
+
+	/**
+	 * @param {string} path
+	 * @param {boolean} is_html
+	 */
+	function output_filename(path, is_html) {
+		const file = path.slice(config.kit.paths.base.length + 1);
+
+		if (file === '') {
+			return 'index.html';
+		}
+
+		if (is_html && !file.endsWith('.html')) {
+			return file + (file.endsWith('/') ? 'index.html' : '.html');
 		}
+
+		return file;
+	}
+
+	const seen = new Set();
+	const written = new Set();
+
+	/**
+	 * @param {string | null} referrer
+	 * @param {string} decoded
+	 * @param {string} [encoded]
+	 */
+	function enqueue(referrer, decoded, encoded) {
+		if (seen.has(decoded)) return;
+		seen.add(decoded);
+
+		const file = decoded.slice(config.kit.paths.base.length + 1);
+		if (files.has(file)) return;
+
+		return q.add(() => visit(decoded, encoded || encodeURI(decoded), referrer));
 	}
 
-	if (node.ssrTransformResult) {
-		if (node.ssrTransformResult.deps) {
-			node.ssrTransformResult.deps.forEach((url) => branches.push(add_by_url(url)));
+	/**
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string?} referrer
+	 */
+	async function visit(decoded, encoded, referrer) {
+		if (!decoded.startsWith(config.kit.paths.base)) {
+			error({ status: 404, path: decoded, referrer, referenceType: 'linked' });
+			return;
+		}
+
+		/** @type {Map<string, import('types').PrerenderDependency>} */
+		const dependencies = new Map();
+
+		const response = await server.respond(new Request(`http://sveltekit-prerender${encoded}`), {
+			getClientAddress,
+			prerendering: {
+				dependencies
+			}
+		});
+
+		const text = await response.text();
+
+		save('pages', response, text, decoded, encoded, referrer, 'linked');
+
+		for (const [dependency_path, result] of dependencies) {
+			// this seems circuitous, but using new URL allows us to not care
+			// whether dependency_path is encoded or not
+			const encoded_dependency_path = new URL$1(dependency_path, 'http://localhost').pathname;
+			const decoded_dependency_path = decodeURI(encoded_dependency_path);
+
+			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
+			save(
+				'dependencies',
+				result.response,
+				body,
+				decoded_dependency_path,
+				encoded_dependency_path,
+				decoded,
+				'fetched'
+			);
+		}
+
+		if (config.kit.prerender.crawl && response.headers.get('content-type') === 'text/html') {
+			for (const href of crawl(text)) {
+				if (href.startsWith('data:') || href.startsWith('#')) continue;
+
+				const resolved = resolve(encoded, href);
+				if (!is_root_relative(resolved)) continue;
+
+				const { pathname, search } = new URL$1(resolved, 'http://localhost');
+
+				enqueue(decoded, decodeURI(pathname), pathname);
+			}
 		}
-	} else {
-		node.importedModules.forEach((node) => branches.push(add(node)));
 	}
 
-	await Promise.all(branches);
-}
+	/**
+	 * @param {'pages' | 'dependencies'} category
+	 * @param {Response} response
+	 * @param {string | Uint8Array} body
+	 * @param {string} decoded
+	 * @param {string} encoded
+	 * @param {string | null} referrer
+	 * @param {'linked' | 'fetched'} referenceType
+	 */
+	function save(category, response, body, decoded, encoded, referrer, referenceType) {
+		const response_type = Math.floor(response.status / 100);
+		const type = /** @type {string} */ (response.headers.get('content-type'));
+		const is_html = response_type === REDIRECT || type === 'text/html';
+
+		const file = output_filename(decoded, is_html);
+		const dest = `${config.kit.outDir}/output/prerendered/${category}/${file}`;
+
+		if (written.has(file)) return;
+
+		if (response_type === REDIRECT) {
+			const location = response.headers.get('location');
+
+			if (location) {
+				const resolved = resolve(encoded, location);
+				if (is_root_relative(resolved)) {
+					enqueue(decoded, decodeURI(resolved), resolved);
+				}
 
-const cwd = process.cwd();
+				if (!response.headers.get('x-sveltekit-normalize')) {
+					mkdirp(dirname(dest));
 
-/**
- * @typedef {{
- *   port: number,
- *   host?: string,
- *   https: boolean,
- * }} Options
- * @typedef {import('types').SSRComponent} SSRComponent
- */
+					log.warn(`${response.status} ${decoded} -> ${location}`);
 
-/** @param {Options} opts */
-async function dev({ port, host, https }) {
-	/** @type {import('types').ValidatedConfig} */
-	const config = await load_config();
-
-	const [vite_config] = deep_merge(
-		{
-			server: {
-				fs: {
-					allow: [
-						...new Set([
-							config.kit.files.lib,
-							config.kit.files.routes,
-							config.kit.outDir,
-							path__default.resolve(cwd, 'src'),
-							path__default.resolve(cwd, 'node_modules'),
-							path__default.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
-						])
-					]
-				},
-				port: 3000,
-				strictPort: true,
-				watch: {
-					ignored: [`${config.kit.outDir}/**`, `!${config.kit.outDir}/generated/**`]
+					writeFileSync(
+						dest,
+						`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
+					);
+
+					written.add(file);
+
+					if (!prerendered.redirects.has(decoded)) {
+						prerendered.redirects.set(decoded, {
+							status: response.status,
+							location: resolved
+						});
+
+						prerendered.paths.push(normalize_path(decoded, 'never'));
+					}
 				}
+			} else {
+				log.warn(`location header missing on redirect received from ${decoded}`);
 			}
-		},
-		await config.kit.vite()
-	);
 
-	/** @type {[any, string[]]} */
-	const [merged_config, conflicts] = deep_merge(vite_config, {
-		configFile: false,
-		root: cwd,
-		resolve: {
-			alias: get_aliases(config)
-		},
-		build: {
-			rollupOptions: {
-				// Vite dependency crawler needs an explicit JS entry point
-				// eventhough server otherwise works without it
-				input: `${get_runtime_path(config)}/client/start.js`
-			}
-		},
-		plugins: [
-			svelte({
-				...config,
-				emitCss: true,
-				compilerOptions: {
-					...config.compilerOptions,
-					hydratable: !!config.kit.browser.hydrate
-				},
-				configFile: false
-			}),
-			await create_plugin(config)
-		],
-		base: '/'
-	});
+			return;
+		}
 
-	print_config_conflicts(conflicts, 'kit.vite.');
+		if (response.status === 200) {
+			mkdirp(dirname(dest));
 
-	// optional config from command-line flags
-	// these should take precedence, but not print conflict warnings
-	if (host) {
-		merged_config.server.host = host;
-	}
+			log.info(`${response.status} ${decoded}`);
+			writeFileSync(dest, body);
+			written.add(file);
+
+			if (is_html) {
+				prerendered.pages.set(decoded, {
+					file
+				});
+			} else {
+				prerendered.assets.set(decoded, {
+					type
+				});
+			}
 
-	// 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;
+			prerendered.paths.push(normalize_path(decoded, 'never'));
+		} else if (response_type !== OK) {
+			error({ status: response.status, path: decoded, referrer, referenceType });
+		}
 	}
 
-	if (port) {
-		merged_config.server.port = port;
+	if (config.kit.prerender.enabled) {
+		for (const entry of config.kit.prerender.entries) {
+			if (entry === '*') {
+				for (const entry of entries) {
+					enqueue(null, config.kit.paths.base + entry); // TODO can we pre-normalize these?
+				}
+			} else {
+				enqueue(null, config.kit.paths.base + entry);
+			}
+		}
+
+		await q.done();
 	}
 
-	const server = await vite.createServer(merged_config);
-	await server.listen(port);
+	const rendered = await server.respond(new Request('http://sveltekit-prerender/[fallback]'), {
+		getClientAddress,
+		prerendering: {
+			fallback: true,
+			dependencies: new Map()
+		}
+	});
 
-	return {
-		server,
-		config
+	const file = `${config.kit.outDir}/output/prerendered/fallback.html`;
+	mkdirp(dirname(file));
+	writeFileSync(file, await rendered.text());
+
+	return prerendered;
+}
+
+/** @return {string} */
+function getClientAddress() {
+	throw new Error('Cannot read clientAddress during prerendering');
+}
+
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {{ log: import('types').Logger }} opts
+ */
+async function build(config, { log }) {
+	const cwd = process.cwd(); // TODO is this necessary?
+
+	const build_dir = path__default.join(config.kit.outDir, 'build');
+	rimraf(build_dir);
+	mkdirp(build_dir);
+
+	const output_dir = path__default.join(config.kit.outDir, 'output');
+	rimraf(output_dir);
+	mkdirp(output_dir);
+
+	const { manifest_data } = all(config);
+
+	const options = {
+		cwd,
+		config,
+		build_dir,
+		manifest_data,
+		output_dir,
+		client_entry_file: path__default.relative(cwd, `${get_runtime_path(config)}/client/start.js`),
+		service_worker_entry_file: resolve_entry(config.kit.files.serviceWorker)
+	};
+
+	const client = await build_client(options);
+	const server = await build_server(options, client);
+
+	/** @type {import('types').BuildData} */
+	const build_data = {
+		app_dir: config.kit.appDir,
+		manifest_data: options.manifest_data,
+		service_worker: options.service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
+		client,
+		server
 	};
+
+	const manifest = `export const manifest = ${generate_manifest({
+		build_data,
+		relative_path: '.',
+		routes: options.manifest_data.routes
+	})};\n`;
+	fs__default.writeFileSync(`${output_dir}/server/manifest.js`, manifest);
+
+	const static_files = options.manifest_data.assets.map((asset) => posixify(asset.file));
+
+	const files = new Set([
+		...static_files,
+		...client.chunks.map((chunk) => `${config.kit.appDir}/immutable/${chunk.fileName}`),
+		...client.assets.map((chunk) => `${config.kit.appDir}/immutable/${chunk.fileName}`)
+	]);
+
+	// TODO is this right?
+	static_files.forEach((file) => {
+		if (file.endsWith('/index.html')) {
+			files.add(file.slice(0, -11));
+		}
+	});
+
+	const prerendered = await prerender({
+		config,
+		entries: options.manifest_data.routes
+			.map((route) => (route.type === 'page' ? route.path : ''))
+			.filter(Boolean),
+		files,
+		log
+	});
+
+	if (options.service_worker_entry_file) {
+		if (config.kit.paths.assets) {
+			throw new Error('Cannot use service worker alongside config.kit.paths.assets');
+		}
+
+		await build_service_worker(options, prerendered, client.vite_manifest);
+	}
+
+	return { build_data, prerendered };
 }
 
-export { dev };
+export { build };