@sveltejs/kit 1.0.0-next.288 → 1.0.0-next.290

package/dist/chunks/index5.js

@@ -1,895 +1,160 @@
-import { b as SVELTE_KIT, m as mkdirp, h as rimraf, i as copy, $, j as logger } from '../cli.js';
-import { readFileSync, writeFileSync } from 'fs';
-import { resolve as resolve$1, join, dirname } from 'path';
-import { pathToFileURL, URL } from 'url';
+import fs__default from 'fs';
+import http from 'http';
+import https from 'https';
+import { join } from 'path';
+import { s as sirv, S as SVELTE_KIT_ASSETS } from './constants.js';
+import { pathToFileURL } from 'url';
+import { getRequest, setResponse } from '../node.js';
 import { installFetch } from '../install-fetch.js';
-import { g as generate_manifest } from './index4.js';
-import 'sade';
-import 'child_process';
-import 'net';
-import 'os';
+import 'querystring';
+import 'stream';
 import 'node:http';
 import 'node:https';
 import 'node:zlib';
 import 'node:stream';
 import 'node:util';
 import 'node:url';
-import './misc.js';
-
-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 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 {string} path
- * @param {import('types').TrailingSlash} trailing_slash
- */
-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' && /\/[^./]+$/.test(path)) {
-		return path + '/';
-	}
-
-	return path;
-}
-
-/** @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 });
-			});
-
-			dequeue();
-			return promise;
-		},
-
-		done: () => {
-			if (current === 0) {
-				closed = true;
-				fulfil();
-			}
-
-			return done;
-		}
-	};
-}
-
-const DOCTYPE = 'DOCTYPE';
-const CDATA_OPEN = '[CDATA[';
-const CDATA_CLOSE = ']]>';
-const COMMENT_OPEN = '--';
-const COMMENT_CLOSE = '-->';
-
-const TAG_OPEN = /[a-zA-Z]/;
-const TAG_CHAR = /[a-zA-Z0-9]/;
-const ATTRIBUTE_NAME = /[^\t\n\f />"'=]/;
-
-const WHITESPACE = /[\s\n\r]/;
-
-/** @param {string} html */
-function crawl(html) {
-	/** @type {string[]} */
-	const hrefs = [];
-
-	let i = 0;
-	main: while (i < html.length) {
-		const char = html[i];
-
-		if (char === '<') {
-			if (html[i + 1] === '!') {
-				i += 2;
-
-				if (html.substr(i, DOCTYPE.length).toUpperCase() === DOCTYPE) {
-					i += DOCTYPE.length;
-					while (i < html.length) {
-						if (html[i++] === '>') {
-							continue main;
-						}
-					}
-				}
-
-				// skip cdata
-				if (html.substr(i, CDATA_OPEN.length) === CDATA_OPEN) {
-					i += CDATA_OPEN.length;
-					while (i < html.length) {
-						if (html.substr(i, CDATA_CLOSE.length) === CDATA_CLOSE) {
-							i += CDATA_CLOSE.length;
-							continue main;
-						}
-
-						i += 1;
-					}
-				}
-
-				// skip comments
-				if (html.substr(i, COMMENT_OPEN.length) === COMMENT_OPEN) {
-					i += COMMENT_OPEN.length;
-					while (i < html.length) {
-						if (html.substr(i, COMMENT_CLOSE.length) === COMMENT_CLOSE) {
-							i += COMMENT_CLOSE.length;
-							continue main;
-						}
-
-						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.substr(i + 2, tag.length).toUpperCase() === tag
-						) {
-							continue main;
-						}
-
-						i += 1;
-					}
-				}
-
-				let href = '';
-
-				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 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;
-										}
-
-										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 (name === 'href') {
-								href = 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 {
-							i -= 1;
-						}
-					}
-
-					i += 1;
-				}
-
-				if (href) {
-					hrefs.push(href);
-				}
-			}
-		}
-
-		i += 1;
-	}
-
-	return hrefs;
-}
-
-/**
- * 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>}
- */
-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;
-		}
+import 'net';
 
-		return escape_html_attr_dict[match] ?? `&#${match.charCodeAt(0)};`;
+/** @param {string} dir */
+const mutable = (dir) =>
+	sirv(dir, {
+		etag: true,
+		maxAge: 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 {{
- *   cwd: string;
- *   out: string;
- *   log: Logger;
+ *   port: number;
+ *   host?: string;
  *   config: import('types').ValidatedConfig;
- *   build_data: import('types').BuildData;
- *   fallback?: string;
- *   all: boolean; // disregard `export const prerender = true`
+ *   https?: boolean;
+ *   cwd?: string;
  * }} opts
  */
-async function prerender({ cwd, out, log, config, build_data, fallback, all }) {
-	/** @type {import('types').Prerendered} */
-	const prerendered = {
-		pages: new Map(),
-		assets: new Map(),
-		redirects: new Map(),
-		paths: []
-	};
-
-	if (!config.kit.prerender.enabled && !fallback) {
-		return prerendered;
-	}
-
+async function preview({ port, host, config, https: use_https = false }) {
 	installFetch();
 
-	const server_root = resolve$1(cwd, `${SVELTE_KIT}/output`);
+	const index_file = join(config.kit.outDir, 'output/server/index.js');
+	const manifest_file = join(config.kit.outDir, 'output/server/manifest.js');
 
 	/** @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 { Server, override } = await import(pathToFileURL(index_file).href);
 
-	const error = normalise_error_handler(log, config.kit.prerender.onError);
+	const { manifest } = await import(pathToFileURL(manifest_file).href);
 
-	const files = new Set([
-		...build_data.static,
-		...build_data.client.chunks.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`),
-		...build_data.client.assets.map((chunk) => `${config.kit.appDir}/${chunk.fileName}`)
-	]);
+	/** @type {import('sirv').RequestHandler} */
+	const static_handler = fs__default.existsSync(config.kit.files.assets)
+		? mutable(config.kit.files.assets)
+		: (_req, _res, next) => {
+				if (!next) throw new Error('No next() handler is available');
+				return next();
+		  };
 
-	build_data.static.forEach((file) => {
-		if (file.endsWith('/index.html')) {
-			files.add(file.slice(0, -11));
-		}
+	const assets_handler = sirv(join(config.kit.outDir, 'output/client'), {
+		maxAge: 31536000,
+		immutable: true
 	});
 
-	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 + (config.kit.trailingSlash === 'always' ? '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));
-	}
-
-	/**
-	 * @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}`), {
-			prerender: {
-				all,
-				dependencies
-			}
-		});
-
-		const text = await response.text();
-
-		save(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(dependency_path, 'http://localhost').pathname;
-			const decoded_dependency_path = decodeURI(encoded_dependency_path);
-
-			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
-			save(
-				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 has_asset_path = !!config.kit.paths.assets;
 
-				const resolved = resolve(encoded, href);
-				if (!is_root_relative(resolved)) continue;
+	override({
+		paths: {
+			base: config.kit.paths.base,
+			assets: has_asset_path ? SVELTE_KIT_ASSETS : config.kit.paths.base
+		},
+		prerendering: false,
+		protocol: use_https ? 'https' : 'http',
+		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+	});
 
-				const parsed = new URL(resolved, 'http://localhost');
+	const server = new Server(manifest);
 
-				if (parsed.search) ;
+	/** @type {import('vite').UserConfig} */
+	const vite_config = (config.kit.vite && (await config.kit.vite())) || {};
 
-				const pathname = normalize_path(parsed.pathname, config.kit.trailingSlash);
-				enqueue(decoded, decodeURI(pathname), pathname);
-			}
+	const http_server = await get_server(use_https, vite_config, (req, res) => {
+		if (req.url == null) {
+			throw new Error('Invalid request url');
 		}
-	}
-
-	/**
-	 * @param {Response} response
-	 * @param {string | Uint8Array} body
-	 * @param {string} decoded
-	 * @param {string} encoded
-	 * @param {string | null} referrer
-	 * @param {'linked' | 'fetched'} referenceType
-	 */
-	function save(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 = `${out}/${file}`;
+		const initial_url = req.url;
 
-		if (written.has(file)) return;
-		written.add(file);
+		const render_handler = async () => {
+			if (initial_url.startsWith(config.kit.paths.base)) {
+				const protocol = use_https ? 'https' : 'http';
+				const host = req.headers['host'];
 
-		if (response_type === REDIRECT) {
-			const location = response.headers.get('location');
+				let request;
 
-			if (location) {
-				mkdirp(dirname(dest));
-
-				log.warn(`${response.status} ${decoded} -> ${location}`);
-
-				writeFileSync(
-					dest,
-					`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
-				);
-
-				let resolved = resolve(encoded, location);
-				if (is_root_relative(resolved)) {
-					resolved = normalize_path(resolved, config.kit.trailingSlash);
-					enqueue(decoded, decodeURI(resolved), resolved);
+				try {
+					req.url = initial_url;
+					request = await getRequest(`${protocol}://${host}`, req);
+				} catch (/** @type {any} */ err) {
+					res.statusCode = err.status || 400;
+					return res.end(err.reason || 'Invalid request body');
 				}
 
-				if (!prerendered.redirects.has(decoded)) {
-					prerendered.redirects.set(decoded, {
-						status: response.status,
-						location: resolved
-					});
-
-					prerendered.paths.push(normalize_path(decoded, 'never'));
-				}
+				setResponse(res, await server.respond(request));
 			} else {
-				log.warn(`location header missing on redirect received from ${decoded}`);
+				res.statusCode = 404;
+				res.end('Not found');
 			}
-
-			return;
-		}
-
-		if (response.status === 200) {
-			mkdirp(dirname(dest));
-
-			log.info(`${response.status} ${decoded}`);
-			writeFileSync(dest, body);
-
-			if (is_html) {
-				prerendered.pages.set(decoded, {
-					file
+		};
+
+		if (has_asset_path) {
+			if (initial_url.startsWith(SVELTE_KIT_ASSETS)) {
+				// custom assets path
+				req.url = initial_url.slice(SVELTE_KIT_ASSETS.length);
+				assets_handler(req, res, () => {
+					static_handler(req, res, render_handler);
 				});
 			} else {
-				prerendered.assets.set(decoded, {
-					type
-				});
+				render_handler();
 			}
-
-			prerendered.paths.push(normalize_path(decoded, 'never'));
-		} else if (response_type !== OK) {
-			error({ status: response.status, path: decoded, referrer, referenceType });
-		}
-	}
-
-	if (config.kit.prerender.enabled) {
-		for (const entry of config.kit.prerender.entries) {
-			if (entry === '*') {
-				for (const entry of build_data.entries) {
-					enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash)); // TODO can we pre-normalize these?
-				}
-			} else {
-				enqueue(null, normalize_path(config.kit.paths.base + entry, config.kit.trailingSlash));
+		} else {
+			if (initial_url.startsWith(config.kit.paths.base)) {
+				req.url = initial_url.slice(config.kit.paths.base.length);
 			}
+			assets_handler(req, res, () => {
+				static_handler(req, res, render_handler);
+			});
 		}
+	});
 
-		await q.done();
-	}
-
-	if (fallback) {
-		const rendered = await server.respond(new Request('http://sveltekit-prerender/[fallback]'), {
-			prerender: {
-				fallback,
-				all: false,
-				dependencies: new Map()
-			}
-		});
-
-		const file = join(out, fallback);
-		mkdirp(dirname(file));
-		writeFileSync(file, await rendered.text());
-	}
+	await http_server.listen(port, host || '0.0.0.0');
 
-	return prerendered;
+	return Promise.resolve(http_server);
 }
 
 /**
- * @param {{
- *   cwd: string;
- *   config: import('types').ValidatedConfig;
- *   build_data: import('types').BuildData;
- *   log: import('types').Logger;
- * }} opts
- * @returns {import('types').Builder}
+ * @param {boolean} use_https
+ * @param {import('vite').UserConfig} user_config
+ * @param {(req: http.IncomingMessage, res: http.ServerResponse) => void} handler
+ * @returns {Promise<import('net').Server>}
  */
-function create_builder({ cwd, config, build_data, log }) {
-	/** @type {Set<string>} */
-	let prerendered_paths;
-
-	let generated_manifest = false;
-
-	/** @param {import('types').RouteData} route */
-	function not_prerendered(route) {
-		if (!prerendered_paths) return true;
-
-		if (route.type === 'page' && route.path) {
-			return !prerendered_paths.has(route.path);
+async function get_server(use_https, user_config, handler) {
+	/** @type {https.ServerOptions} */
+	const https_options = {};
+
+	if (use_https) {
+		const secure_opts = user_config.server
+			? /** @type {import('tls').SecureContextOptions} */ (user_config.server.https)
+			: {};
+
+		if (secure_opts.key && secure_opts.cert) {
+			https_options.key = secure_opts.key.toString();
+			https_options.cert = secure_opts.cert.toString();
+		} else {
+			https_options.key = https_options.cert = (await import('./cert.js')).createCertificate();
 		}
-
-		return true;
 	}
 
-	return {
-		log,
-		rimraf,
-		mkdirp,
-		copy,
-
-		appDir: config.kit.appDir,
-		trailingSlash: config.kit.trailingSlash,
-
-		createEntries(fn) {
-			generated_manifest = true;
-
-			const { routes } = build_data.manifest_data;
-
-			/** @type {import('types').RouteDefinition[]} */
-			const facades = routes.map((route) => ({
-				type: route.type,
-				segments: route.segments,
-				pattern: route.pattern,
-				methods: route.type === 'page' ? ['get'] : build_data.server.methods[route.file]
-			}));
-
-			const seen = new Set();
-
-			for (let i = 0; i < routes.length; i += 1) {
-				const route = routes[i];
-				const { id, filter, complete } = fn(facades[i]);
-
-				if (seen.has(id)) continue;
-				seen.add(id);
-
-				const group = [route];
-
-				// figure out which lower priority routes should be considered fallbacks
-				for (let j = i + 1; j < routes.length; j += 1) {
-					if (filter(facades[j])) {
-						group.push(routes[j]);
-					}
-				}
-
-				const filtered = new Set(group.filter(not_prerendered));
-
-				// heuristic: if /foo/[bar] is included, /foo/[bar].json should
-				// also be included, since the page likely needs the endpoint
-				filtered.forEach((route) => {
-					if (route.type === 'page') {
-						const length = route.segments.length;
-
-						const endpoint = routes.find((candidate) => {
-							if (candidate.segments.length !== length) return false;
-
-							for (let i = 0; i < length; i += 1) {
-								const a = route.segments[i];
-								const b = candidate.segments[i];
-
-								if (i === length - 1) {
-									return b.content === `${a.content}.json`;
-								}
-
-								if (a.content !== b.content) return false;
-							}
-						});
-
-						if (endpoint) {
-							filtered.add(endpoint);
-						}
-					}
-				});
-
-				if (filtered.size > 0) {
-					complete({
-						generateManifest: ({ relativePath, format }) =>
-							generate_manifest(build_data, relativePath, Array.from(filtered), format)
-					});
-				}
-			}
-		},
-
-		generateManifest: ({ relativePath, format }) => {
-			generated_manifest = true;
-			return generate_manifest(
-				build_data,
-				relativePath,
-				build_data.manifest_data.routes.filter(not_prerendered),
-				format
-			);
-		},
-
-		getBuildDirectory(name) {
-			return `${cwd}/${SVELTE_KIT}/${name}`;
-		},
-
-		getClientDirectory() {
-			return `${cwd}/${SVELTE_KIT}/output/client`;
-		},
-
-		getServerDirectory() {
-			return `${cwd}/${SVELTE_KIT}/output/server`;
-		},
-
-		getStaticDirectory() {
-			return config.kit.files.assets;
-		},
-
-		writeClient(dest) {
-			return copy(`${cwd}/${SVELTE_KIT}/output/client`, dest, {
-				filter: (file) => file[0] !== '.'
-			});
-		},
-
-		writeServer(dest) {
-			return copy(`${cwd}/${SVELTE_KIT}/output/server`, dest, {
-				filter: (file) => file[0] !== '.'
-			});
-		},
-
-		writeStatic(dest) {
-			return copy(config.kit.files.assets, dest);
-		},
-
-		async prerender({ all = false, dest, fallback }) {
-			if (generated_manifest) {
-				throw new Error(
-					'Adapters must call prerender(...) before createEntries(...) or generateManifest(...)'
-				);
-			}
-
-			const prerendered = await prerender({
-				out: dest,
-				all,
-				cwd,
-				config,
-				build_data,
-				fallback,
-				log
-			});
-
-			prerendered_paths = new Set(prerendered.paths);
-
-			return prerendered;
-		}
-	};
-}
-
-/**
- * @param {import('types').ValidatedConfig} config
- * @param {import('types').BuildData} build_data
- * @param {{ cwd?: string, verbose: boolean }} opts
- */
-async function adapt(config, build_data, { cwd = process.cwd(), verbose }) {
-	const { name, adapt } = config.kit.adapter;
-
-	console.log($.bold().cyan(`\n> Using ${name}`));
-
-	const log = logger({ verbose });
-	const builder = create_builder({ cwd, config, build_data, log });
-	await adapt(builder);
-
-	log.success('done');
+	return Promise.resolve(
+		use_https
+			? https.createServer(/** @type {https.ServerOptions} */ (https_options), handler)
+			: http.createServer(handler)
+	);
 }
 
-export { adapt };
+export { preview };