@sveltejs/kit 1.0.0-next.206 → 1.0.0-next.208

package/dist/chunks/index3.js

@@ -1,526 +1,136 @@
-import fs__default from 'fs';
+import fs__default, { writeFileSync } from 'fs';
 import path__default from 'path';
-import { svelte } from '@sveltejs/vite-plugin-svelte';
-import require$$0 from 'os';
-import vite from 'vite';
-import { r as rimraf, a as resolve_entry, b as posixify, 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 { 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 { 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';
+import { s } from './misc.js';
+import vite from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
 import 'sade';
 import 'child_process';
 import 'net';
 import 'url';
+import 'os';
 import './error.js';
 
-const isWin$1 = process.platform === 'win32';
-const SEP = isWin$1 ? `\\\\+` : `\\/`;
-const SEP_ESC = isWin$1 ? `\\\\` : `/`;
-const GLOBSTAR = `((?:[^/]*(?:/|$))*)`;
-const WILDCARD = `([^/]*)`;
-const GLOBSTAR_SEGMENT = `((?:[^${SEP_ESC}]*(?:${SEP_ESC}|$))*)`;
-const WILDCARD_SEGMENT = `([^${SEP_ESC}]*)`;
-
-/**
- * Convert any glob pattern to a JavaScript Regexp object
- * @param {String} glob Glob pattern to convert
- * @param {Object} opts Configuration object
- * @param {Boolean} [opts.extended=false] Support advanced ext globbing
- * @param {Boolean} [opts.globstar=false] Support globstar
- * @param {Boolean} [opts.strict=true] be laissez faire about mutiple slashes
- * @param {Boolean} [opts.filepath=''] Parse as filepath for extra path related features
- * @param {String} [opts.flags=''] RegExp globs
- * @returns {Object} converted object with string, segments and RegExp object
- */
-function globrex$1(glob, {extended = false, globstar = false, strict = false, filepath = false, flags = ''} = {}) {
-    let regex = '';
-    let segment = '';
-    let path = { regex: '', segments: [] };
-
-    // If we are doing extended matching, this boolean is true when we are inside
-    // a group (eg {*.html,*.js}), and false otherwise.
-    let inGroup = false;
-    let inRange = false;
-
-    // extglob stack. Keep track of scope
-    const ext = [];
-
-    // Helper function to build string and segments
-    function add(str, {split, last, only}={}) {
-        if (only !== 'path') regex += str;
-        if (filepath && only !== 'regex') {
-            path.regex += (str === '\\/' ? SEP : str);
-            if (split) {
-                if (last) segment += str;
-                if (segment !== '') {
-                    if (!flags.includes('g')) segment = `^${segment}$`; // change it 'includes'
-                    path.segments.push(new RegExp(segment, flags));
-                }
-                segment = '';
-            } else {
-                segment += str;
-            }
-        }
-    }
-
-    let c, n;
-    for (let i = 0; i < glob.length; i++) {
-        c = glob[i];
-        n = glob[i + 1];
-
-        if (['\\', '$', '^', '.', '='].includes(c)) {
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '/') {
-            add(`\\${c}`, {split: true});
-            if (n === '/' && !strict) regex += '?';
-            continue;
-        }
-
-        if (c === '(') {
-            if (ext.length) {
-                add(c);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === ')') {
-            if (ext.length) {
-                add(c);
-                let type = ext.pop();
-                if (type === '@') {
-                    add('{1}');
-                } else if (type === '!') {
-                    add('([^\/]*)');
-                } else {
-                    add(type);
-                }
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-        
-        if (c === '|') {
-            if (ext.length) {
-                add(c);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '+') {
-            if (n === '(' && extended) {
-                ext.push(c);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '@' && extended) {
-            if (n === '(') {
-                ext.push(c);
-                continue;
-            }
-        }
-
-        if (c === '!') {
-            if (extended) {
-                if (inRange) {
-                    add('^');
-                    continue
-                }
-                if (n === '(') {
-                    ext.push(c);
-                    add('(?!');
-                    i++;
-                    continue;
-                }
-                add(`\\${c}`);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '?') {
-            if (extended) {
-                if (n === '(') {
-                    ext.push(c);
-                } else {
-                    add('.');
-                }
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '[') {
-            if (inRange && n === ':') {
-                i++; // skip [
-                let value = '';
-                while(glob[++i] !== ':') value += glob[i];
-                if (value === 'alnum') add('(\\w|\\d)');
-                else if (value === 'space') add('\\s');
-                else if (value === 'digit') add('\\d');
-                i++; // skip last ]
-                continue;
-            }
-            if (extended) {
-                inRange = true;
-                add(c);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === ']') {
-            if (extended) {
-                inRange = false;
-                add(c);
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '{') {
-            if (extended) {
-                inGroup = true;
-                add('(');
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '}') {
-            if (extended) {
-                inGroup = false;
-                add(')');
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === ',') {
-            if (inGroup) {
-                add('|');
-                continue;
-            }
-            add(`\\${c}`);
-            continue;
-        }
-
-        if (c === '*') {
-            if (n === '(' && extended) {
-                ext.push(c);
-                continue;
-            }
-            // Move over all consecutive "*"'s.
-            // Also store the previous and next characters
-            let prevChar = glob[i - 1];
-            let starCount = 1;
-            while (glob[i + 1] === '*') {
-                starCount++;
-                i++;
-            }
-            let nextChar = glob[i + 1];
-            if (!globstar) {
-                // globstar is disabled, so treat any number of "*" as one
-                add('.*');
-            } else {
-                // globstar is enabled, so determine if this is a globstar segment
-                let isGlobstar =
-                    starCount > 1 && // multiple "*"'s
-                    (prevChar === '/' || prevChar === undefined) && // from the start of the segment
-                    (nextChar === '/' || nextChar === undefined); // to the end of the segment
-                if (isGlobstar) {
-                    // it's a globstar, so match zero or more path segments
-                    add(GLOBSTAR, {only:'regex'});
-                    add(GLOBSTAR_SEGMENT, {only:'path', last:true, split:true});
-                    i++; // move over the "/"
-                } else {
-                    // it's not a globstar, so only match one path segment
-                    add(WILDCARD, {only:'regex'});
-                    add(WILDCARD_SEGMENT, {only:'path'});
-                }
-            }
-            continue;
-        }
-
-        add(c);
-    }
-
-
-    // When regexp 'g' flag is specified don't
-    // constrain the regular expression with ^ & $
-    if (!flags.includes('g')) {
-        regex = `^${regex}$`;
-        segment = `^${segment}$`;
-        if (filepath) path.regex = `^${path.regex}$`;
-    }
-
-    const result = {regex: new RegExp(regex, flags)};
-
-    // Push the last segment
-    if (filepath) {
-        path.segments.push(new RegExp(segment, flags));
-        path.regex = new RegExp(path.regex, flags);
-        path.globstar = new RegExp(!flags.includes('g') ? `^${GLOBSTAR_SEGMENT}$` : GLOBSTAR_SEGMENT, flags);
-        result.path = path;
-    }
-
-    return result;
-}
-
-var globrex_1 = globrex$1;
-
-const os = require$$0;
-const path = path__default;
-const isWin = os.platform() === 'win32';
-
-const CHARS = { '{': '}', '(': ')', '[': ']'};
-const STRICT = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\)|(\\).|([@?!+*]\(.*\)))/;
-const RELAXED = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
-
 /**
- * Detect if a string cointains glob
- * @param {String} str Input string
- * @param {Object} [options] Configuration object
- * @param {Boolean} [options.strict=true] Use relaxed regex if true
- * @returns {Boolean} true if string contains glob
+ * @param {{
+ *   cwd: string;
+ *   assets_base: string;
+ *   config: import('types/config').ValidatedConfig
+ *   manifest_data: import('types/internal').ManifestData
+ *   build_dir: string;
+ *   output_dir: string;
+ *   client_entry_file: string;
+ *   service_worker_entry_file: string | null;
+ * }} options
+ * @param {import('vite').Manifest} client_manifest
  */
-function isglob(str, { strict = true } = {}) {
-  if (str === '') return false;
-  let match, rgx = strict ? STRICT : RELAXED;
-
-  while ((match = rgx.exec(str))) {
-    if (match[2]) return true;
-    let idx = match.index + match[0].length;
-
-    // if an open bracket/brace/paren is escaped,
-    // set the index to the next closing character
-    let open = match[1];
-    let close = open ? CHARS[open] : null;
-    if (open && close) {
-      let n = str.indexOf(close, idx);
-      if (n !== -1)  idx = n + 1;
-    }
-
-    str = str.slice(idx);
-  }
-  return false;
-}
-
+async function build_service_worker(
+	{ cwd, assets_base, config, manifest_data, build_dir, output_dir, service_worker_entry_file },
+	client_manifest
+) {
+	// TODO add any assets referenced in template .html file, e.g. favicon?
+	const app_files = new Set();
+	for (const key in client_manifest) {
+		const { file, css } = client_manifest[key];
+		app_files.add(file);
+		if (css) {
+			css.forEach((file) => {
+				app_files.add(file);
+			});
+		}
+	}
 
-/**
- * Find the static part of a glob-path,
- * split path and return path part
- * @param {String} str Path/glob string
- * @returns {String} static path section of glob
- */
-function parent(str, { strict = false } = {}) {
-  if (isWin && str.includes('/'))
-    str = str.split('\\').join('/');
+	fs__default.writeFileSync(
+		`${build_dir}/runtime/service-worker.js`,
+		`
+			export const timestamp = ${Date.now()};
 
-	// special case for strings ending in enclosure containing path separator
-	if (/[\{\[].*[\/]*.*[\}\]]$/.test(str)) str += '/';
+			export const build = [
+				${Array.from(app_files)
+					.map((file) => `${s(`${config.kit.paths.base}/${config.kit.appDir}/${file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
 
-	// preserves full path in case of trailing path separator
-	str += 'a';
+			export const files = [
+				${manifest_data.assets
+					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
+		`
+			.replace(/^\t{3}/gm, '')
+			.trim()
+	);
 
-	do {str = path.dirname(str);}
-	while (isglob(str, {strict}) || /(^|[^\\])([\{\[]|\([^\)]+$)/.test(str));
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(config.kit.vite(), {
+		configFile: false,
+		root: cwd,
+		base: assets_base,
+		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': path__default.resolve(`${build_dir}/runtime/service-worker`),
+				$lib: config.kit.files.lib
+			}
+		}
+	});
 
-	// remove escape chars and return result
-	return str.replace(/\\([\*\?\|\[\]\(\)\{\}])/g, '$1');
-}
+	print_config_conflicts(conflicts, 'kit.vite.', 'build_service_worker');
 
-/**
- * Parse a glob path, and split it by static/glob part
- * @param {String} pattern String path
- * @param {Object} [opts] Options
- * @param {Object} [opts.strict=false] Use strict parsing
- * @returns {Object} object with parsed path
- */
-function globalyzer$1(pattern, opts = {}) {
-    let base = parent(pattern, opts);
-    let isGlob = isglob(pattern, opts);
-    let glob;
-
-    if (base != '.') {
-        glob = pattern.substr(base.length);
-        if (glob.startsWith('/')) glob = glob.substr(1);
-    } else {
-        glob = pattern;
-    }
-
-    if (!isGlob) {
-        base = path.dirname(pattern);
-        glob = base !== '.' ? pattern.substr(base.length) : pattern;
-    }
-
-    if (glob.startsWith('./')) glob = glob.substr(2);
-    if (glob.startsWith('/')) glob = glob.substr(1);
-
-    return { base, glob, isGlob };
+	await vite.build(merged_config);
 }
 
+/** @param {import('vite').UserConfig} config */
+async function create_build(config) {
+	const { output } = /** @type {import('rollup').RollupOutput} */ (await vite.build(config));
 
-var src = globalyzer$1;
-
-const fs = fs__default;
-const globrex = globrex_1;
-const globalyzer = src;
-const { join, resolve, relative } = path__default;
-const isHidden = /(^|[\\\/])\.[^\\\/\.]/g;
-
-let CACHE = {};
-
-function walk(output, prefix, lexer, opts, dirname='', level=0) {
-  const rgx = lexer.segments[level];
-  const dir = resolve(opts.cwd, prefix, dirname);
-  const files = fs.readdirSync(dir);
-  const { dot, filesOnly } = opts;
-
-  let i=0, len=files.length, file;
-  let fullpath, relpath, stats, isMatch;
-
-  for (; i < len; i++) {
-    fullpath = join(dir, file=files[i]);
-    relpath = dirname ? join(dirname, file) : file;
-    if (!dot && isHidden.test(relpath)) continue;
-    isMatch = lexer.regex.test(relpath);
-
-    if ((stats=CACHE[relpath]) === void 0) {
-      CACHE[relpath] = stats = fs.lstatSync(fullpath);
-    }
-
-    if (!stats.isDirectory()) {
-      isMatch && output.push(relative(opts.cwd, fullpath));
-      continue;
-    }
+	const chunks = /** @type {import('rollup').OutputChunk[]} */ (
+		output.filter((output) => output.type === 'chunk')
+	);
 
-    if (rgx && !rgx.test(file)) continue;
-    !filesOnly && isMatch && output.push(join(prefix, relpath));
+	const assets = /** @type {import('rollup').OutputAsset[]} */ (
+		output.filter((output) => output.type === 'asset')
+	);
 
-    walk(output, prefix, lexer, opts, relpath, rgx && rgx.toString() !== lexer.globstar && level + 1);
-  }
+	return { chunks, assets };
 }
 
 /**
- * Find files using bash-like globbing.
- * All paths are normalized compared to node-glob.
- * @param {String} str Glob string
- * @param {String} [options.cwd='.'] Current working directory
- * @param {Boolean} [options.dot=false] Include dotfile matches
- * @param {Boolean} [options.absolute=false] Return absolute paths
- * @param {Boolean} [options.filesOnly=false] Do not include folders if true
- * @param {Boolean} [options.flush=false] Reset cache object
- * @returns {Array} array containing matching files
- */
-var sync = function (str, opts={}) {
-  if (!str) return [];
-
-  let glob = globalyzer(str);
-
-  opts.cwd = opts.cwd || '.';
-
-  if (!glob.isGlob) {
-    try {
-      let resolved = resolve(opts.cwd, str);
-      let dirent = fs.statSync(resolved);
-      if (opts.filesOnly && !dirent.isFile()) return [];
-
-      return opts.absolute ? [resolved] : [str];
-    } catch (err) {
-      if (err.code != 'ENOENT') throw err;
-
-      return [];
-    }
-  }
-
-  if (opts.flush) CACHE = {};
-
-  let matches = [];
-  const { path } = globrex(glob.glob, { filepath:true, globstar:true, extended:true });
-
-  path.globstar = path.globstar.toString();
-  walk(matches, glob.base, path, opts, '.', 0);
-
-  return opts.absolute ? matches.map(x => resolve(opts.cwd, x)) : matches;
-};
-
-var glob = sync;
-
-/** @param {any} value */
-const s = (value) => JSON.stringify(value);
-
-/**
- * @param {import('types/config').ValidatedConfig} config
- * @param {{
- *   cwd?: string;
- *   runtime?: string;
- * }} [opts]
- * @returns {Promise<import('types/internal').BuildData>}
+ * @param {string} file
+ * @param {import('vite').Manifest} manifest
+ * @param {Set<string>} css
+ * @param {Set<string>} js
+ * @returns
  */
-async function build(config, { cwd = process.cwd(), runtime = '@sveltejs/kit/ssr' } = {}) {
-	const build_dir = path__default.resolve(cwd, `${SVELTE_KIT}/build`);
-
-	rimraf(build_dir);
-
-	const output_dir = path__default.resolve(cwd, `${SVELTE_KIT}/output`);
-
-	const options = {
-		cwd,
-		config,
-		build_dir,
-		// TODO this is so that Vite's preloading works. Unfortunately, it fails
-		// during `svelte-kit preview`, because we use a local asset path. If Vite
-		// used relative paths, I _think_ this could get fixed. Issue here:
-		// https://github.com/vitejs/vite/issues/2009
-		assets_base: `${config.kit.paths.assets || config.kit.paths.base}/${config.kit.appDir}/`,
-		manifest: create_manifest_data({
-			config,
-			output: build_dir,
-			cwd
-		}),
-		output_dir,
-		client_entry_file: `${SVELTE_KIT}/build/runtime/internal/start.js`,
-		service_worker_entry_file: resolve_entry(config.kit.files.serviceWorker)
-	};
+function find_deps(file, manifest, js, css) {
+	const chunk = manifest[file];
 
-	const client_manifest = await build_client(options);
-	await build_server(options, client_manifest, runtime);
+	if (js.has(chunk.file)) return;
+	js.add(chunk.file);
 
-	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, client_manifest);
+	if (chunk.css) {
+		chunk.css.forEach((file) => css.add(file));
 	}
 
-	const client = glob('**', { cwd: `${output_dir}/client`, filesOnly: true }).map(posixify);
-	const server = glob('**', { cwd: `${output_dir}/server`, filesOnly: true }).map(posixify);
-
-	return {
-		client,
-		server,
-		static: options.manifest.assets.map((asset) => posixify(asset.file)),
-		entries: options.manifest.routes
-			.map((route) => (route.type === 'page' ? route.path : ''))
-			.filter(Boolean)
-	};
+	if (chunk.imports) {
+		chunk.imports.forEach((file) => find_deps(file, manifest, js, css));
+	}
 }
 
 /**
@@ -528,24 +138,25 @@ async function build(config, { cwd = process.cwd(), runtime = '@sveltejs/kit/ssr
  *   cwd: string;
  *   assets_base: string;
  *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
+ *   manifest_data: import('types/internal').ManifestData
  *   build_dir: string;
  *   output_dir: string;
  *   client_entry_file: string;
  *   service_worker_entry_file: string | null;
+ *   service_worker_register: boolean;
  * }} options
  */
 async function build_client({
 	cwd,
 	assets_base,
 	config,
-	manifest,
+	manifest_data,
 	build_dir,
 	output_dir,
 	client_entry_file
 }) {
 	create_app({
-		manifest_data: manifest,
+		manifest_data,
 		output: build_dir,
 		cwd
 	});
@@ -564,7 +175,7 @@ async function build_client({
 	// 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.components.forEach((file) => {
+	manifest_data.components.forEach((file) => {
 		const resolved = path__default.resolve(cwd, file);
 		const relative = path__default.relative(config.kit.files.routes, resolved);
 
@@ -574,16 +185,8 @@ async function build_client({
 		input[name] = resolved;
 	});
 
-	/** @type {import('vite').UserConfig} */
-	const vite_config = config.kit.vite();
-
-	const default_config = {};
-
-	// 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, {
+	const [merged_config, conflicts] = deep_merge(config.kit.vite(), {
 		configFile: false,
 		root: cwd,
 		base: assets_base,
@@ -621,42 +224,143 @@ async function build_client({
 
 	print_config_conflicts(conflicts, 'kit.vite.', 'build_client');
 
-	await vite.build(merged_config);
+	const { chunks, assets } = await create_build(merged_config);
 
-	const client_manifest_file = `${client_out_dir}/manifest.json`;
 	/** @type {import('vite').Manifest} */
-	const client_manifest = JSON.parse(fs__default.readFileSync(client_manifest_file, 'utf-8'));
-	fs__default.renameSync(client_manifest_file, `${output_dir}/manifest.json`); // inspectable but not shipped
+	const vite_manifest = JSON.parse(fs__default.readFileSync(`${client_out_dir}/manifest.json`, 'utf-8'));
+
+	const entry_js = new Set();
+	const entry_css = new Set();
+	find_deps(client_entry_file, vite_manifest, entry_js, entry_css);
+
+	return {
+		assets,
+		chunks,
+		entry: {
+			file: vite_manifest[client_entry_file].file,
+			js: Array.from(entry_js),
+			css: Array.from(entry_css)
+		},
+		vite_manifest
+	};
+}
+
+/**
+ * @param {{
+ *   runtime: string,
+ *   hooks: string,
+ *   config: import('types/config').ValidatedConfig
+ * }} opts
+ * @returns
+ */
+const template = ({ config, hooks, runtime }) => `
+import { respond } from '${runtime}';
+import root from './generated/root.svelte';
+import { set_paths, assets, base } from './runtime/paths.js';
+import { set_prerendering } from './runtime/env.js';
+import * as user_hooks from ${s(hooks)};
+
+const template = ({ head, body }) => ${s(fs__default.readFileSync(config.kit.files.template, 'utf-8'))
+	.replace('%svelte.head%', '" + head + "')
+	.replace('%svelte.body%', '" + body + "')};
+
+let read = null;
+
+set_paths(${s(config.kit.paths)});
+
+// this looks redundant, but the indirection allows us to access
+// named imports without triggering Rollup's missing import detection
+const get_hooks = hooks => ({
+	getSession: hooks.getSession || (() => ({})),
+	handle: hooks.handle || (({ request, resolve }) => resolve(request)),
+	handleError: hooks.handleError || (({ error }) => console.error(error.stack)),
+	externalFetch: hooks.externalFetch || fetch
+});
+
+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 App {
+	constructor(manifest) {
+		const hooks = get_hooks(user_hooks);
+
+		this.options = {
+			amp: ${config.kit.amp},
+			dev: false,
+			floc: ${config.kit.floc},
+			get_stack: error => String(error), // for security
+			handle_error: (error, request) => {
+				hooks.handleError({ error, request });
+				error.stack = this.options.get_stack(error);
+			},
+			hooks,
+			hydrate: ${s(config.kit.hydrate)},
+			manifest,
+			paths: { base, assets },
+			prefix: assets + '/${config.kit.appDir}/',
+			prerender: ${config.kit.prerender.enabled},
+			read,
+			root,
+			service_worker: ${
+				config.kit.files.serviceWorker && config.kit.serviceWorker.register
+					? "'/service-worker.js'"
+					: 'null'
+			},
+			router: ${s(config.kit.router)},
+			ssr: ${s(config.kit.ssr)},
+			target: ${s(config.kit.target)},
+			template,
+			trailing_slash: ${s(config.kit.trailingSlash)}
+		};
+	}
+
+	render(request, {
+		prerender
+	} = {}) {
+		// TODO remove this for 1.0
+		if (Object.keys(request).sort().join() !== 'headers,method,rawBody,url') {
+			throw new Error('Adapters should call app.render({ url, method, headers, rawBody })');
+		}
+
+		const host = ${
+			config.kit.host
+				? s(config.kit.host)
+				: `request.headers[${s(config.kit.headers.host || 'host')}]`
+		};
+		const protocol = ${
+			config.kit.protocol
+				? s(config.kit.protocol)
+				: config.kit.headers.protocol
+				? `request.headers[${s(config.kit.headers.protocol)}] || default_protocol`
+				: 'default_protocol'
+		};
 
-	return client_manifest;
+		return respond({ ...request, url: new URL(request.url, protocol + '://' + host) }, this.options, { prerender });
+	}
 }
+`;
 
 /**
  * @param {{
  *   cwd: string;
  *   assets_base: string;
  *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
+ *   manifest_data: import('types/internal').ManifestData
  *   build_dir: string;
  *   output_dir: string;
- *   client_entry_file: string;
- *   service_worker_entry_file: string | null;
  * }} options
- * @param {import('vite').Manifest} client_manifest
  * @param {string} runtime
  */
 async function build_server(
-	{
-		cwd,
-		assets_base,
-		config,
-		manifest,
-		build_dir,
-		output_dir,
-		client_entry_file,
-		service_worker_entry_file
-	},
-	client_manifest,
+	{ cwd, assets_base, config, manifest_data, build_dir, output_dir },
 	runtime
 ) {
 	let hooks_file = resolve_entry(config.kit.files.hooks);
@@ -665,215 +369,46 @@ async function build_server(
 		fs__default.writeFileSync(hooks_file, '');
 	}
 
-	const app_file = `${build_dir}/app.js`;
-
-	/** @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}`;
+	/** @type {Record<string, string>} */
+	const input = {
+		app: `${build_dir}/app.js`
 	};
 
-	const prefix = `/${config.kit.appDir}/`;
-
-	/**
-	 * @param {string} file
-	 * @param {Set<string>} js_deps
-	 * @param {Set<string>} css_deps
-	 */
-	function find_deps(file, js_deps, css_deps) {
-		const chunk = client_manifest[file];
-
-		if (js_deps.has(chunk.file)) return;
-		js_deps.add(chunk.file);
-
-		if (chunk.css) {
-			chunk.css.forEach((file) => css_deps.add(file));
+	// add entry points for every endpoint...
+	manifest_data.routes.forEach((route) => {
+		if (route.type === 'endpoint') {
+			const resolved = path__default.resolve(cwd, route.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;
 		}
+	});
 
-		if (chunk.imports) {
-			chunk.imports.forEach((file) => find_deps(file, js_deps, css_deps));
-		}
-	}
-
-	/** @type {Record<string, { entry: string, css: string[], js: string[], styles: string[] }>} */
-	const metadata_lookup = {};
-
-	manifest.components.forEach((file) => {
-		const js_deps = new Set();
-		const css_deps = new Set();
-
-		find_deps(file, js_deps, css_deps);
-
-		const js = Array.from(js_deps);
-		const css = Array.from(css_deps);
-
-		const styles = config.kit.amp
-			? Array.from(css_deps).map((url) => {
-					const resolved = `${output_dir}/client/${config.kit.appDir}/${url}`;
-					return fs__default.readFileSync(resolved, 'utf-8');
-			  })
-			: [];
+	// ...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);
 
-		metadata_lookup[file] = {
-			entry: client_manifest[file].file,
-			css,
-			js,
-			styles
-		};
+		const name = relative.startsWith('..')
+			? posixify(path__default.join('entries/pages', path__default.basename(file)))
+			: posixify(path__default.join('entries/pages', relative));
+		input[name] = resolved;
 	});
 
-	/** @type {Set<string>} */
-	const entry_js = new Set();
-	/** @type {Set<string>} */
-	const entry_css = new Set();
-
-	find_deps(client_entry_file, entry_js, entry_css);
+	/** @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}`;
+	};
 
 	// prettier-ignore
 	fs__default.writeFileSync(
-		app_file,
-		`
-			import { respond } from '${runtime}';
-			import root from './generated/root.svelte';
-			import { set_paths, assets } from './runtime/paths.js';
-			import { set_prerendering } from './runtime/env.js';
-			import * as user_hooks from ${s(app_relative(hooks_file))};
-
-			const template = ({ head, body }) => ${s(fs__default.readFileSync(config.kit.files.template, 'utf-8'))
-				.replace('%svelte.head%', '" + head + "')
-				.replace('%svelte.body%', '" + body + "')};
-
-			let options = null;
-
-			const default_settings = { paths: ${s(config.kit.paths)} };
-
-			// allow paths to be overridden in svelte-kit preview
-			// and in prerendering
-			export function init(settings = default_settings) {
-				set_paths(settings.paths);
-				set_prerendering(settings.prerendering || false);
-
-				const hooks = get_hooks(user_hooks);
-
-				options = {
-					amp: ${config.kit.amp},
-					dev: false,
-					entry: {
-						file: assets + ${s(prefix + client_manifest[client_entry_file].file)},
-						css: [${Array.from(entry_css).map(dep => 'assets + ' + s(prefix + dep))}],
-						js: [${Array.from(entry_js).map(dep => 'assets + ' + s(prefix + dep))}]
-					},
-					fetched: undefined,
-					floc: ${config.kit.floc},
-					get_component_path: id => assets + ${s(prefix)} + entry_lookup[id],
-					get_stack: error => String(error), // for security
-					handle_error: (error, request) => {
-						hooks.handleError({ error, request });
-						error.stack = options.get_stack(error);
-					},
-					hooks,
-					hydrate: ${s(config.kit.hydrate)},
-					initiator: undefined,
-					load_component,
-					manifest,
-					paths: settings.paths,
-					prerender: ${config.kit.prerender.enabled},
-					read: settings.read,
-					root,
-					service_worker: ${service_worker_entry_file ? "'/service-worker.js'" : 'null'},
-					router: ${s(config.kit.router)},
-					ssr: ${s(config.kit.ssr)},
-					target: ${s(config.kit.target)},
-					template,
-					trailing_slash: ${s(config.kit.trailingSlash)}
-				};
-			}
-
-			// input has already been decoded by decodeURI
-			// now handle the rest that decodeURIComponent would do
-			const d = s => s
-				.replace(/%23/g, '#')
-				.replace(/%3[Bb]/g, ';')
-				.replace(/%2[Cc]/g, ',')
-				.replace(/%2[Ff]/g, '/')
-				.replace(/%3[Ff]/g, '?')
-				.replace(/%3[Aa]/g, ':')
-				.replace(/%40/g, '@')
-				.replace(/%26/g, '&')
-				.replace(/%3[Dd]/g, '=')
-				.replace(/%2[Bb]/g, '+')
-				.replace(/%24/g, '$');
-
-			const empty = () => ({});
-
-			const manifest = {
-				assets: ${s(manifest.assets)},
-				layout: ${s(manifest.layout)},
-				error: ${s(manifest.error)},
-				routes: [
-					${manifest.routes
-				.map((route) => {
-					if (route.type === 'page') {
-						const params = get_params(route.params);
-
-						return `{
-									type: 'page',
-									pattern: ${route.pattern},
-									params: ${params},
-									a: [${route.a.map(file => file && s(file)).join(', ')}],
-									b: [${route.b.map(file => file && s(file)).join(', ')}]
-								}`;
-					} else {
-						const params = get_params(route.params);
-						const load = `() => import(${s(app_relative(route.file))})`;
-
-						return `{
-									type: 'endpoint',
-									pattern: ${route.pattern},
-									params: ${params},
-									load: ${load}
-								}`;
-					}
-				})
-				.join(',\n\t\t\t\t\t')}
-				]
-			};
-
-			// this looks redundant, but the indirection allows us to access
-			// named imports without triggering Rollup's missing import detection
-			const get_hooks = hooks => ({
-				getSession: hooks.getSession || (() => ({})),
-				handle: hooks.handle || (({ request, resolve }) => resolve(request)),
-				handleError: hooks.handleError || (({ error }) => console.error(error.stack)),
-				externalFetch: hooks.externalFetch || fetch
-			});
-
-			const module_lookup = {
-				${manifest.components.map(file => `${s(file)}: () => import(${s(app_relative(file))})`)}
-			};
-
-			const metadata_lookup = ${s(metadata_lookup)};
-
-			async function load_component(file) {
-				const { entry, css, js, styles } = metadata_lookup[file];
-				return {
-					module: await module_lookup[file](),
-					entry: assets + ${s(prefix)} + entry,
-					css: css.map(dep => assets + ${s(prefix)} + dep),
-					js: js.map(dep => assets + ${s(prefix)} + dep),
-					styles
-				};
-			}
-
-			export function render(request, {
-				prerender
-			} = {}) {
-				const host = ${config.kit.host ? s(config.kit.host) : `request.headers[${s(config.kit.hostHeader || 'host')}]`};
-				return respond({ ...request, host }, options, { prerender });
-			}
-		`
-			.replace(/^\t{3}/gm, '')
-			.trim()
+		input.app,
+		template({
+			config,
+			hooks: app_relative(hooks_file),
+			runtime
+		})
 	);
 
 	/** @type {import('vite').UserConfig} */
@@ -896,11 +431,10 @@ async function build_server(
 		build: {
 			ssr: true,
 			outDir: `${output_dir}/server`,
+			manifest: true,
 			polyfillDynamicImport: false,
 			rollupOptions: {
-				input: {
-					app: app_file
-				},
+				input,
 				output: {
 					format: 'esm',
 					entryFileNames: '[name].js',
@@ -928,115 +462,163 @@ async function build_server(
 
 	print_config_conflicts(conflicts, 'kit.vite.', 'build_server');
 
-	await vite.build(merged_config);
+	const { chunks } = await create_build(merged_config);
+
+	/** @type {Record<string, string[]>} */
+	const lookup = {};
+	chunks.forEach((chunk) => {
+		if (!chunk.facadeModuleId) return;
+		const id = chunk.facadeModuleId.slice(cwd.length + 1);
+		lookup[id] = chunk.exports;
+	});
+
+	/** @type {Record<string, import('types/internal').HttpMethod[]>} */
+	const methods = {};
+	manifest_data.routes.forEach((route) => {
+		if (route.type === 'endpoint' && lookup[route.file]) {
+			methods[route.file] = lookup[route.file]
+				.map((x) => /** @type {import('types/internal').HttpMethod} */ (method_names[x]))
+				.filter(Boolean);
+		}
+	});
+
+	return {
+		chunks,
+		/** @type {import('vite').Manifest} */
+		vite_manifest: JSON.parse(fs__default.readFileSync(`${output_dir}/server/manifest.json`, 'utf-8')),
+		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 {{
- *   cwd: string;
- *   assets_base: string;
- *   config: import('types/config').ValidatedConfig
- *   manifest: import('types/internal').ManifestData
- *   build_dir: string;
- *   output_dir: string;
- *   client_entry_file: string;
- *   service_worker_entry_file: string | null;
- * }} options
- * @param {import('vite').Manifest} client_manifest
+ *
+ * @param {string} cwd
+ * @param {import('rollup').OutputChunk[]} output
+ * @param {import('types/internal').ManifestData} manifest_data
  */
-async function build_service_worker(
-	{ cwd, assets_base, config, manifest, build_dir, output_dir, service_worker_entry_file },
-	client_manifest
-) {
-	// TODO add any assets referenced in template .html file, e.g. favicon?
-	const app_files = new Set();
-	for (const key in client_manifest) {
-		const { file, css } = client_manifest[key];
-		app_files.add(file);
-		if (css) {
-			css.forEach((file) => {
-				app_files.add(file);
-			});
+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;
+	});
+
+	/** @type {Record<string, import('types/internal').HttpMethod[]>} */
+	const methods = {};
+	manifest_data.routes.forEach((route) => {
+		if (route.type === 'endpoint' && lookup[route.file]) {
+			methods[route.file] = lookup[route.file]
+				.map((x) => /** @type {import('types/internal').HttpMethod} */ (method_names[x]))
+				.filter(Boolean);
 		}
-	}
+	});
 
-	fs__default.writeFileSync(
-		`${build_dir}/runtime/service-worker.js`,
-		`
-			export const timestamp = ${Date.now()};
+	return methods;
+}
 
-			export const build = [
-				${Array.from(app_files)
-					.map((file) => `${s(`${config.kit.paths.base}/${config.kit.appDir}/${file}`)}`)
-					.join(',\n\t\t\t\t')}
-			];
+/**
+ * @param {import('types/config').ValidatedConfig} config
+ * @param {{
+ *   cwd?: string;
+ *   runtime?: string;
+ * }} [opts]
+ * @returns {Promise<import('types/internal').BuildData>}
+ */
+async function build(config, { cwd = process.cwd(), runtime = '@sveltejs/kit/ssr' } = {}) {
+	const build_dir = path__default.resolve(cwd, `${SVELTE_KIT}/build`);
 
-			export const files = [
-				${manifest.assets
-					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
-					.join(',\n\t\t\t\t')}
-			];
-		`
-			.replace(/^\t{3}/gm, '')
-			.trim()
-	);
+	rimraf(build_dir);
 
-	/** @type {import('vite').UserConfig} */
-	const vite_config = config.kit.vite();
+	const output_dir = path__default.resolve(cwd, `${SVELTE_KIT}/output`);
 
-	const default_config = {};
+	const options = {
+		cwd,
+		config,
+		build_dir,
+		// TODO this is so that Vite's preloading works. Unfortunately, it fails
+		// during `svelte-kit preview`, because we use a local asset path. If Vite
+		// used relative paths, I _think_ this could get fixed. Issue here:
+		// https://github.com/vitejs/vite/issues/2009
+		assets_base: `${config.kit.paths.assets || config.kit.paths.base}/${config.kit.appDir}/`,
+		manifest_data: create_manifest_data({
+			config,
+			output: build_dir,
+			cwd
+		}),
+		output_dir,
+		client_entry_file: `${SVELTE_KIT}/build/runtime/internal/start.js`,
+		service_worker_entry_file: resolve_entry(config.kit.files.serviceWorker),
+		service_worker_register: config.kit.serviceWorker.register
+	};
 
-	// don't warn on overriding defaults
-	const [modified_vite_config] = deep_merge(default_config, vite_config);
+	const client = await build_client(options);
+	const server = await build_server(options, runtime);
 
-	/** @type {[any, string[]]} */
-	const [merged_config, conflicts] = deep_merge(modified_vite_config, {
-		configFile: false,
-		root: cwd,
-		base: assets_base,
-		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': path__default.resolve(`${build_dir}/runtime/service-worker`),
-				$lib: config.kit.files.lib
+	const styles_lookup = new Map();
+	if (options.config.kit.amp) {
+		client.assets.forEach((asset) => {
+			if (asset.fileName.endsWith('.css')) {
+				styles_lookup.set(asset.fileName, asset.source);
 			}
-		}
+		});
+	}
+
+	mkdirp(`${output_dir}/server/nodes`);
+	options.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 styles = config.kit.amp && Array.from(css).map((file) => styles_lookup.get(file));
+
+		const node = `import * as module from '../${server.vite_manifest[component].file}';
+			export { module };
+			export const entry = '${client.vite_manifest[component].file}';
+			export const js = ${JSON.stringify(Array.from(js))};
+			export const css = ${JSON.stringify(Array.from(css))};
+			${styles ? `export const styles = ${s(styles)}` : ''}
+			`.replace(/^\t\t\t/gm, '');
+
+		writeFileSync(file, node);
 	});
 
-	print_config_conflicts(conflicts, 'kit.vite.', 'build_service_worker');
+	if (options.service_worker_entry_file) {
+		if (config.kit.paths.assets) {
+			throw new Error('Cannot use service worker alongside config.kit.paths.assets');
+		}
 
-	await vite.build(merged_config);
-}
+		await build_service_worker(options, client.vite_manifest);
+	}
+
+	const build_data = {
+		app_dir: config.kit.appDir,
+		manifest_data: options.manifest_data,
+		client,
+		server,
+		static: options.manifest_data.assets.map((asset) => posixify(asset.file)),
+		entries: options.manifest_data.routes
+			.map((route) => (route.type === 'page' ? route.path : ''))
+			.filter(Boolean)
+	};
+
+	const manifest = `export const manifest = ${generate_manifest(build_data, '.')};\n`;
+	fs__default.writeFileSync(`${output_dir}/server/manifest.js`, 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 RexExpMatchArray into ({ x, y, z })
-	return array.length
-		? '(m) => ({ ' +
-				array
-					.map((param, i) => {
-						return param.startsWith('...')
-							? `${param.slice(3)}: d(m[${i + 1}] || '')`
-							: `${param}: d(m[${i + 1}])`;
-					})
-					.join(', ') +
-				'})'
-		: 'empty';
+	return build_data;
 }
 
 export { build };