@sveltejs/kit 1.0.0-next.24 → 1.0.0-next.240

package/dist/chunks/index.js

@@ -0,0 +1,2202 @@
+import path__default from 'path';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+import vite from 'vite';
+import { c as create_manifest_data, a as create_app, d as deep_merge } from './index2.js';
+import { c as coalesce_to_error, S as SVELTE_KIT_ASSETS, r as resolve_entry, $, a as SVELTE_KIT, b as runtime, l as load_template, g as get_mime_lookup, d as copy_assets, e as get_aliases, p as print_config_conflicts } from '../cli.js';
+import fs__default from 'fs';
+import { URL as URL$1 } from 'url';
+import { s as sirv } from './build.js';
+import { e as escape_html_attr, r as resolve, i as is_root_relative, a as escape_json_string_in_html } from './url.js';
+import { s } from './misc.js';
+import { __fetch_polyfill } from '../install-fetch.js';
+import { getRequest, setResponse } from '../node.js';
+import 'sade';
+import 'child_process';
+import 'net';
+import 'os';
+import 'querystring';
+import 'node:http';
+import 'node:https';
+import 'node:zlib';
+import 'node:stream';
+import 'node:util';
+import 'node:url';
+import 'stream';
+
+/** @param {Partial<import('types/helper').ResponseHeaders> | undefined} object */
+function to_headers(object) {
+	const headers = new Headers();
+
+	if (object) {
+		for (const key in object) {
+			const value = object[key];
+			if (!value) continue;
+
+			if (typeof value === 'string') {
+				headers.set(key, value);
+			} else {
+				value.forEach((value) => {
+					headers.append(key, value);
+				});
+			}
+		}
+	}
+
+	return headers;
+}
+
+/**
+ * Hash using djb2
+ * @param {import('types/hooks').StrictBody} value
+ */
+function hash(value) {
+	let hash = 5381;
+	let i = value.length;
+
+	if (typeof value === 'string') {
+		while (i) hash = (hash * 33) ^ value.charCodeAt(--i);
+	} else {
+		while (i) hash = (hash * 33) ^ value[--i];
+	}
+
+	return (hash >>> 0).toString(36);
+}
+
+/** @param {Record<string, any>} obj */
+
+/** @param {Record<string, string>} params */
+function decode_params(params) {
+	for (const key in params) {
+		// input has already been decoded by decodeURI
+		// now handle the rest that decodeURIComponent would do
+		params[key] = params[key]
+			.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, '$');
+	}
+
+	return params;
+}
+
+/** @param {string} body */
+function error(body) {
+	return new Response(body, {
+		status: 500
+	});
+}
+
+/** @param {unknown} s */
+function is_string(s) {
+	return typeof s === 'string' || s instanceof String;
+}
+
+const text_types = new Set([
+	'application/xml',
+	'application/json',
+	'application/x-www-form-urlencoded',
+	'multipart/form-data'
+]);
+
+/**
+ * Decides how the body should be parsed based on its mime type. Should match what's in parse_body
+ *
+ * @param {string | undefined | null} content_type The `content-type` header of a request/response.
+ * @returns {boolean}
+ */
+function is_text(content_type) {
+	if (!content_type) return true; // defaults to json
+	const type = content_type.split(';')[0].toLowerCase(); // get the mime type
+
+	return type.startsWith('text/') || type.endsWith('+xml') || text_types.has(type);
+}
+
+/**
+ * @param {import('types/hooks').RequestEvent} event
+ * @param {import('types/internal').SSREndpoint} route
+ * @param {RegExpExecArray} match
+ * @returns {Promise<Response | undefined>}
+ */
+async function render_endpoint(event, route, match) {
+	const mod = await route.load();
+
+	/** @type {import('types/endpoint').RequestHandler} */
+	const handler = mod[event.request.method.toLowerCase().replace('delete', 'del')]; // 'delete' is a reserved word
+
+	if (!handler) {
+		return;
+	}
+
+	// we're mutating `request` so that we don't have to do { ...request, params }
+	// on the next line, since that breaks the getters that replace path, query and
+	// origin. We could revert that once we remove the getters
+	event.params = route.params ? decode_params(route.params(match)) : {};
+
+	const response = await handler(event);
+	const preface = `Invalid response from route ${event.url.pathname}`;
+
+	if (typeof response !== 'object') {
+		return error(`${preface}: expected an object, got ${typeof response}`);
+	}
+
+	if (response.fallthrough) {
+		return;
+	}
+
+	const { status = 200, body = {} } = response;
+	const headers =
+		response.headers instanceof Headers ? response.headers : to_headers(response.headers);
+
+	const type = headers.get('content-type');
+
+	if (!is_text(type) && !(body instanceof Uint8Array || is_string(body))) {
+		return error(
+			`${preface}: body must be an instance of string or Uint8Array if content-type is not a supported textual content-type`
+		);
+	}
+
+	/** @type {import('types/hooks').StrictBody} */
+	let normalized_body;
+
+	if (is_pojo(body) && (!type || type.startsWith('application/json'))) {
+		headers.set('content-type', 'application/json; charset=utf-8');
+		normalized_body = JSON.stringify(body);
+	} else {
+		normalized_body = /** @type {import('types/hooks').StrictBody} */ (body);
+	}
+
+	if (
+		(typeof normalized_body === 'string' || normalized_body instanceof Uint8Array) &&
+		!headers.has('etag')
+	) {
+		const cache_control = headers.get('cache-control');
+		if (!cache_control || !/(no-store|immutable)/.test(cache_control)) {
+			headers.set('etag', `"${hash(normalized_body)}"`);
+		}
+	}
+
+	return new Response(normalized_body, {
+		status,
+		headers
+	});
+}
+
+/** @param {any} body */
+function is_pojo(body) {
+	if (typeof body !== 'object') return false;
+
+	if (body) {
+		if (body instanceof Uint8Array) return false;
+
+		// body could be a node Readable, but we don't want to import
+		// node built-ins, so we use duck typing
+		if (body._readableState && body._writableState && body._events) return false;
+
+		// similarly, it could be a web ReadableStream
+		if (body[Symbol.toStringTag] === 'ReadableStream') return false;
+	}
+
+	return true;
+}
+
+var chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+var unsafeChars = /[<>\b\f\n\r\t\0\u2028\u2029]/g;
+var reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
+var escaped = {
+    '<': '\\u003C',
+    '>': '\\u003E',
+    '/': '\\u002F',
+    '\\': '\\\\',
+    '\b': '\\b',
+    '\f': '\\f',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+    '\0': '\\0',
+    '\u2028': '\\u2028',
+    '\u2029': '\\u2029'
+};
+var objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join('\0');
+function devalue(value) {
+    var counts = new Map();
+    function walk(thing) {
+        if (typeof thing === 'function') {
+            throw new Error("Cannot stringify a function");
+        }
+        if (counts.has(thing)) {
+            counts.set(thing, counts.get(thing) + 1);
+            return;
+        }
+        counts.set(thing, 1);
+        if (!isPrimitive(thing)) {
+            var type = getType(thing);
+            switch (type) {
+                case 'Number':
+                case 'String':
+                case 'Boolean':
+                case 'Date':
+                case 'RegExp':
+                    return;
+                case 'Array':
+                    thing.forEach(walk);
+                    break;
+                case 'Set':
+                case 'Map':
+                    Array.from(thing).forEach(walk);
+                    break;
+                default:
+                    var proto = Object.getPrototypeOf(thing);
+                    if (proto !== Object.prototype &&
+                        proto !== null &&
+                        Object.getOwnPropertyNames(proto).sort().join('\0') !== objectProtoOwnPropertyNames) {
+                        throw new Error("Cannot stringify arbitrary non-POJOs");
+                    }
+                    if (Object.getOwnPropertySymbols(thing).length > 0) {
+                        throw new Error("Cannot stringify POJOs with symbolic keys");
+                    }
+                    Object.keys(thing).forEach(function (key) { return walk(thing[key]); });
+            }
+        }
+    }
+    walk(value);
+    var names = new Map();
+    Array.from(counts)
+        .filter(function (entry) { return entry[1] > 1; })
+        .sort(function (a, b) { return b[1] - a[1]; })
+        .forEach(function (entry, i) {
+        names.set(entry[0], getName(i));
+    });
+    function stringify(thing) {
+        if (names.has(thing)) {
+            return names.get(thing);
+        }
+        if (isPrimitive(thing)) {
+            return stringifyPrimitive(thing);
+        }
+        var type = getType(thing);
+        switch (type) {
+            case 'Number':
+            case 'String':
+            case 'Boolean':
+                return "Object(" + stringify(thing.valueOf()) + ")";
+            case 'RegExp':
+                return "new RegExp(" + stringifyString(thing.source) + ", \"" + thing.flags + "\")";
+            case 'Date':
+                return "new Date(" + thing.getTime() + ")";
+            case 'Array':
+                var members = thing.map(function (v, i) { return i in thing ? stringify(v) : ''; });
+                var tail = thing.length === 0 || (thing.length - 1 in thing) ? '' : ',';
+                return "[" + members.join(',') + tail + "]";
+            case 'Set':
+            case 'Map':
+                return "new " + type + "([" + Array.from(thing).map(stringify).join(',') + "])";
+            default:
+                var obj = "{" + Object.keys(thing).map(function (key) { return safeKey(key) + ":" + stringify(thing[key]); }).join(',') + "}";
+                var proto = Object.getPrototypeOf(thing);
+                if (proto === null) {
+                    return Object.keys(thing).length > 0
+                        ? "Object.assign(Object.create(null)," + obj + ")"
+                        : "Object.create(null)";
+                }
+                return obj;
+        }
+    }
+    var str = stringify(value);
+    if (names.size) {
+        var params_1 = [];
+        var statements_1 = [];
+        var values_1 = [];
+        names.forEach(function (name, thing) {
+            params_1.push(name);
+            if (isPrimitive(thing)) {
+                values_1.push(stringifyPrimitive(thing));
+                return;
+            }
+            var type = getType(thing);
+            switch (type) {
+                case 'Number':
+                case 'String':
+                case 'Boolean':
+                    values_1.push("Object(" + stringify(thing.valueOf()) + ")");
+                    break;
+                case 'RegExp':
+                    values_1.push(thing.toString());
+                    break;
+                case 'Date':
+                    values_1.push("new Date(" + thing.getTime() + ")");
+                    break;
+                case 'Array':
+                    values_1.push("Array(" + thing.length + ")");
+                    thing.forEach(function (v, i) {
+                        statements_1.push(name + "[" + i + "]=" + stringify(v));
+                    });
+                    break;
+                case 'Set':
+                    values_1.push("new Set");
+                    statements_1.push(name + "." + Array.from(thing).map(function (v) { return "add(" + stringify(v) + ")"; }).join('.'));
+                    break;
+                case 'Map':
+                    values_1.push("new Map");
+                    statements_1.push(name + "." + Array.from(thing).map(function (_a) {
+                        var k = _a[0], v = _a[1];
+                        return "set(" + stringify(k) + ", " + stringify(v) + ")";
+                    }).join('.'));
+                    break;
+                default:
+                    values_1.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
+                    Object.keys(thing).forEach(function (key) {
+                        statements_1.push("" + name + safeProp(key) + "=" + stringify(thing[key]));
+                    });
+            }
+        });
+        statements_1.push("return " + str);
+        return "(function(" + params_1.join(',') + "){" + statements_1.join(';') + "}(" + values_1.join(',') + "))";
+    }
+    else {
+        return str;
+    }
+}
+function getName(num) {
+    var name = '';
+    do {
+        name = chars[num % chars.length] + name;
+        num = ~~(num / chars.length) - 1;
+    } while (num >= 0);
+    return reserved.test(name) ? name + "_" : name;
+}
+function isPrimitive(thing) {
+    return Object(thing) !== thing;
+}
+function stringifyPrimitive(thing) {
+    if (typeof thing === 'string')
+        return stringifyString(thing);
+    if (thing === void 0)
+        return 'void 0';
+    if (thing === 0 && 1 / thing < 0)
+        return '-0';
+    var str = String(thing);
+    if (typeof thing === 'number')
+        return str.replace(/^(-)?0\./, '$1.');
+    return str;
+}
+function getType(thing) {
+    return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function escapeUnsafeChar(c) {
+    return escaped[c] || c;
+}
+function escapeUnsafeChars(str) {
+    return str.replace(unsafeChars, escapeUnsafeChar);
+}
+function safeKey(key) {
+    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
+}
+function safeProp(key) {
+    return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? "." + key : "[" + escapeUnsafeChars(JSON.stringify(key)) + "]";
+}
+function stringifyString(str) {
+    var result = '"';
+    for (var i = 0; i < str.length; i += 1) {
+        var char = str.charAt(i);
+        var code = char.charCodeAt(0);
+        if (char === '"') {
+            result += '\\"';
+        }
+        else if (char in escaped) {
+            result += escaped[char];
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            var next = str.charCodeAt(i + 1);
+            // If this is the beginning of a [high, low] surrogate pair,
+            // add the next two characters, otherwise escape
+            if (code <= 0xdbff && (next >= 0xdc00 && next <= 0xdfff)) {
+                result += char + str[++i];
+            }
+            else {
+                result += "\\u" + code.toString(16).toUpperCase();
+            }
+        }
+        else {
+            result += char;
+        }
+    }
+    result += '"';
+    return result;
+}
+
+function noop() { }
+function safe_not_equal(a, b) {
+    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
+}
+Promise.resolve();
+
+const subscriber_queue = [];
+/**
+ * Create a `Writable` store that allows both updating and reading by subscription.
+ * @param {*=}value initial value
+ * @param {StartStopNotifier=}start start and stop notifications for subscriptions
+ */
+function writable(value, start = noop) {
+    let stop;
+    const subscribers = new Set();
+    function set(new_value) {
+        if (safe_not_equal(value, new_value)) {
+            value = new_value;
+            if (stop) { // store is ready
+                const run_queue = !subscriber_queue.length;
+                for (const subscriber of subscribers) {
+                    subscriber[1]();
+                    subscriber_queue.push(subscriber, value);
+                }
+                if (run_queue) {
+                    for (let i = 0; i < subscriber_queue.length; i += 2) {
+                        subscriber_queue[i][0](subscriber_queue[i + 1]);
+                    }
+                    subscriber_queue.length = 0;
+                }
+            }
+        }
+    }
+    function update(fn) {
+        set(fn(value));
+    }
+    function subscribe(run, invalidate = noop) {
+        const subscriber = [run, invalidate];
+        subscribers.add(subscriber);
+        if (subscribers.size === 1) {
+            stop = start(set) || noop;
+        }
+        run(value);
+        return () => {
+            subscribers.delete(subscriber);
+            if (subscribers.size === 0) {
+                stop();
+                stop = null;
+            }
+        };
+    }
+    return { set, update, subscribe };
+}
+
+/** @param {URL} url */
+function create_prerendering_url_proxy(url) {
+	return new Proxy(url, {
+		get: (target, prop, receiver) => {
+			if (prop === 'search' || prop === 'searchParams') {
+				throw new Error(`Cannot access url.${prop} on a page with prerendering enabled`);
+			}
+			return Reflect.get(target, prop, receiver);
+		}
+	});
+}
+
+// TODO rename this function/module
+
+/**
+ * @param {{
+ *   branch: Array<import('./types').Loaded>;
+ *   options: import('types/internal').SSRRenderOptions;
+ *   state: import('types/internal').SSRRenderState;
+ *   $session: any;
+ *   page_config: { hydrate: boolean, router: boolean };
+ *   status: number;
+ *   error?: Error;
+ *   url: URL;
+ *   params: Record<string, string>;
+ *   ssr: boolean;
+ *   stuff: Record<string, any>;
+ * }} opts
+ */
+async function render_response({
+	branch,
+	options,
+	state,
+	$session,
+	page_config,
+	status,
+	error,
+	url,
+	params,
+	ssr,
+	stuff
+}) {
+	const css = new Set(options.manifest._.entry.css);
+	const js = new Set(options.manifest._.entry.js);
+	/** @type {Map<string, string>} */
+	const styles = new Map();
+
+	/** @type {Array<{ url: string, body: string, json: string }>} */
+	const serialized_data = [];
+
+	let rendered;
+
+	let is_private = false;
+	let maxage;
+
+	if (error) {
+		error.stack = options.get_stack(error);
+	}
+
+	if (ssr) {
+		branch.forEach(({ node, loaded, fetched, uses_credentials }) => {
+			if (node.css) node.css.forEach((url) => css.add(url));
+			if (node.js) node.js.forEach((url) => js.add(url));
+			if (node.styles) Object.entries(node.styles).forEach(([k, v]) => styles.set(k, v));
+
+			// TODO probably better if `fetched` wasn't populated unless `hydrate`
+			if (fetched && page_config.hydrate) serialized_data.push(...fetched);
+
+			if (uses_credentials) is_private = true;
+
+			maxage = loaded.maxage;
+		});
+
+		const session = writable($session);
+
+		/** @type {Record<string, any>} */
+		const props = {
+			stores: {
+				page: writable(null),
+				navigating: writable(null),
+				session
+			},
+			page: {
+				url: state.prerender ? create_prerendering_url_proxy(url) : url,
+				params,
+				status,
+				error,
+				stuff
+			},
+			components: branch.map(({ node }) => node.module.default)
+		};
+
+		// TODO remove this for 1.0
+		/**
+		 * @param {string} property
+		 * @param {string} replacement
+		 */
+		const print_error = (property, replacement) => {
+			Object.defineProperty(props.page, property, {
+				get: () => {
+					throw new Error(`$page.${property} has been replaced by $page.url.${replacement}`);
+				}
+			});
+		};
+
+		print_error('origin', 'origin');
+		print_error('path', 'pathname');
+		print_error('query', 'searchParams');
+
+		// props_n (instead of props[n]) makes it easy to avoid
+		// unnecessary updates for layout components
+		for (let i = 0; i < branch.length; i += 1) {
+			props[`props_${i}`] = await branch[i].loaded.props;
+		}
+
+		let session_tracking_active = false;
+		const unsubscribe = session.subscribe(() => {
+			if (session_tracking_active) is_private = true;
+		});
+		session_tracking_active = true;
+
+		try {
+			rendered = options.root.render(props);
+		} finally {
+			unsubscribe();
+		}
+	} else {
+		rendered = { head: '', html: '', css: { code: '', map: null } };
+	}
+
+	let { head, html: body } = rendered;
+
+	const inlined_style = Array.from(styles.values()).join('\n');
+
+	if (state.prerender) {
+		if (maxage) {
+			head += `<meta http-equiv="cache-control" content="max-age=${maxage}">`;
+		}
+	}
+
+	if (options.amp) {
+		head += `
+		<style amp-boilerplate>body{-webkit-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-moz-animation:-amp-start 8s steps(1,end) 0s 1 normal both;-ms-animation:-amp-start 8s steps(1,end) 0s 1 normal both;animation:-amp-start 8s steps(1,end) 0s 1 normal both}@-webkit-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-moz-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-ms-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@-o-keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}@keyframes -amp-start{from{visibility:hidden}to{visibility:visible}}</style>
+		<noscript><style amp-boilerplate>body{-webkit-animation:none;-moz-animation:none;-ms-animation:none;animation:none}</style></noscript>
+		<script async src="https://cdn.ampproject.org/v0.js"></script>
+
+		<style amp-custom>${inlined_style}\n${rendered.css.code}</style>`;
+
+		if (options.service_worker) {
+			head +=
+				'<script async custom-element="amp-install-serviceworker" src="https://cdn.ampproject.org/v0/amp-install-serviceworker-0.1.js"></script>';
+
+			body += `<amp-install-serviceworker src="${options.service_worker}" layout="nodisplay"></amp-install-serviceworker>`;
+		}
+	} else {
+		if (inlined_style) {
+			head += `\n\t<style${options.dev ? ' data-svelte' : ''}>${inlined_style}</style>`;
+		}
+		// prettier-ignore
+		head += Array.from(css)
+			.map((dep) => `\n\t<link${styles.has(dep) ? ' disabled media="(max-width: 0)"' : ''} rel="stylesheet" href="${options.prefix + dep}">`)
+			.join('');
+
+		if (page_config.router || page_config.hydrate) {
+			head += Array.from(js)
+				.map((dep) => `\n\t<link rel="modulepreload" href="${options.prefix + dep}">`)
+				.join('');
+			// prettier-ignore
+			head += `
+			<script type="module">
+				import { start } from ${s(options.prefix + options.manifest._.entry.file)};
+				start({
+					target: ${options.target ? `document.querySelector(${s(options.target)})` : 'document.body'},
+					paths: ${s(options.paths)},
+					session: ${try_serialize($session, (error) => {
+						throw new Error(`Failed to serialize session data: ${error.message}`);
+					})},
+					route: ${!!page_config.router},
+					spa: ${!ssr},
+					trailing_slash: ${s(options.trailing_slash)},
+					hydrate: ${ssr && page_config.hydrate ? `{
+						status: ${status},
+						error: ${serialize_error(error)},
+						nodes: [
+							${(branch || [])
+							.map(({ node }) => `import(${s(options.prefix + node.entry)})`)
+							.join(',\n\t\t\t\t\t\t')}
+						],
+						url: new URL(${s(url.href)}),
+						params: ${devalue(params)}
+					}` : 'null'}
+				});
+			</script>`;
+
+			body += serialized_data
+				.map(({ url, body, json }) => {
+					let attributes = `type="application/json" data-type="svelte-data" data-url=${escape_html_attr(
+						url
+					)}`;
+					if (body) attributes += ` data-body="${hash(body)}"`;
+
+					return `<script ${attributes}>${json}</script>`;
+				})
+				.join('\n\n\t');
+		}
+
+		if (options.service_worker) {
+			// always include service worker unless it's turned off explicitly
+			head += `
+			<script>
+				if ('serviceWorker' in navigator) {
+					navigator.serviceWorker.register('${options.service_worker}');
+				}
+			</script>`;
+		}
+	}
+
+	const segments = url.pathname.slice(options.paths.base.length).split('/').slice(2);
+	const assets =
+		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
+
+	const html = options.template({ head, body, assets });
+
+	const headers = new Headers({
+		'content-type': 'text/html',
+		etag: `"${hash(html)}"`
+	});
+
+	if (maxage) {
+		headers.set('cache-control', `${is_private ? 'private' : 'public'}, max-age=${maxage}`);
+	}
+
+	if (!options.floc) {
+		headers.set('permissions-policy', 'interest-cohort=()');
+	}
+
+	return new Response(html, {
+		status,
+		headers
+	});
+}
+
+/**
+ * @param {any} data
+ * @param {(error: Error) => void} [fail]
+ */
+function try_serialize(data, fail) {
+	try {
+		return devalue(data);
+	} catch (err) {
+		if (fail) fail(coalesce_to_error(err));
+		return null;
+	}
+}
+
+// Ensure we return something truthy so the client will not re-render the page over the error
+
+/** @param {(Error & {frame?: string} & {loc?: object}) | undefined | null} error */
+function serialize_error(error) {
+	if (!error) return null;
+	let serialized = try_serialize(error);
+	if (!serialized) {
+		const { name, message, stack } = error;
+		serialized = try_serialize({ ...error, name, message, stack });
+	}
+	if (!serialized) {
+		serialized = '{}';
+	}
+	return serialized;
+}
+
+/**
+ * @param {import('types/page').LoadOutput} loaded
+ * @returns {import('types/internal').NormalizedLoadOutput}
+ */
+function normalize(loaded) {
+	const has_error_status =
+		loaded.status && loaded.status >= 400 && loaded.status <= 599 && !loaded.redirect;
+	if (loaded.error || has_error_status) {
+		const status = loaded.status;
+
+		if (!loaded.error && has_error_status) {
+			return {
+				status: status || 500,
+				error: new Error()
+			};
+		}
+
+		const error = typeof loaded.error === 'string' ? new Error(loaded.error) : loaded.error;
+
+		if (!(error instanceof Error)) {
+			return {
+				status: 500,
+				error: new Error(
+					`"error" property returned from load() must be a string or instance of Error, received type "${typeof error}"`
+				)
+			};
+		}
+
+		if (!status || status < 400 || status > 599) {
+			console.warn('"error" returned from load() without a valid status code — defaulting to 500');
+			return { status: 500, error };
+		}
+
+		return { status, error };
+	}
+
+	if (loaded.redirect) {
+		if (!loaded.status || Math.floor(loaded.status / 100) !== 3) {
+			return {
+				status: 500,
+				error: new Error(
+					'"redirect" property returned from load() must be accompanied by a 3xx status code'
+				)
+			};
+		}
+
+		if (typeof loaded.redirect !== 'string') {
+			return {
+				status: 500,
+				error: new Error('"redirect" property returned from load() must be a string')
+			};
+		}
+	}
+
+	// TODO remove before 1.0
+	if (/** @type {any} */ (loaded).context) {
+		throw new Error(
+			'You are returning "context" from a load function. ' +
+				'"context" was renamed to "stuff", please adjust your code accordingly.'
+		);
+	}
+
+	return /** @type {import('types/internal').NormalizedLoadOutput} */ (loaded);
+}
+
+/**
+ * @param {{
+ *   event: import('types/hooks').RequestEvent;
+ *   options: import('types/internal').SSRRenderOptions;
+ *   state: import('types/internal').SSRRenderState;
+ *   route: import('types/internal').SSRPage | null;
+ *   url: URL;
+ *   params: Record<string, string>;
+ *   node: import('types/internal').SSRNode;
+ *   $session: any;
+ *   stuff: Record<string, any>;
+ *   is_error: boolean;
+ *   status?: number;
+ *   error?: Error;
+ * }} opts
+ * @returns {Promise<import('./types').Loaded | undefined>} undefined for fallthrough
+ */
+async function load_node({
+	event,
+	options,
+	state,
+	route,
+	url,
+	params,
+	node,
+	$session,
+	stuff,
+	is_error,
+	status,
+	error
+}) {
+	const { module } = node;
+
+	let uses_credentials = false;
+
+	/**
+	 * @type {Array<{
+	 *   url: string;
+	 *   body: string;
+	 *   json: string;
+	 * }>}
+	 */
+	const fetched = [];
+
+	/**
+	 * @type {string[]}
+	 */
+	let set_cookie_headers = [];
+
+	let loaded;
+
+	if (module.load) {
+		/** @type {import('types/page').LoadInput | import('types/page').ErrorLoadInput} */
+		const load_input = {
+			url: state.prerender ? create_prerendering_url_proxy(url) : url,
+			params,
+			get session() {
+				uses_credentials = true;
+				return $session;
+			},
+			/**
+			 * @param {RequestInfo} resource
+			 * @param {RequestInit} opts
+			 */
+			fetch: async (resource, opts = {}) => {
+				/** @type {string} */
+				let requested;
+
+				if (typeof resource === 'string') {
+					requested = resource;
+				} else {
+					requested = resource.url;
+
+					opts = {
+						method: resource.method,
+						headers: resource.headers,
+						body: resource.body,
+						mode: resource.mode,
+						credentials: resource.credentials,
+						cache: resource.cache,
+						redirect: resource.redirect,
+						referrer: resource.referrer,
+						integrity: resource.integrity,
+						...opts
+					};
+				}
+
+				opts.headers = new Headers(opts.headers);
+
+				const resolved = resolve(event.url.pathname, requested.split('?')[0]);
+
+				let response;
+
+				// handle fetch requests for static assets. e.g. prebaked data, etc.
+				// we need to support everything the browser's fetch supports
+				const prefix = options.paths.assets || options.paths.base;
+				const filename = (
+					resolved.startsWith(prefix) ? resolved.slice(prefix.length) : resolved
+				).slice(1);
+				const filename_html = `${filename}/index.html`; // path may also match path/index.html
+
+				const is_asset = options.manifest.assets.has(filename);
+				const is_asset_html = options.manifest.assets.has(filename_html);
+
+				if (is_asset || is_asset_html) {
+					const file = is_asset ? filename : filename_html;
+
+					if (options.read) {
+						const type = is_asset
+							? options.manifest._.mime[filename.slice(filename.lastIndexOf('.'))]
+							: 'text/html';
+
+						response = new Response(options.read(file), {
+							headers: type ? { 'content-type': type } : {}
+						});
+					} else {
+						response = await fetch(`${url.origin}/${file}`, /** @type {RequestInit} */ (opts));
+					}
+				} else if (is_root_relative(resolved)) {
+					const relative = resolved;
+
+					// TODO: fix type https://github.com/node-fetch/node-fetch/issues/1113
+					if (opts.credentials !== 'omit') {
+						uses_credentials = true;
+
+						const cookie = event.request.headers.get('cookie');
+						const authorization = event.request.headers.get('authorization');
+
+						if (cookie) {
+							opts.headers.set('cookie', cookie);
+						}
+
+						if (authorization && !opts.headers.has('authorization')) {
+							opts.headers.set('authorization', authorization);
+						}
+					}
+
+					if (opts.body && typeof opts.body !== 'string') {
+						// per https://developer.mozilla.org/en-US/docs/Web/API/Request/Request, this can be a
+						// Blob, BufferSource, FormData, URLSearchParams, USVString, or ReadableStream object.
+						// non-string bodies are irksome to deal with, but luckily aren't particularly useful
+						// in this context anyway, so we take the easy route and ban them
+						throw new Error('Request body must be a string');
+					}
+
+					const rendered = await respond(
+						new Request(new URL(requested, event.url).href, opts),
+						options,
+						{
+							fetched: requested,
+							initiator: route
+						}
+					);
+
+					if (rendered) {
+						if (state.prerender) {
+							state.prerender.dependencies.set(relative, rendered);
+						}
+
+						response = rendered;
+					} else {
+						// we can't load the endpoint from our own manifest,
+						// so we need to make an actual HTTP request
+						return fetch(new URL(requested, event.url).href, {
+							method: opts.method || 'GET',
+							headers: opts.headers
+						});
+					}
+				} else {
+					// external
+					if (resolved.startsWith('//')) {
+						throw new Error(
+							`Cannot request protocol-relative URL (${requested}) in server-side fetch`
+						);
+					}
+
+					// external fetch
+					// allow cookie passthrough for "same-origin"
+					// if SvelteKit is serving my.domain.com:
+					// -        domain.com WILL NOT receive cookies
+					// -     my.domain.com WILL receive cookies
+					// -    api.domain.dom WILL NOT receive cookies
+					// - sub.my.domain.com WILL receive cookies
+					// ports do not affect the resolution
+					// leading dot prevents mydomain.com matching domain.com
+					if (
+						`.${new URL(requested).hostname}`.endsWith(`.${event.url.hostname}`) &&
+						opts.credentials !== 'omit'
+					) {
+						uses_credentials = true;
+
+						const cookie = event.request.headers.get('cookie');
+						if (cookie) opts.headers.set('cookie', cookie);
+					}
+
+					const external_request = new Request(requested, /** @type {RequestInit} */ (opts));
+					response = await options.hooks.externalFetch.call(null, external_request);
+				}
+
+				if (response) {
+					const proxy = new Proxy(response, {
+						get(response, key, _receiver) {
+							async function text() {
+								const body = await response.text();
+
+								/** @type {import('types/helper').ResponseHeaders} */
+								const headers = {};
+								for (const [key, value] of response.headers) {
+									if (key === 'set-cookie') {
+										set_cookie_headers = set_cookie_headers.concat(value);
+									} else if (key !== 'etag') {
+										headers[key] = value;
+									}
+								}
+
+								if (!opts.body || typeof opts.body === 'string') {
+									// prettier-ignore
+									fetched.push({
+										url: requested,
+										body: /** @type {string} */ (opts.body),
+										json: `{"status":${response.status},"statusText":${s(response.statusText)},"headers":${s(headers)},"body":"${escape_json_string_in_html(body)}"}`
+									});
+								}
+
+								return body;
+							}
+
+							if (key === 'text') {
+								return text;
+							}
+
+							if (key === 'json') {
+								return async () => {
+									return JSON.parse(await text());
+								};
+							}
+
+							// TODO arrayBuffer?
+
+							return Reflect.get(response, key, response);
+						}
+					});
+
+					return proxy;
+				}
+
+				return (
+					response ||
+					new Response('Not found', {
+						status: 404
+					})
+				);
+			},
+			stuff: { ...stuff }
+		};
+
+		if (options.dev) {
+			// TODO remove this for 1.0
+			Object.defineProperty(load_input, 'page', {
+				get: () => {
+					throw new Error('`page` in `load` functions has been replaced by `url` and `params`');
+				}
+			});
+		}
+
+		if (is_error) {
+			/** @type {import('types/page').ErrorLoadInput} */ (load_input).status = status;
+			/** @type {import('types/page').ErrorLoadInput} */ (load_input).error = error;
+		}
+
+		loaded = await module.load.call(null, load_input);
+
+		if (!loaded) {
+			throw new Error(`load function must return a value${options.dev ? ` (${node.entry})` : ''}`);
+		}
+	} else {
+		loaded = {};
+	}
+
+	if (loaded.fallthrough && !is_error) {
+		return;
+	}
+
+	return {
+		node,
+		loaded: normalize(loaded),
+		stuff: loaded.stuff || stuff,
+		fetched,
+		set_cookie_headers,
+		uses_credentials
+	};
+}
+
+/**
+ * @typedef {import('./types.js').Loaded} Loaded
+ * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
+ * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ */
+
+/**
+ * @param {{
+ *   event: import('types/hooks').RequestEvent;
+ *   options: SSRRenderOptions;
+ *   state: SSRRenderState;
+ *   $session: any;
+ *   status: number;
+ *   error: Error;
+ *   ssr: boolean;
+ * }} opts
+ */
+async function respond_with_error({ event, options, state, $session, status, error, ssr }) {
+	try {
+		const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
+		const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
+
+		/** @type {Record<string, string>} */
+		const params = {}; // error page has no params
+
+		const layout_loaded = /** @type {Loaded} */ (
+			await load_node({
+				event,
+				options,
+				state,
+				route: null,
+				url: event.url, // TODO this is redundant, no?
+				params,
+				node: default_layout,
+				$session,
+				stuff: {},
+				is_error: false
+			})
+		);
+
+		const error_loaded = /** @type {Loaded} */ (
+			await load_node({
+				event,
+				options,
+				state,
+				route: null,
+				url: event.url,
+				params,
+				node: default_error,
+				$session,
+				stuff: layout_loaded ? layout_loaded.stuff : {},
+				is_error: true,
+				status,
+				error
+			})
+		);
+
+		return await render_response({
+			options,
+			state,
+			$session,
+			page_config: {
+				hydrate: options.hydrate,
+				router: options.router
+			},
+			stuff: error_loaded.stuff,
+			status,
+			error,
+			branch: [layout_loaded, error_loaded],
+			url: event.url,
+			params,
+			ssr
+		});
+	} catch (err) {
+		const error = coalesce_to_error(err);
+
+		options.handle_error(error, event);
+
+		return new Response(error.stack, {
+			status: 500
+		});
+	}
+}
+
+/**
+ * @typedef {import('./types.js').Loaded} Loaded
+ * @typedef {import('types/internal').SSRNode} SSRNode
+ * @typedef {import('types/internal').SSRRenderOptions} SSRRenderOptions
+ * @typedef {import('types/internal').SSRRenderState} SSRRenderState
+ */
+
+/**
+ * @param {{
+ *   event: import('types/hooks').RequestEvent;
+ *   options: SSRRenderOptions;
+ *   state: SSRRenderState;
+ *   $session: any;
+ *   route: import('types/internal').SSRPage;
+ *   params: Record<string, string>;
+ *   ssr: boolean;
+ * }} opts
+ * @returns {Promise<Response | undefined>}
+ */
+async function respond$1(opts) {
+	const { event, options, state, $session, route, ssr } = opts;
+
+	/** @type {Array<SSRNode | undefined>} */
+	let nodes;
+
+	if (!ssr) {
+		return await render_response({
+			...opts,
+			branch: [],
+			page_config: {
+				hydrate: true,
+				router: true
+			},
+			status: 200,
+			url: event.url,
+			stuff: {}
+		});
+	}
+
+	try {
+		nodes = await Promise.all(
+			route.a.map((n) => options.manifest._.nodes[n] && options.manifest._.nodes[n]())
+		);
+	} catch (err) {
+		const error = coalesce_to_error(err);
+
+		options.handle_error(error, event);
+
+		return await respond_with_error({
+			event,
+			options,
+			state,
+			$session,
+			status: 500,
+			error,
+			ssr
+		});
+	}
+
+	// the leaf node will be present. only layouts may be undefined
+	const leaf = /** @type {SSRNode} */ (nodes[nodes.length - 1]).module;
+
+	let page_config = get_page_config(leaf, options);
+
+	if (!leaf.prerender && state.prerender && !state.prerender.all) {
+		// if the page has `export const prerender = true`, continue,
+		// otherwise bail out at this point
+		return new Response(undefined, {
+			status: 204
+		});
+	}
+
+	/** @type {Array<Loaded>} */
+	let branch = [];
+
+	/** @type {number} */
+	let status = 200;
+
+	/** @type {Error|undefined} */
+	let error;
+
+	/** @type {string[]} */
+	let set_cookie_headers = [];
+
+	let stuff = {};
+
+	ssr: if (ssr) {
+		for (let i = 0; i < nodes.length; i += 1) {
+			const node = nodes[i];
+
+			/** @type {Loaded | undefined} */
+			let loaded;
+
+			if (node) {
+				try {
+					loaded = await load_node({
+						...opts,
+						url: event.url,
+						node,
+						stuff,
+						is_error: false
+					});
+
+					if (!loaded) return;
+
+					set_cookie_headers = set_cookie_headers.concat(loaded.set_cookie_headers);
+
+					if (loaded.loaded.redirect) {
+						return with_cookies(
+							new Response(undefined, {
+								status: loaded.loaded.status,
+								headers: {
+									location: loaded.loaded.redirect
+								}
+							}),
+							set_cookie_headers
+						);
+					}
+
+					if (loaded.loaded.error) {
+						({ status, error } = loaded.loaded);
+					}
+				} catch (err) {
+					const e = coalesce_to_error(err);
+
+					options.handle_error(e, event);
+
+					status = 500;
+					error = e;
+				}
+
+				if (loaded && !error) {
+					branch.push(loaded);
+				}
+
+				if (error) {
+					while (i--) {
+						if (route.b[i]) {
+							const error_node = await options.manifest._.nodes[route.b[i]]();
+
+							/** @type {Loaded} */
+							let node_loaded;
+							let j = i;
+							while (!(node_loaded = branch[j])) {
+								j -= 1;
+							}
+
+							try {
+								const error_loaded = /** @type {import('./types').Loaded} */ (
+									await load_node({
+										...opts,
+										url: event.url,
+										node: error_node,
+										stuff: node_loaded.stuff,
+										is_error: true,
+										status,
+										error
+									})
+								);
+
+								if (error_loaded.loaded.error) {
+									continue;
+								}
+
+								page_config = get_page_config(error_node.module, options);
+								branch = branch.slice(0, j + 1).concat(error_loaded);
+								stuff = { ...node_loaded.stuff, ...error_loaded.stuff };
+								break ssr;
+							} catch (err) {
+								const e = coalesce_to_error(err);
+
+								options.handle_error(e, event);
+
+								continue;
+							}
+						}
+					}
+
+					// TODO backtrack until we find an __error.svelte component
+					// that we can use as the leaf node
+					// for now just return regular error page
+					return with_cookies(
+						await respond_with_error({
+							event,
+							options,
+							state,
+							$session,
+							status,
+							error,
+							ssr
+						}),
+						set_cookie_headers
+					);
+				}
+			}
+
+			if (loaded && loaded.loaded.stuff) {
+				stuff = {
+					...stuff,
+					...loaded.loaded.stuff
+				};
+			}
+		}
+	}
+
+	try {
+		return with_cookies(
+			await render_response({
+				...opts,
+				stuff,
+				url: event.url,
+				page_config,
+				status,
+				error,
+				branch: branch.filter(Boolean)
+			}),
+			set_cookie_headers
+		);
+	} catch (err) {
+		const error = coalesce_to_error(err);
+
+		options.handle_error(error, event);
+
+		return with_cookies(
+			await respond_with_error({
+				...opts,
+				status: 500,
+				error
+			}),
+			set_cookie_headers
+		);
+	}
+}
+
+/**
+ * @param {import('types/internal').SSRComponent} leaf
+ * @param {SSRRenderOptions} options
+ */
+function get_page_config(leaf, options) {
+	// TODO remove for 1.0
+	if ('ssr' in leaf) {
+		throw new Error(
+			'`export const ssr` has been removed — use the handle hook instead: https://kit.svelte.dev/docs#hooks-handle'
+		);
+	}
+
+	return {
+		router: 'router' in leaf ? !!leaf.router : options.router,
+		hydrate: 'hydrate' in leaf ? !!leaf.hydrate : options.hydrate
+	};
+}
+
+/**
+ * @param {Response} response
+ * @param {string[]} set_cookie_headers
+ */
+function with_cookies(response, set_cookie_headers) {
+	if (set_cookie_headers.length) {
+		set_cookie_headers.forEach((value) => {
+			response.headers.append('set-cookie', value);
+		});
+	}
+	return response;
+}
+
+/**
+ * @param {import('types/hooks').RequestEvent} event
+ * @param {import('types/internal').SSRPage} route
+ * @param {RegExpExecArray} match
+ * @param {import('types/internal').SSRRenderOptions} options
+ * @param {import('types/internal').SSRRenderState} state
+ * @param {boolean} ssr
+ * @returns {Promise<Response | undefined>}
+ */
+async function render_page(event, route, match, options, state, ssr) {
+	if (state.initiator === route) {
+		// infinite request cycle detected
+		return new Response(`Not found: ${event.url.pathname}`, {
+			status: 404
+		});
+	}
+
+	const params = route.params ? decode_params(route.params(match)) : {};
+
+	const $session = await options.hooks.getSession(event);
+
+	const response = await respond$1({
+		event,
+		options,
+		state,
+		$session,
+		route,
+		params,
+		ssr
+	});
+
+	if (response) {
+		return response;
+	}
+
+	if (state.fetched) {
+		// we came here because of a bad request in a `load` function.
+		// rather than render the error page — which could lead to an
+		// infinite loop, if the `load` belonged to the root layout,
+		// we respond with a bare-bones 500
+		return new Response(`Bad request in load function: failed to fetch ${state.fetched}`, {
+			status: 500
+		});
+	}
+}
+
+/** @type {import('types/internal').Respond} */
+async function respond(request, options, state = {}) {
+	const url = new URL(request.url);
+
+	if (url.pathname !== '/' && options.trailing_slash !== 'ignore') {
+		const has_trailing_slash = url.pathname.endsWith('/');
+
+		if (
+			(has_trailing_slash && options.trailing_slash === 'never') ||
+			(!has_trailing_slash &&
+				options.trailing_slash === 'always' &&
+				!(url.pathname.split('/').pop() || '').includes('.'))
+		) {
+			url.pathname = has_trailing_slash ? url.pathname.slice(0, -1) : url.pathname + '/';
+
+			if (url.search === '?') url.search = '';
+
+			return new Response(undefined, {
+				status: 301,
+				headers: {
+					location: url.pathname + url.search
+				}
+			});
+		}
+	}
+
+	const { parameter, allowed } = options.method_override;
+	const method_override = url.searchParams.get(parameter)?.toUpperCase();
+
+	if (method_override) {
+		if (request.method === 'POST') {
+			if (allowed.includes(method_override)) {
+				request = new Proxy(request, {
+					get: (target, property, _receiver) => {
+						if (property === 'method') return method_override;
+						return Reflect.get(target, property, target);
+					}
+				});
+			} else {
+				const verb = allowed.length === 0 ? 'enabled' : 'allowed';
+				const body = `${parameter}=${method_override} is not ${verb}. See https://kit.svelte.dev/docs#configuration-methodoverride`;
+
+				return new Response(body, {
+					status: 400
+				});
+			}
+		} else {
+			throw new Error(`${parameter}=${method_override} is only allowed with POST requests`);
+		}
+	}
+
+	/** @type {import('types/hooks').RequestEvent} */
+	const event = {
+		request,
+		url,
+		params: {},
+		locals: {}
+	};
+
+	// TODO remove this for 1.0
+	/**
+	 * @param {string} property
+	 * @param {string} replacement
+	 * @param {string} suffix
+	 */
+	const removed = (property, replacement, suffix = '') => ({
+		get: () => {
+			throw new Error(`event.${property} has been replaced by event.${replacement}` + suffix);
+		}
+	});
+
+	const details = '. See https://github.com/sveltejs/kit/pull/3384 for details';
+
+	const body_getter = {
+		get: () => {
+			throw new Error(
+				'To access the request body use the text/json/arrayBuffer/formData methods, e.g. `body = await request.json()`' +
+					details
+			);
+		}
+	};
+
+	Object.defineProperties(event, {
+		method: removed('method', 'request.method', details),
+		headers: removed('headers', 'request.headers', details),
+		origin: removed('origin', 'url.origin'),
+		path: removed('path', 'url.pathname'),
+		query: removed('query', 'url.searchParams'),
+		body: body_getter,
+		rawBody: body_getter
+	});
+
+	let ssr = true;
+
+	try {
+		const response = await options.hooks.handle({
+			event,
+			resolve: async (event, opts) => {
+				if (opts && 'ssr' in opts) ssr = /** @type {boolean} */ (opts.ssr);
+
+				if (state.prerender && state.prerender.fallback) {
+					return await render_response({
+						url: event.url,
+						params: event.params,
+						options,
+						state,
+						$session: await options.hooks.getSession(event),
+						page_config: { router: true, hydrate: true },
+						stuff: {},
+						status: 200,
+						branch: [],
+						ssr: false
+					});
+				}
+
+				let decoded = decodeURI(event.url.pathname);
+
+				if (options.paths.base) {
+					if (!decoded.startsWith(options.paths.base)) return;
+					decoded = decoded.slice(options.paths.base.length) || '/';
+				}
+
+				for (const route of options.manifest._.routes) {
+					const match = route.pattern.exec(decoded);
+					if (!match) continue;
+
+					const response =
+						route.type === 'endpoint'
+							? await render_endpoint(event, route, match)
+							: await render_page(event, route, match, options, state, ssr);
+
+					if (response) {
+						// respond with 304 if etag matches
+						if (response.status === 200 && response.headers.has('etag')) {
+							let if_none_match_value = request.headers.get('if-none-match');
+
+							// ignore W/ prefix https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match#directives
+							if (if_none_match_value?.startsWith('W/"')) {
+								if_none_match_value = if_none_match_value.substring(2);
+							}
+
+							const etag = /** @type {string} */ (response.headers.get('etag'));
+
+							if (if_none_match_value === etag) {
+								const headers = new Headers({ etag });
+
+								// https://datatracker.ietf.org/doc/html/rfc7232#section-4.1
+								for (const key of [
+									'cache-control',
+									'content-location',
+									'date',
+									'expires',
+									'vary'
+								]) {
+									const value = response.headers.get(key);
+									if (value) headers.set(key, value);
+								}
+
+								return new Response(undefined, {
+									status: 304,
+									headers
+								});
+							}
+						}
+
+						return response;
+					}
+				}
+
+				// if this request came direct from the user, rather than
+				// via a `fetch` in a `load`, render a 404 page
+				if (!state.initiator) {
+					const $session = await options.hooks.getSession(event);
+					return await respond_with_error({
+						event,
+						options,
+						state,
+						$session,
+						status: 404,
+						error: new Error(`Not found: ${event.url.pathname}`),
+						ssr
+					});
+				}
+			},
+
+			// TODO remove for 1.0
+			// @ts-expect-error
+			get request() {
+				throw new Error('request in handle has been replaced with event' + details);
+			}
+		});
+
+		// TODO for 1.0, change the error message to point to docs rather than PR
+		if (response && !(response instanceof Response)) {
+			throw new Error('handle must return a Response object' + details);
+		}
+
+		return response;
+	} catch (/** @type {unknown} */ e) {
+		const error = coalesce_to_error(e);
+
+		options.handle_error(error, event);
+
+		try {
+			const $session = await options.hooks.getSession(event);
+			return await respond_with_error({
+				event,
+				options,
+				state,
+				$session,
+				status: 500,
+				error,
+				ssr
+			});
+		} catch (/** @type {unknown} */ e) {
+			const error = coalesce_to_error(e);
+
+			return new Response(options.dev ? error.stack : error.message, {
+				status: 500
+			});
+		}
+	}
+}
+
+/**
+ * @param {import('types/config').ValidatedConfig} config
+ * @param {string} cwd
+ * @returns {Promise<import('vite').Plugin>}
+ */
+async function create_plugin(config, cwd) {
+	/** @type {import('amphtml-validator').Validator} */
+	let amp;
+
+	if (config.kit.amp) {
+		process.env.VITE_SVELTEKIT_AMP = 'true';
+		amp = await (await import('./index8.js').then(function (n) { return n.i; })).getInstance();
+	}
+
+	return {
+		name: 'vite-plugin-svelte-kit',
+
+		configureServer(vite) {
+			__fetch_polyfill();
+
+			/** @type {import('types/app').SSRManifest} */
+			let manifest;
+
+			function update_manifest() {
+				const manifest_data = create_manifest_data({ config, cwd });
+
+				create_app({ manifest_data, output: `${SVELTE_KIT}/generated`, cwd });
+
+				manifest = {
+					appDir: config.kit.appDir,
+					assets: new Set(manifest_data.assets.map((asset) => asset.file)),
+					_: {
+						mime: 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/internal').SSRComponent} */ (
+									await vite.ssrLoadModule(url)
+								);
+								const node = await vite.moduleGraph.getModuleByUrl(url);
+
+								if (!node) throw new Error(`Could not find node for ${url}`);
+
+								const deps = new Set();
+								find_deps(node, deps);
+
+								/** @type {Record<string, string>} */
+								const styles = {};
+
+								for (const dep of deps) {
+									const parsed = new URL$1(dep.url, 'http://localhost/');
+									const query = parsed.searchParams;
+
+									// TODO what about .scss files, etc?
+									if (
+										dep.file.endsWith('.css') ||
+										(query.has('svelte') && query.get('type') === 'style')
+									) {
+										try {
+											const mod = await vite.ssrLoadModule(dep.url);
+											styles[dep.url] = mod.default;
+										} catch {
+											// this can happen with dynamically imported modules, I think
+											// because the Vite module graph doesn't distinguish between
+											// static and dynamic imports? TODO investigate, submit fix
+										}
+									}
+								}
+
+								return {
+									module,
+									entry: url.endsWith('.svelte') ? url : url + '?import',
+									css: [],
+									js: [],
+									styles
+								};
+							};
+						}),
+						routes: manifest_data.routes.map((route) => {
+							if (route.type === 'page') {
+								return {
+									type: 'page',
+									pattern: route.pattern,
+									params: get_params(route.params),
+									a: route.a.map((id) => manifest_data.components.indexOf(id)),
+									b: route.b.map((id) => manifest_data.components.indexOf(id))
+								};
+							}
+
+							return {
+								type: 'endpoint',
+								pattern: route.pattern,
+								params: get_params(route.params),
+								load: async () => {
+									const url = path__default.resolve(cwd, route.file);
+									return await vite.ssrLoadModule(url);
+								}
+							};
+						})
+					}
+				};
+			}
+
+			update_manifest();
+
+			vite.watcher.on('add', update_manifest);
+			vite.watcher.on('remove', update_manifest);
+
+			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: []
+			});
+
+			return () => {
+				remove_html_middlewares(vite.middlewares);
+
+				vite.middlewares.use(async (req, res) => {
+					try {
+						if (!req.url || !req.method) throw new Error('Incomplete request');
+						if (req.url === '/favicon.ico') return not_found(res);
+
+						const base = `${vite.config.server.https ? 'https' : 'http'}://${req.headers.host}`;
+
+						const decoded = decodeURI(new URL$1(base + req.url).pathname);
+
+						if (decoded.startsWith(assets)) {
+							const pathname = decoded.slice(assets.length);
+							const file = config.kit.files.assets + pathname;
+
+							if (fs__default.existsSync(file) && !fs__default.statSync(file).isDirectory()) {
+								req.url = encodeURI(pathname); // don't need query/hash
+								asset_server(req, res);
+								return;
+							}
+						}
+
+						if (!decoded.startsWith(config.kit.paths.base)) return not_found(res);
+
+						/** @type {Partial<import('types/internal').Hooks>} */
+						const user_hooks = resolve_entry(config.kit.files.hooks)
+							? await vite.ssrLoadModule(`/${config.kit.files.hooks}`)
+							: {};
+
+						/** @type {import('types/internal').Hooks} */
+						const hooks = {
+							getSession: user_hooks.getSession || (() => ({})),
+							handle: user_hooks.handle || (({ event, resolve }) => resolve(event)),
+							handleError:
+								user_hooks.handleError ||
+								(({ /** @type {Error & { frame?: string }} */ error }) => {
+									console.error($.bold().red(error.message));
+									if (error.frame) {
+										console.error($.gray(error.frame));
+									}
+									if (error.stack) {
+										console.error($.gray(error.stack));
+									}
+								}),
+							externalFetch: user_hooks.externalFetch || fetch
+						};
+
+						if (/** @type {any} */ (hooks).getContext) {
+							// TODO remove this for 1.0
+							throw new Error(
+								'The getContext hook has been removed. See https://kit.svelte.dev/docs#hooks'
+							);
+						}
+
+						if (/** @type {any} */ (hooks).serverFetch) {
+							// TODO remove this for 1.0
+							throw new Error('The serverFetch hook has been renamed to externalFetch.');
+						}
+
+						const root = (await vite.ssrLoadModule(`/${SVELTE_KIT}/generated/root.svelte`)).default;
+						const paths = await vite.ssrLoadModule(
+							true ? `/${SVELTE_KIT}/runtime/paths.js` : `/@fs${runtime}/paths.js`
+						);
+
+						paths.set_paths({
+							base: config.kit.paths.base,
+							assets
+						});
+
+						let request;
+
+						try {
+							request = await getRequest(base, req);
+						} catch (/** @type {any} */ err) {
+							res.statusCode = err.status || 400;
+							return res.end(err.reason || 'Invalid request body');
+						}
+
+						const rendered = await respond(request, {
+							amp: config.kit.amp,
+							dev: true,
+							floc: config.kit.floc,
+							get_stack: (error) => {
+								vite.ssrFixStacktrace(error);
+								return error.stack;
+							},
+							handle_error: (error, event) => {
+								vite.ssrFixStacktrace(error);
+								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'
+										);
+									}
+								});
+							},
+							hooks,
+							hydrate: config.kit.hydrate,
+							manifest,
+							method_override: config.kit.methodOverride,
+							paths: {
+								base: config.kit.paths.base,
+								assets
+							},
+							prefix: '',
+							prerender: config.kit.prerender.enabled,
+							read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
+							root,
+							router: config.kit.router,
+							target: config.kit.target,
+							template: ({ head, body, assets }) => {
+								let rendered = load_template(cwd, config)
+									.replace(/%svelte\.assets%/g, assets)
+									// head and body must be replaced last, in case someone tries to sneak in %svelte.assets% etc
+									.replace('%svelte.head%', () => head)
+									.replace('%svelte.body%', () => body);
+
+								if (amp) {
+									const result = amp.validateString(rendered);
+
+									if (result.status !== 'PASS') {
+										const lines = rendered.split('\n');
+
+										/** @param {string} str */
+										const escape = (str) =>
+											str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+										rendered = `<!doctype html>
+										<head>
+											<meta charset="utf-8" />
+											<meta name="viewport" content="width=device-width, initial-scale=1" />
+											<style>
+												body {
+													font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+													color: #333;
+												}
+
+												pre {
+													background: #f4f4f4;
+													padding: 1em;
+													overflow-x: auto;
+												}
+											</style>
+										</head>
+										<h1>AMP validation failed</h1>
+
+										${result.errors
+											.map(
+												(error) => `
+											<h2>${error.severity}</h2>
+											<p>Line ${error.line}, column ${error.col}: ${error.message} (<a href="${error.specUrl}">${
+													error.code
+												}</a>)</p>
+											<pre>${escape(lines[error.line - 1])}</pre>
+										`
+											)
+											.join('\n\n')}
+									`;
+									}
+								}
+
+								return rendered;
+							},
+							trailing_slash: config.kit.trailingSlash
+						});
+
+						if (rendered) {
+							setResponse(res, rendered);
+						} else {
+							not_found(res);
+						}
+					} catch (e) {
+						const error = coalesce_to_error(e);
+						vite.ssrFixStacktrace(error);
+						res.statusCode = 500;
+						res.end(error.stack);
+					}
+				});
+			};
+		}
+	};
+}
+
+/** @param {string[]} array */
+function get_params(array) {
+	// given an array of params like `['x', 'y', 'z']` for
+	// src/routes/[x]/[y]/[z]/svelte, create a function
+	// that turns a RegExpExecArray into ({ x, y, z })
+
+	/** @param {RegExpExecArray} match */
+	const fn = (match) => {
+		/** @type {Record<string, string>} */
+		const params = {};
+		array.forEach((key, i) => {
+			if (key.startsWith('...')) {
+				params[key.slice(3)] = match[i + 1] || '';
+			} else {
+				params[key] = match[i + 1];
+			}
+		});
+		return params;
+	};
+
+	return fn;
+}
+
+/** @param {import('http').ServerResponse} res */
+function not_found(res) {
+	res.statusCode = 404;
+	res.end('Not found');
+}
+
+/**
+ * @param {import('connect').Server} server
+ */
+function remove_html_middlewares(server) {
+	const html_middlewares = [
+		'viteIndexHtmlMiddleware',
+		'vite404Middleware',
+		'viteSpaFallbackMiddleware'
+	];
+	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);
+		}
+	}
+}
+
+/**
+ * @param {import('vite').ModuleNode} node
+ * @param {Set<import('vite').ModuleNode>} deps
+ */
+function find_deps(node, deps) {
+	for (const dep of node.importedModules) {
+		if (!deps.has(dep)) {
+			deps.add(dep);
+			find_deps(dep, deps);
+		}
+	}
+}
+
+/**
+ * @typedef {{
+ *   cwd: string,
+ *   port: number,
+ *   host?: string,
+ *   https: boolean,
+ *   config: import('types/config').ValidatedConfig
+ * }} Options
+ * @typedef {import('types/internal').SSRComponent} SSRComponent
+ */
+
+/** @param {Options} opts */
+async function dev({ cwd, port, host, https, config }) {
+	copy_assets(`${SVELTE_KIT}/runtime`);
+
+	const [vite_config] = deep_merge(
+		{
+			server: {
+				fs: {
+					allow: [
+						...new Set([
+							config.kit.files.assets,
+							config.kit.files.lib,
+							config.kit.files.routes,
+							path__default.resolve(cwd, 'src'),
+							path__default.resolve(cwd, SVELTE_KIT),
+							path__default.resolve(cwd, 'node_modules'),
+							path__default.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
+						])
+					]
+				},
+				strictPort: true
+			}
+		},
+		config.kit.vite()
+	);
+
+	/** @type {[any, string[]]} */
+	const [merged_config, conflicts] = deep_merge(vite_config, {
+		configFile: false,
+		root: cwd,
+		resolve: {
+			alias: get_aliases(config)
+		},
+		build: {
+			rollupOptions: {
+				// Vite dependency crawler needs an explicit JS entry point
+				// eventhough server otherwise works without it
+				input: `${runtime}/client/start.js`
+			}
+		},
+		plugins: [
+			svelte({
+				extensions: config.extensions,
+				emitCss: !config.kit.amp,
+				compilerOptions: {
+					hydratable: !!config.kit.hydrate
+				}
+			}),
+			await create_plugin(config, cwd)
+		],
+		base: '/'
+	});
+
+	print_config_conflicts(conflicts, 'kit.vite.');
+
+	// optional config from command-line flags
+	// these should take precedence, but not print conflict warnings
+	if (host) {
+		merged_config.server.host = host;
+	}
+
+	// if https is already enabled then do nothing. it could be an object and we
+	// don't want to overwrite with a boolean
+	if (https && !merged_config.server.https) {
+		merged_config.server.https = https;
+	}
+
+	if (port) {
+		merged_config.server.port = port;
+	}
+
+	const server = await vite.createServer(merged_config);
+	await server.listen(port);
+
+	const address_info = /** @type {import('net').AddressInfo} */ (
+		/** @type {import('http').Server} */ (server.httpServer).address()
+	);
+
+	return {
+		address_info,
+		server_config: vite_config.server,
+		close: () => server.close()
+	};
+}
+
+export { dev };