@sveltejs/kit 1.0.0-next.393 → 1.0.0-next.396

package/dist/vite.js

@@ -1,16 +1,23 @@
-import * as fs from 'fs';
-import fs__default, { readFileSync, existsSync, writeFileSync, readdirSync, statSync } from 'fs';
-import path__default, { join, dirname, resolve as resolve$1, normalize } from 'path';
-import { a as load_template, $, c as coalesce_to_error, l as load_config } from './chunks/error.js';
+import { fork } from 'node:child_process';
+import fs$1 from 'node:fs';
+import path from 'node:path';
+import { a as load_template, $, l as load_config } from './chunks/index.js';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import * as vite from 'vite';
-import { loadConfigFromFile } from 'vite';
-import { p as posixify, m as mkdirp, w as walk, r as rimraf } from './chunks/write_tsconfig.js';
-import { g as get_runtime_directory, s, i as init, a as get_runtime_prefix, u as update, b as get_mime_lookup, p as parse_route_id, c as all, l as logger } from './chunks/sync.js';
-import { URL as URL$1, pathToFileURL } from 'url';
-import { installPolyfills } from './node/polyfills.js';
+import { loadEnv } from 'vite';
+import { p as posixify, m as mkdirp, r as rimraf } from './chunks/filesystem.js';
+import { g as get_aliases, r as resolve_entry, s, m as merge_vite_configs, a as get_vite_config, i as init, b as get_env, u as update, p as prevent_illegal_vite_imports, c as parse_route_id, d as all, e as prevent_illegal_rollup_imports } from './chunks/sync.js';
+import * as fs from 'fs';
+import fs__default, { readdirSync, statSync } from 'fs';
+import path__default, { resolve, join, normalize } from 'path';
+import { g as get_runtime_directory, a as get_runtime_prefix, b as get_mime_lookup, l as logger } from './chunks/utils.js';
 import * as qs from 'querystring';
+import { URL as URL$1, pathToFileURL } from 'url';
 import { getRequest, setResponse } from './node.js';
+import { installPolyfills } from './node/polyfills.js';
+import { c as coalesce_to_error } from './chunks/error.js';
+import { fileURLToPath } from 'node:url';
+import './chunks/write_tsconfig.js';
 import 'assert';
 import 'net';
 import 'http';
@@ -31,151 +38,9 @@ import 'node:zlib';
 import 'node:stream';
 import 'node:buffer';
 import 'node:util';
-import 'node:url';
 import 'node:net';
-import 'node:fs';
-import 'node:path';
 import 'crypto';
 
-/**
- * @param {import('vite').ResolvedConfig} config
- * @param {import('vite').ConfigEnv} config_env
- * @return {Promise<import('vite').UserConfig>}
- */
-async function get_vite_config(config, config_env) {
-	const loaded = await loadConfigFromFile(
-		config_env,
-		config.configFile,
-		undefined,
-		config.logLevel
-	);
-
-	if (!loaded) {
-		throw new Error('Could not load Vite config');
-	}
-	return { ...loaded.config, mode: config_env.mode };
-}
-
-/**
- * @param {...import('vite').UserConfig} configs
- * @returns {import('vite').UserConfig}
- */
-function merge_vite_configs(...configs) {
-	return deep_merge(
-		...configs.map((config) => ({
-			...config,
-			resolve: {
-				...config.resolve,
-				alias: normalize_alias(config.resolve?.alias || {})
-			}
-		}))
-	);
-}
-
-/**
- * Takes zero or more objects and returns a new object that has all the values
- * deeply merged together. None of the original objects will be mutated at any
- * level, and the returned object will have no references to the original
- * objects at any depth. If there's a conflict the last one wins, except for
- * arrays which will be combined.
- * @param {...Object} objects
- * @returns {Record<string, any>} the merged object
- */
-function deep_merge(...objects) {
-	const result = {};
-	/** @type {string[]} */
-	objects.forEach((o) => merge_into(result, o));
-	return result;
-}
-
-/**
- * normalize kit.vite.resolve.alias as an array
- * @param {import('vite').AliasOptions} o
- * @returns {import('vite').Alias[]}
- */
-function normalize_alias(o) {
-	if (Array.isArray(o)) return o;
-	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
-}
-
-/**
- * Merges b into a, recursively, mutating a.
- * @param {Record<string, any>} a
- * @param {Record<string, any>} b
- */
-function merge_into(a, b) {
-	/**
-	 * Checks for "plain old Javascript object", typically made as an object
-	 * literal. Excludes Arrays and built-in types like Buffer.
-	 * @param {any} x
-	 */
-	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
-
-	for (const prop in b) {
-		if (is_plain_object(b[prop])) {
-			if (!is_plain_object(a[prop])) {
-				a[prop] = {};
-			}
-			merge_into(a[prop], b[prop]);
-		} else if (Array.isArray(b[prop])) {
-			if (!Array.isArray(a[prop])) {
-				a[prop] = [];
-			}
-			a[prop].push(...b[prop]);
-		} else {
-			a[prop] = b[prop];
-		}
-	}
-}
-
-/** @param {import('types').ValidatedKitConfig} config */
-function get_aliases(config) {
-	/** @type {Record<string, string>} */
-	const alias = {
-		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
-		$app: `${get_runtime_directory(config)}/app`,
-
-		// For now, we handle `$lib` specially here rather than make it a default value for
-		// `config.kit.alias` since it has special meaning for packaging, etc.
-		$lib: config.files.lib
-	};
-
-	for (const [key, value] of Object.entries(config.alias)) {
-		alias[key] = path__default.resolve(value);
-	}
-
-	return alias;
-}
-
-/**
- * Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
- * @param {string} entry
- * @returns {string|null}
- */
-function resolve_entry(entry) {
-	if (fs__default.existsSync(entry)) {
-		const stats = fs__default.statSync(entry);
-		if (stats.isDirectory()) {
-			return resolve_entry(path__default.join(entry, 'index'));
-		}
-
-		return entry;
-	} else {
-		const dir = path__default.dirname(entry);
-
-		if (fs__default.existsSync(dir)) {
-			const base = path__default.basename(entry);
-			const files = fs__default.readdirSync(dir);
-
-			const found = files.find((file) => file.replace(/\.[^.]+$/, '') === base);
-
-			if (found) return path__default.join(dir, found);
-		}
-	}
-
-	return null;
-}
-
 /**
  * @typedef {import('rollup').RollupOutput} RollupOutput
  * @typedef {import('rollup').OutputChunk} OutputChunk
@@ -291,9 +156,7 @@ const get_default_config = function ({ config, input, ssr, outDir }) {
 			__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: JSON.stringify(config.kit.version.pollInterval),
 			__SVELTEKIT_DEV__: 'false'
 		},
-		// prevent Vite copying the contents of `config.kit.files.assets`,
-		// if it happens to be 'public' instead of 'static'
-		publicDir: false,
+		publicDir: ssr ? false : config.kit.files.assets,
 		resolve: {
 			alias: get_aliases(config.kit)
 		},
@@ -358,6 +221,8 @@ import root from '__GENERATED__/root.svelte';
 import { respond } from '${runtime}/server/index.js';
 import { set_paths, assets, base } from '${runtime}/paths.js';
 import { set_prerendering } from '${runtime}/env.js';
+import { set_private_env } from '${runtime}/env-private.js';
+import { set_public_env } from '${runtime}/env-public.js';
 
 const template = ({ head, body, assets, nonce }) => ${s(template)
 	.replace('%sveltekit.head%', '" + head + "')
@@ -409,6 +274,7 @@ export class Server {
 				default: ${config.kit.prerender.default},
 				enabled: ${config.kit.prerender.enabled}
 			},
+			public_env: {},
 			read,
 			root,
 			service_worker: ${has_service_worker ? "base + '/service-worker.js'" : 'null'},
@@ -419,6 +285,23 @@ export class Server {
 		};
 	}
 
+	init({ env }) {
+		const entries = Object.entries(env);
+
+		const prv = Object.fromEntries(Object.entries(env).filter(([k]) => !k.startsWith('${
+			config.kit.env.publicPrefix
+		}')));
+
+		const pub = Object.fromEntries(Object.entries(env).filter(([k]) => k.startsWith('${
+			config.kit.env.publicPrefix
+		}')));
+
+		set_private_env(prv);
+		set_public_env(pub);
+
+		this.options.public_env = pub;
+	}
+
 	async respond(request, options = {}) {
 		if (!(request instanceof Request)) {
 			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
@@ -708,747 +591,8 @@ async function build_service_worker(
 	await vite.build(merged_config);
 }
 
-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] !== '/';
-}
-
-/**
- * @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.slice(i, i + DOCTYPE.length).toUpperCase() === DOCTYPE) {
-					i += DOCTYPE.length;
-					while (i < html.length) {
-						if (html[i++] === '>') {
-							continue main;
-						}
-					}
-				}
-
-				// skip cdata
-				if (html.slice(i, i + CDATA_OPEN.length) === CDATA_OPEN) {
-					i += CDATA_OPEN.length;
-					while (i < html.length) {
-						if (html.slice(i, i + CDATA_CLOSE.length) === CDATA_CLOSE) {
-							i += CDATA_CLOSE.length;
-							continue main;
-						}
-
-						i += 1;
-					}
-				}
-
-				// skip comments
-				if (html.slice(i, i + COMMENT_OPEN.length) === COMMENT_OPEN) {
-					i += COMMENT_OPEN.length;
-					while (i < html.length) {
-						if (html.slice(i, i + COMMENT_CLOSE.length) === COMMENT_CLOSE) {
-							i += COMMENT_CLOSE.length;
-							continue main;
-						}
-
-						i += 1;
-					}
-				}
-			}
-
-			// parse opening tags
-			const start = ++i;
-			if (TAG_OPEN.test(html[start])) {
-				while (i < html.length) {
-					if (!TAG_CHAR.test(html[i])) {
-						break;
-					}
-
-					i += 1;
-				}
-
-				const tag = html.slice(start, i).toUpperCase();
-
-				if (tag === 'SCRIPT' || tag === 'STYLE') {
-					while (i < html.length) {
-						if (
-							html[i] === '<' &&
-							html[i + 1] === '/' &&
-							html.slice(i + 2, i + 2 + tag.length).toUpperCase() === tag
-						) {
-							continue main;
-						}
-
-						i += 1;
-					}
-				}
-
-				let href = '';
-				let rel = '';
-
-				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 === 'rel') {
-								rel = value;
-							} else if (name === 'src') {
-								hrefs.push(value);
-							} else if (name === 'srcset') {
-								const candidates = [];
-								let insideURL = true;
-								value = value.trim();
-								for (let i = 0; i < value.length; i++) {
-									if (value[i] === ',' && (!insideURL || (insideURL && value[i + 1] === ' '))) {
-										candidates.push(value.slice(0, i));
-										value = value.substring(i + 1).trim();
-										i = 0;
-										insideURL = true;
-									} else if (value[i] === ' ') {
-										insideURL = false;
-									}
-								}
-								candidates.push(value);
-								for (const candidate of candidates) {
-									const src = candidate.split(WHITESPACE)[0];
-									hrefs.push(src);
-								}
-							}
-						} else {
-							i -= 1;
-						}
-					}
-
-					i += 1;
-				}
-
-				if (href && !/\bexternal\b/i.test(rel)) {
-					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;
-		}
-
-		return escape_html_attr_dict[match] ?? `&#${match.charCodeAt(0)};`;
-	});
-
-	return `"${escaped_str}"`;
-}
-
-/**
- * @typedef {import('types').PrerenderErrorHandler} PrerenderErrorHandler
- * @typedef {import('types').Logger} Logger
- */
-
-/**
- * @param {Parameters<PrerenderErrorHandler>[0]} details
- * @param {import('types').ValidatedKitConfig} config
- */
-function format_error({ status, path, referrer, referenceType }, config) {
-	const message =
-		status === 404 && !path.startsWith(config.paths.base)
-			? `${path} does not begin with \`base\`, which is configured in \`paths.base\` and can be imported from \`$app/paths\``
-			: path;
-
-	return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
-}
-
-/**
- * @param {Logger} log
- * @param {import('types').ValidatedKitConfig} config
- * @returns {PrerenderErrorHandler}
- */
-function normalise_error_handler(log, config) {
-	switch (config.prerender.onError) {
-		case 'continue':
-			return (details) => {
-				log.error(format_error(details, config));
-			};
-		case 'fail':
-			return (details) => {
-				throw new Error(format_error(details, config));
-			};
-		default:
-			return config.prerender.onError;
-	}
-}
-
-const OK = 2;
-const REDIRECT = 3;
-
-/**
- * @param {{
- *   config: import('types').ValidatedKitConfig;
- *   client_out_dir: string;
- *   manifest_path: string;
- *   log: Logger;
- * }} opts
- */
-async function prerender({ config, client_out_dir, manifest_path, log }) {
-	/** @type {import('types').Prerendered} */
-	const prerendered = {
-		pages: new Map(),
-		assets: new Map(),
-		redirects: new Map(),
-		paths: []
-	};
-
-	if (!config.prerender.enabled) {
-		return prerendered;
-	}
-
-	installPolyfills();
-	const { fetch } = globalThis;
-	globalThis.fetch = async (info, init) => {
-		/** @type {string} */
-		let url;
-
-		/** @type {RequestInit} */
-		let opts = {};
-
-		if (info instanceof Request) {
-			url = info.url;
-
-			opts = {
-				method: info.method,
-				headers: info.headers,
-				body: info.body,
-				mode: info.mode,
-				credentials: info.credentials,
-				cache: info.cache,
-				redirect: info.redirect,
-				referrer: info.referrer,
-				integrity: info.integrity
-			};
-		} else {
-			url = info.toString();
-		}
-
-		if (url.startsWith(config.prerender.origin + '/')) {
-			const request = new Request(url, opts);
-			const response = await server.respond(request, {
-				getClientAddress,
-				prerendering: {
-					dependencies: new Map()
-				}
-			});
-
-			const decoded = new URL$1(url).pathname;
-
-			save(
-				'dependencies',
-				response,
-				Buffer.from(await response.clone().arrayBuffer()),
-				decoded,
-				encodeURI(decoded),
-				null,
-				'fetched'
-			);
-
-			return response;
-		}
-
-		return fetch(info, init);
-	};
-
-	const server_root = join(config.outDir, 'output');
-
-	/** @type {import('types').ServerModule} */
-	const { Server, override } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
-
-	/** @type {import('types').SSRManifest} */
-	const manifest = (await import(pathToFileURL(`${server_root}/server/manifest.js`).href)).manifest;
-
-	override({
-		paths: config.paths,
-		prerendering: true,
-		read: (file) => readFileSync(join(config.files.assets, file))
-	});
-
-	const server = new Server(manifest);
-
-	const error = normalise_error_handler(log, config);
-
-	const q = queue(config.prerender.concurrency);
-
-	/**
-	 * @param {string} path
-	 * @param {boolean} is_html
-	 */
-	function output_filename(path, is_html) {
-		const file = path.slice(config.paths.base.length + 1) || 'index.html';
-
-		if (is_html && !file.endsWith('.html')) {
-			return file + (file.endsWith('/') ? 'index.html' : '.html');
-		}
-
-		return file;
-	}
-
-	const files = new Set([
-		...walk(client_out_dir).map(posixify),
-		...(existsSync(config.files.assets) ? walk(config.files.assets).map(posixify) : []) // TODO remove this if we use Vite publicDir option
-	]);
-	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.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.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(config.prerender.origin + encoded), {
-			getClientAddress,
-			prerendering: {
-				dependencies
-			}
-		});
-
-		const body = Buffer.from(await response.arrayBuffer());
-
-		save('pages', response, body, decoded, encoded, referrer, 'linked');
-
-		for (const [dependency_path, result] of dependencies) {
-			// this seems circuitous, but using new URL allows us to not care
-			// whether dependency_path is encoded or not
-			const encoded_dependency_path = new URL$1(dependency_path, 'http://localhost').pathname;
-			const decoded_dependency_path = decodeURI(encoded_dependency_path);
-
-			const body = result.body ?? new Uint8Array(await result.response.arrayBuffer());
-			save(
-				'dependencies',
-				result.response,
-				body,
-				decoded_dependency_path,
-				encoded_dependency_path,
-				decoded,
-				'fetched'
-			);
-		}
-
-		if (config.prerender.crawl && response.headers.get('content-type') === 'text/html') {
-			for (const href of crawl(body.toString())) {
-				if (href.startsWith('data:') || href.startsWith('#')) continue;
-
-				const resolved = resolve(encoded, href);
-				if (!is_root_relative(resolved)) continue;
-
-				const { pathname, search } = new URL$1(resolved, 'http://localhost');
-
-				enqueue(decoded, decodeURI(pathname), pathname);
-			}
-		}
-	}
-
-	/**
-	 * @param {'pages' | 'dependencies'} category
-	 * @param {Response} response
-	 * @param {string | Uint8Array} body
-	 * @param {string} decoded
-	 * @param {string} encoded
-	 * @param {string | null} referrer
-	 * @param {'linked' | 'fetched'} referenceType
-	 */
-	function save(category, response, body, decoded, encoded, referrer, referenceType) {
-		const response_type = Math.floor(response.status / 100);
-		const type = /** @type {string} */ (response.headers.get('content-type'));
-		const is_html = response_type === REDIRECT || type === 'text/html';
-
-		const file = output_filename(decoded, is_html);
-		const dest = `${config.outDir}/output/prerendered/${category}/${file}`;
-
-		if (written.has(file)) return;
-
-		if (response_type === REDIRECT) {
-			const location = response.headers.get('location');
-
-			if (location) {
-				const resolved = resolve(encoded, location);
-				if (is_root_relative(resolved)) {
-					enqueue(decoded, decodeURI(resolved), resolved);
-				}
-
-				if (!response.headers.get('x-sveltekit-normalize')) {
-					mkdirp(dirname(dest));
-
-					log.warn(`${response.status} ${decoded} -> ${location}`);
-
-					writeFileSync(
-						dest,
-						`<meta http-equiv="refresh" content=${escape_html_attr(`0;url=${location}`)}>`
-					);
-
-					written.add(file);
-
-					if (!prerendered.redirects.has(decoded)) {
-						prerendered.redirects.set(decoded, {
-							status: response.status,
-							location: resolved
-						});
-
-						prerendered.paths.push(decoded);
-					}
-				}
-			} else {
-				log.warn(`location header missing on redirect received from ${decoded}`);
-			}
-
-			return;
-		}
-
-		if (response.status === 200) {
-			mkdirp(dirname(dest));
-
-			log.info(`${response.status} ${decoded}`);
-			writeFileSync(dest, body);
-			written.add(file);
-
-			if (is_html) {
-				prerendered.pages.set(decoded, {
-					file
-				});
-			} else {
-				prerendered.assets.set(decoded, {
-					type
-				});
-			}
-
-			prerendered.paths.push(decoded);
-		} else if (response_type !== OK) {
-			error({ status: response.status, path: decoded, referrer, referenceType });
-		}
-	}
-
-	if (config.prerender.enabled) {
-		for (const entry of config.prerender.entries) {
-			if (entry === '*') {
-				/** @type {import('types').ManifestData} */
-				const { routes } = (await import(pathToFileURL(manifest_path).href)).manifest._;
-				const entries = routes
-					.map((route) => (route.type === 'page' ? route.path : ''))
-					.filter(Boolean);
-
-				for (const entry of entries) {
-					enqueue(null, config.paths.base + entry); // TODO can we pre-normalize these?
-				}
-			} else {
-				enqueue(null, config.paths.base + entry);
-			}
-		}
-
-		await q.done();
-	}
-
-	const rendered = await server.respond(new Request(config.prerender.origin + '/[fallback]'), {
-		getClientAddress,
-		prerendering: {
-			fallback: true,
-			dependencies: new Map()
-		}
-	});
-
-	const file = `${config.outDir}/output/prerendered/fallback.html`;
-	mkdirp(dirname(file));
-	writeFileSync(file, await rendered.text());
-
-	return prerendered;
-}
-
-/** @return {string} */
-function getClientAddress() {
-	throw new Error('Cannot read clientAddress during prerendering');
-}
-
 function totalist(dir, callback, pre='') {
-	dir = resolve$1('.', dir);
+	dir = resolve('.', dir);
 	let arr = readdirSync(dir);
 	let i=0, abs, stats;
 	for (; i < arr.length; i++) {
@@ -2022,7 +1166,7 @@ function toHeaders(name, stats, isEtag) {
 }
 
 function sirv (dir, opts={}) {
-	dir = resolve$1(dir || '.');
+	dir = resolve(dir || '.');
 
 	let isNotFound = opts.onNoMatch || is404;
 	let setHeaders = opts.setHeaders || noop;
@@ -2113,12 +1257,13 @@ const cwd$1 = process.cwd();
  * @param {import('vite').ViteDevServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
+ * @param {Set<string>} illegal_imports
  * @return {Promise<Promise<() => void>>}
  */
-async function dev(vite, vite_config, svelte_config) {
+async function dev(vite, vite_config, svelte_config, illegal_imports) {
 	installPolyfills();
 
-	init(svelte_config);
+	init(svelte_config, vite_config.mode);
 
 	const runtime = get_runtime_prefix(svelte_config.kit);
 
@@ -2149,6 +1294,11 @@ async function dev(vite, vite_config, svelte_config) {
 							await vite.ssrLoadModule(url)
 						);
 
+						const node = await vite.moduleGraph.getModuleByUrl(url);
+						if (!node) throw new Error(`Could not find node for ${url}`);
+
+						prevent_illegal_vite_imports(node, illegal_imports, svelte_config.kit.outDir);
+
 						return {
 							module,
 							index,
@@ -2157,10 +1307,6 @@ async function dev(vite, vite_config, svelte_config) {
 							stylesheets: [],
 							// in dev we inline all styles to avoid FOUC
 							inline_styles: async () => {
-								const node = await vite.moduleGraph.getModuleByUrl(url);
-
-								if (!node) throw new Error(`Could not find node for ${url}`);
-
 								const deps = new Set();
 								await find_deps(vite, node, deps);
 
@@ -2269,37 +1415,50 @@ async function dev(vite, vite_config, svelte_config) {
 		extensions: []
 	});
 
+	vite.middlewares.use(async (req, res, next) => {
+		try {
+			const base = `${vite.config.server.https ? 'https' : 'http'}://${
+				req.headers[':authority'] || 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 = svelte_config.kit.files.assets + pathname;
+
+				if (fs__default.existsSync(file) && !fs__default.statSync(file).isDirectory()) {
+					if (has_correct_case(file, svelte_config.kit.files.assets)) {
+						req.url = encodeURI(pathname); // don't need query/hash
+						asset_server(req, res);
+						return;
+					}
+				}
+			}
+
+			next();
+		} catch (e) {
+			const error = coalesce_to_error(e);
+			res.statusCode = 500;
+			res.end(fix_stack_trace(error));
+		}
+	});
+
 	return () => {
 		const serve_static_middleware = vite.middlewares.stack.find(
 			(middleware) =>
 				/** @type {function} */ (middleware.handle).name === 'viteServeStaticMiddleware'
 		);
 
-		remove_html_middlewares(vite.middlewares);
+		remove_static_middlewares(vite.middlewares);
 
 		vite.middlewares.use(async (req, res) => {
 			try {
-				if (!req.url || !req.method) throw new Error('Incomplete request');
-
 				const base = `${vite.config.server.https ? 'https' : 'http'}://${
 					req.headers[':authority'] || 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 = svelte_config.kit.files.assets + pathname;
-
-					if (fs__default.existsSync(file) && !fs__default.statSync(file).isDirectory()) {
-						if (has_correct_case(file, svelte_config.kit.files.assets)) {
-							req.url = encodeURI(pathname); // don't need query/hash
-							asset_server(req, res);
-							return;
-						}
-					}
-				}
-
 				const file = posixify(path__default.resolve(decoded.slice(1)));
 				const is_file = fs__default.existsSync(file) && !fs__default.statSync(file).isDirectory();
 				const allowed =
@@ -2324,6 +1483,17 @@ async function dev(vite, vite_config, svelte_config) {
 					? await vite.ssrLoadModule(`/${svelte_config.kit.files.hooks}`)
 					: {};
 
+				const runtime_base = true
+					? `/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/runtime`))}`
+					: `/@fs${runtime}`;
+
+				const { set_private_env } = await vite.ssrLoadModule(`${runtime_base}/env-private.js`);
+				const { set_public_env } = await vite.ssrLoadModule(`${runtime_base}/env-public.js`);
+
+				const env = get_env(vite_config.mode, svelte_config.kit.env.publicPrefix);
+				set_private_env(env.private);
+				set_public_env(env.public);
+
 				const handle = user_hooks.handle || (({ event, resolve }) => resolve(event));
 
 				/** @type {import('types').Hooks} */
@@ -2364,11 +1534,7 @@ async function dev(vite, vite_config, svelte_config) {
 					`/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/generated/root.svelte`))}`
 				);
 
-				const paths = await vite.ssrLoadModule(
-					true
-						? `/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/runtime/paths.js`))}`
-						: `/@fs${runtime}/paths.js`
-				);
+				const paths = await vite.ssrLoadModule(`${runtime_base}/paths.js`);
 
 				paths.set_paths({
 					base: svelte_config.kit.paths.base,
@@ -2427,6 +1593,7 @@ async function dev(vite, vite_config, svelte_config) {
 							default: svelte_config.kit.prerender.default,
 							enabled: svelte_config.kit.prerender.enabled
 						},
+						public_env: env.public,
 						read: (file) => fs__default.readFileSync(path__default.join(svelte_config.kit.files.assets, file)),
 						root,
 						router: svelte_config.kit.browser.router,
@@ -2478,11 +1645,15 @@ function not_found(res, message = 'Not found') {
 /**
  * @param {import('connect').Server} server
  */
-function remove_html_middlewares(server) {
-	const html_middlewares = ['viteServeStaticMiddleware'];
+function remove_static_middlewares(server) {
+	// We don't use viteServePublicMiddleware because of the following issues:
+	// https://github.com/vitejs/vite/issues/9260
+	// https://github.com/vitejs/vite/issues/9236
+	// https://github.com/vitejs/vite/issues/9234
+	const static_middlewares = ['viteServePublicMiddleware', 'viteServeStaticMiddleware'];
 	for (let i = server.stack.length - 1; i > 0; i--) {
-		// @ts-expect-error using internals until https://github.com/vitejs/vite/pull/4640 is merged
-		if (html_middlewares.includes(server.stack[i].handle.name)) {
+		// @ts-expect-error using internals
+		if (static_middlewares.includes(server.stack[i].handle.name)) {
 			server.stack.splice(i, 1);
 		}
 	}
@@ -2677,20 +1848,22 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
  *   middlewares: import('connect').Server;
  *   httpServer: import('http').Server;
  * }} vite
- * @param {import('types').ValidatedConfig} config
- * @param {'http' | 'https'} protocol
+ * @param {import('vite').ResolvedConfig} vite_config
+ * @param {import('types').ValidatedConfig} svelte_config
  */
-async function preview(vite, config, protocol) {
+async function preview(vite, vite_config, svelte_config) {
 	installPolyfills();
 
-	const { paths } = config.kit;
+	const { paths } = svelte_config.kit;
 	const base = paths.base;
 	const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
 
+	const protocol = vite_config.preview.https ? 'https' : 'http';
+
 	const etag = `"${Date.now()}"`;
 
-	const index_file = join(config.kit.outDir, 'output/server/index.js');
-	const manifest_file = join(config.kit.outDir, 'output/server/manifest.js');
+	const index_file = join(svelte_config.kit.outDir, 'output/server/index.js');
+	const manifest_file = join(svelte_config.kit.outDir, 'output/server/manifest.js');
 
 	/** @type {import('types').ServerModule} */
 	const { Server, override } = await import(pathToFileURL(index_file).href);
@@ -2700,23 +1873,23 @@ async function preview(vite, config, protocol) {
 		paths: { base, assets },
 		prerendering: false,
 		protocol,
-		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+		read: (file) => fs__default.readFileSync(join(svelte_config.kit.files.assets, file))
 	});
 
 	const server = new Server(manifest);
+	server.init({
+		env: loadEnv(vite_config.mode, process.cwd(), '')
+	});
 
 	return () => {
-		// files in `static`
-		vite.middlewares.use(scoped(assets, mutable(config.kit.files.assets)));
-
-		// immutable generated client assets
+		// generated client assets and the contents of `static`
 		vite.middlewares.use(
 			scoped(
 				assets,
-				sirv(join(config.kit.outDir, 'output/client'), {
+				sirv(join(svelte_config.kit.outDir, 'output/client'), {
 					setHeaders: (res, pathname) => {
-						// only apply to build directory, not e.g. version.json
-						if (pathname.startsWith(`/${config.kit.appDir}/immutable`)) {
+						// only apply to immutable directory, not e.g. version.json
+						if (pathname.startsWith(`/${svelte_config.kit.appDir}/immutable`)) {
 							res.setHeader('cache-control', 'public,max-age=31536000,immutable');
 						}
 					}
@@ -2738,7 +1911,7 @@ async function preview(vite, config, protocol) {
 
 		// prerendered dependencies
 		vite.middlewares.use(
-			scoped(base, mutable(join(config.kit.outDir, 'output/prerendered/dependencies')))
+			scoped(base, mutable(join(svelte_config.kit.outDir, 'output/prerendered/dependencies')))
 		);
 
 		// prerendered pages (we can't just use sirv because we need to
@@ -2762,7 +1935,7 @@ async function preview(vite, config, protocol) {
 				// only treat this as a page if it doesn't include an extension
 				if (pathname === '/' || /\/[^./]+\/?$/.test(pathname)) {
 					const file = join(
-						config.kit.outDir,
+						svelte_config.kit.outDir,
 						'output/prerendered/pages' +
 							pathname +
 							(pathname.endsWith('/') ? 'index.html' : '.html')
@@ -2820,7 +1993,7 @@ const mutable = (dir) =>
 				etag: true,
 				maxAge: 0
 		  })
-		: (req, res, next) => next();
+		: (_req, _res, next) => next();
 
 /**
  * @param {string} scope
@@ -2928,6 +2101,9 @@ function kit() {
 	/** @type {import('types').BuildData} */
 	let build_data;
 
+	/** @type {Set<string>} */
+	let illegal_imports;
+
 	/** @type {string | undefined} */
 	let deferred_warning;
 
@@ -2954,12 +2130,12 @@ function kit() {
 		// for everything regardless — but it means that entry chunks reflect
 		// their location in the source code, which is helpful for debugging
 		manifest_data.components.forEach((file) => {
-			const resolved = path__default.resolve(cwd, file);
-			const relative = decodeURIComponent(path__default.relative(svelte_config.kit.files.routes, resolved));
+			const resolved = path.resolve(cwd, file);
+			const relative = decodeURIComponent(path.relative(svelte_config.kit.files.routes, resolved));
 
 			const name = relative.startsWith('..')
-				? path__default.basename(file)
-				: posixify(path__default.join('pages', relative));
+				? path.basename(file)
+				: posixify(path.join('pages', relative));
 			input[name] = resolved;
 		});
 
@@ -2978,11 +2154,11 @@ function kit() {
 	function client_build_info(assets, chunks) {
 		/** @type {import('vite').Manifest} */
 		const vite_manifest = JSON.parse(
-			fs__default.readFileSync(`${paths.client_out_dir}/manifest.json`, 'utf-8')
+			fs$1.readFileSync(`${paths.client_out_dir}/manifest.json`, 'utf-8')
 		);
 
 		const entry_id = posixify(
-			path__default.relative(cwd, `${get_runtime_directory(svelte_config.kit)}/client/start.js`)
+			path.relative(cwd, `${get_runtime_directory(svelte_config.kit)}/client/start.js`)
 		);
 
 		return {
@@ -3014,8 +2190,13 @@ function kit() {
 				client_out_dir: `${svelte_config.kit.outDir}/output/client/`
 			};
 
+			illegal_imports = new Set([
+				`${svelte_config.kit.outDir}/runtime/env/dynamic/private.js`,
+				`${svelte_config.kit.outDir}/runtime/env/static/private.js`
+			]);
+
 			if (is_build) {
-				manifest_data = all(svelte_config).manifest_data;
+				manifest_data = all(svelte_config, config_env.mode).manifest_data;
 
 				const new_config = vite_client_build_config();
 
@@ -3041,6 +2222,7 @@ function kit() {
 					__SVELTEKIT_DEV__: 'true',
 					__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: '0'
 				},
+				publicDir: svelte_config.kit.files.assets,
 				resolve: {
 					alias: get_aliases(svelte_config.kit)
 				},
@@ -3052,9 +2234,9 @@ function kit() {
 								svelte_config.kit.files.lib,
 								svelte_config.kit.files.routes,
 								svelte_config.kit.outDir,
-								path__default.resolve(cwd, 'src'),
-								path__default.resolve(cwd, 'node_modules'),
-								path__default.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
+								path.resolve(cwd, 'src'),
+								path.resolve(cwd, 'node_modules'),
+								path.resolve(vite.searchForWorkspaceRoot(cwd), 'node_modules')
 							])
 						]
 					},
@@ -3100,11 +2282,26 @@ function kit() {
 		 * then use this hook to kick off builds for the server and service worker.
 		 */
 		async writeBundle(_options, bundle) {
+			for (const file of manifest_data.components) {
+				const id = path.resolve(file);
+				const node = this.getModuleInfo(id);
+
+				if (node) {
+					prevent_illegal_rollup_imports(
+						this.getModuleInfo.bind(this),
+						node,
+						illegal_imports,
+						svelte_config.kit.outDir
+					);
+				}
+			}
+
+			const verbose = vite_config.logLevel === 'info';
 			log = logger({
-				verbose: vite_config.logLevel === 'info'
+				verbose
 			});
 
-			fs__default.writeFileSync(
+			fs$1.writeFileSync(
 				`${paths.client_out_dir}/${svelte_config.kit.appDir}/version.json`,
 				JSON.stringify({ version: svelte_config.kit.version.name })
 			);
@@ -3136,7 +2333,7 @@ function kit() {
 			};
 
 			const manifest_path = `${paths.output_dir}/server/manifest.js`;
-			fs__default.writeFileSync(
+			fs$1.writeFileSync(
 				manifest_path,
 				`export const manifest = ${generate_manifest({
 					build_data,
@@ -3145,14 +2342,39 @@ function kit() {
 				})};\n`
 			);
 
-			process.env.SVELTEKIT_SERVER_BUILD_COMPLETED = 'true';
 			log.info('Prerendering');
+			await new Promise((fulfil, reject) => {
+				const results_path = `${svelte_config.kit.outDir}/generated/prerendered.json`;
+
+				// do prerendering in a subprocess so any dangling stuff gets killed upon completion
+				const script = fileURLToPath(
+					new URL(
+						'./prerender.js' ,
+						import.meta.url
+					)
+				);
 
-			prerendered = await prerender({
-				config: svelte_config.kit,
-				client_out_dir: vite_config.build.outDir,
-				manifest_path,
-				log
+				const child = fork(
+					script,
+					[vite_config.build.outDir, results_path, manifest_path, '' + verbose],
+					{
+						stdio: 'inherit'
+					}
+				);
+
+				child.on('exit', (code) => {
+					if (code) {
+						reject(new Error(`Prerendering failed with code ${code}`));
+					} else {
+						prerendered = JSON.parse(fs$1.readFileSync(results_path, 'utf8'), (key, value) => {
+							if (key === 'pages' || key === 'assets' || key === 'redirects') {
+								return new Map(value);
+							}
+							return value;
+						});
+						fulfil(undefined);
+					}
+				});
 			});
 
 			if (options.service_worker_entry_file) {
@@ -3183,7 +2405,7 @@ function kit() {
 			}
 
 			if (svelte_config.kit.adapter) {
-				const { adapt } = await import('./chunks/index2.js');
+				const { adapt } = await import('./chunks/index3.js');
 				await adapt(svelte_config, build_data, prerendered, { log });
 			} else {
 				console.log($.bold().yellow('\nNo adapter specified'));
@@ -3192,13 +2414,6 @@ function kit() {
 					`See ${$.bold().cyan('https://kit.svelte.dev/docs/adapters')} to learn how to configure your app to run on the platform of your choosing`
 				);
 			}
-
-			if (svelte_config.kit.prerender.enabled) {
-				// this is necessary to close any open db connections, etc.
-				// TODO: prerender in a subprocess so we can exit in isolation and then remove this
-				// https://github.com/sveltejs/kit/issues/5306
-				process.exit(0);
-			}
 		},
 
 		/**
@@ -3214,7 +2429,7 @@ function kit() {
 				if (deferred_warning) console.error('\n' + deferred_warning);
 			};
 
-			return await dev(vite, vite_config, svelte_config);
+			return await dev(vite, vite_config, svelte_config, illegal_imports);
 		},
 
 		/**
@@ -3222,7 +2437,7 @@ function kit() {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configurepreviewserver
 		 */
 		configurePreviewServer(vite) {
-			return preview(vite, svelte_config, vite_config.preview.https ? 'https' : 'http');
+			return preview(vite, vite_config, svelte_config);
 		}
 	};
 }