@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

package/src/core/postbuild/prerender.js

@@ -1,8 +1,9 @@
-/** @import { Adapter } from '@sveltejs/kit' */
-import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import process from 'node:process';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { clearLine, moveCursor } from 'node:readline';
 import { pathToFileURL } from 'node:url';
-import { mkdirp, walk } from '../../utils/filesystem.js';
+import { walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { noop } from '../../utils/functions.js';
 import { decode_uri, is_root_relative, resolve } from '../../utils/url.js';
@@ -17,6 +18,7 @@ import * as devalue from 'devalue';
 import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
+import { matches_content_type } from '../../utils/http.js';
 
 export default forked(import.meta.url, prerender);
 
@@ -35,46 +37,94 @@ const SPECIAL_HASHLINKS = new Set(['', 'top']);
  *   verbose: boolean;
  *   env: Record<string, string>;
  *   vite_config_file: string | undefined;
+ *   is_tty: boolean | undefined;
  * }} opts
  */
-async function prerender({ hash, out, manifest_path, metadata, verbose, env, vite_config_file }) {
+async function prerender({
+	hash,
+	out,
+	manifest_path,
+	metadata,
+	verbose,
+	env,
+	vite_config_file,
+	is_tty
+}) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */
-	const internal = await import(pathToFileURL(`${out}/server/internal.js`).href);
+	const { set_building, set_prerendering, set_manifest, set_read_implementation, log_response } =
+		await import(pathToFileURL(`${out}/server/internal.js`).href);
+
+	// configure `import { building } from `$app/env` —
+	// essential we do this before analysing the code
+	set_building();
+	set_prerendering();
+
+	// `set_env` and `Server` live in modules that import the user's `src/env` config. We import them
+	// *after* `set_building()` so that `building`-dependent expressions resolve correctly
+	/** @type {typeof import('__sveltekit/env')} */
+	const { set_env } = await import(pathToFileURL(`${out}/server/env.js`).href);
+	set_env(env);
 
 	/** @type {import('types').ServerModule} */
 	const { Server } = await import(pathToFileURL(`${out}/server/index.js`).href);
 
-	// configure `import { building } from `$app/env` —
-	// essential we do this before analysing the code
-	internal.set_building();
-	internal.set_prerendering();
+	const throw_handled = () => {
+		throw new Error('__handled__');
+	};
 
 	/**
 	 * @template {{message: string}} T
 	 * @template {Omit<T, 'message'>} K
-	 * @param {import('types').Logger} log
-	 * @param {'fail' | 'warn' | 'ignore' | ((details: T) => void)} input
+	 * @param {string} name
+	 * @param {'fail' | 'warn' | 'ignore' | undefined | ((details: T) => void)} input
 	 * @param {(details: K) => string} format
-	 * @returns {(details: K) => void}
+	 * @returns {(details: K & { error?: unknown }) => void}
 	 */
-	function normalise_error_handler(log, input, format) {
+	function normalise_error_handler(name, input, format) {
+		/**
+		 * @param {any} details
+		 */
+		function log_failure(details) {
+			const message = format(details);
+			log.error(`\n${message}\n`);
+		}
+
 		switch (input) {
 			case 'fail':
 				return (details) => {
-					throw new Error(format(details));
+					log_failure(details);
+					throw_handled();
 				};
 			case 'warn':
-				return (details) => {
-					log.error(format(details));
-				};
+				return log_failure;
 			case 'ignore':
 				return noop;
+			case undefined: {
+				return (details) => {
+					log_failure(details);
+
+					log.err(
+						`To suppress or handle this error, implement \`${name}\` in https://svelte.dev/docs/kit/configuration#prerender\n`
+					);
+
+					throw_handled();
+				};
+			}
 			default:
-				// @ts-expect-error TS thinks T might be of a different kind, but it's not
-				return (details) => input({ ...details, message: format(details) });
+				return (details) => {
+					const message = format(details);
+
+					try {
+						// @ts-expect-error TS thinks T might be of a different kind, but it's not
+						input({ ...details, message });
+					} catch (error) {
+						log.prettyError(error, import.meta.dirname);
+						throw_handled();
+					}
+				};
 		}
 	}
 
@@ -103,21 +153,23 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 	const vite_config = await load_vite_config(vite_config_file);
 
-	const config = extract_svelte_config(vite_config).kit;
+	const config = extract_svelte_config(vite_config);
+
+	const prerender_origin = config.paths.origin || 'http://sveltekit-prerender';
 
 	if (hash) {
 		const fallback = await generate_fallback({
 			manifest_path,
 			env,
 			out_dir: config.outDir,
-			origin: config.prerender.origin,
+			origin: prerender_origin,
 			assets: config.files.assets
 		});
 
 		const file = output_filename('/', true);
 		const dest = `${config.outDir}/output/prerendered/pages/${file}`;
 
-		mkdirp(dirname(dest));
+		mkdirSync(dirname(dest), { recursive: true });
 		writeFileSync(dest, fallback);
 
 		prerendered.pages.set('/', { file });
@@ -125,13 +177,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		return { prerendered, prerender_map };
 	}
 
-	// TODO this can just be config.adapter?
-	/** @type {Adapter | undefined} */
-	const adapter = vite_config.plugins.find(
-		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
-	)?.api?.adapter;
-
-	const emulator = await adapter?.emulate?.();
+	const emulator = await config.adapter?.emulate?.();
 
 	/** @type {import('types').Logger} */
 	const log = logger({ verbose });
@@ -140,43 +186,58 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	const saved = new Map();
 
 	const handle_http_error = normalise_error_handler(
-		log,
+		'handleHttpError',
 		config.prerender.handleHttpError,
 		({ status, path, referrer, referenceType }) => {
-			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\` - see https://svelte.dev/docs/kit/configuration#paths for more info`
-					: path;
+			let message = `Failed to prerender ${path}`;
+
+			if (status === 404) {
+				if (!path.startsWith(config.paths.base)) {
+					message = referrer ? `${path} (${referenceType} from ${referrer})` : path;
+
+					message += ` does not begin with \`base\`. You can fix this by using \`resolve('${path}')\` from \`$app/paths\`. The base path is configurable from \`paths.base\``;
+				} else if (referrer) {
+					message = `${path} was ${referenceType} from ${referrer}`;
+				}
+			}
 
-			return `${status} ${message}${referrer ? ` (${referenceType} from ${referrer})` : ''}`;
+			return message;
 		}
 	);
 
 	const handle_missing_id = normalise_error_handler(
-		log,
+		'handleMissingId',
 		config.prerender.handleMissingId,
 		({ path, id, referrers }) => {
 			return (
-				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path} - see the \`handleMissingId\` option in https://svelte.dev/docs/kit/configuration#prerender for more info:` +
+				`The following pages contain links to ${path}#${id}, but no element with id="${id}" exists on ${path}:` +
 				referrers.map((l) => `\n  - ${l}`).join('')
 			);
 		}
 	);
 
 	const handle_entry_generator_mismatch = normalise_error_handler(
-		log,
+		'handleEntryGeneratorMismatch',
 		config.prerender.handleEntryGeneratorMismatch,
 		({ generatedFromId, entry, matchedId }) => {
-			return `The entries export from ${generatedFromId} generated entry ${entry}, which was matched by ${matchedId} - see the \`handleEntryGeneratorMismatch\` option in https://svelte.dev/docs/kit/configuration#prerender for more info.`;
+			return `The entries export from ${generatedFromId} generated entry ${entry}, which was matched by ${matchedId === entry ? 'a static route' : matchedId}`;
 		}
 	);
 
 	const handle_not_prerendered_route = normalise_error_handler(
-		log,
+		'handleUnseenRoutes',
 		config.prerender.handleUnseenRoutes,
 		({ routes }) => {
 			const list = routes.map((id) => `  - ${id}`).join('\n');
-			return `The following routes were marked as prerenderable, but were not prerendered because they were not found while crawling your app:\n${list}\n\nSee the \`handleUnseenRoutes\` option in https://svelte.dev/docs/kit/configuration#prerender for more info.`;
+			return `The following routes were marked as prerenderable, but were not prerendered because they were not found while crawling your app:\n${list}`;
+		}
+	);
+
+	const handle_invalid_url = normalise_error_handler(
+		'handleInvalidUrl',
+		config.prerender.handleInvalidUrl,
+		({ href, referrer }) => {
+			return `Invalid URL ${href}${referrer ? ` (linked from ${referrer})` : ''}`;
 		}
 	);
 
@@ -210,12 +271,73 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 	const seen = new Set();
 	const written = new Set();
+
+	/** @type {Map<string, Promise<any>>} */
 	const remote_responses = new Map();
 
+	/** @type {null | { clear: () => void; update: (path: string) => void; updated: number }} */
+	let progress = null;
+
+	if (is_tty) {
+		// Where possible, provide progress feedback by showing the path we're
+		// currently requesting, then clearing the line once the response comes in.
+		// This avoids the wall of text that happens when you prerender
+		// many pages and log each response
+		let current = false;
+		let mid_line = false;
+		const stdout_write = process.stdout.write;
+		const stderr_write = process.stderr.write;
+
+		/** @type {ProxyHandler<typeof stdout_write>} */
+		const track_output = {
+			apply(target, this_arg, args) {
+				const chunk = args[0];
+				if (chunk.length > 0) {
+					current = false;
+					mid_line =
+						typeof chunk === 'string' ? !chunk.endsWith('\n') : chunk[chunk.length - 1] !== 10;
+				}
+				return Reflect.apply(target, this_arg, args);
+			}
+		};
+
+		process.stdout.write = new Proxy(stdout_write, track_output);
+		process.stderr.write = new Proxy(stderr_write, track_output);
+
+		progress = {
+			clear: () => {
+				// If app code writes to stdout or stderr, don't move the cursor to clear
+				// the previous progress log, because that will corrupt things
+				if (!current) return;
+
+				moveCursor(process.stdout, 0, -1);
+				clearLine(process.stdout, 0);
+			},
+
+			update: (path) => {
+				if (mid_line) {
+					// app output ended mid-line — start a fresh one rather than appending to it
+					stdout_write.call(process.stdout, '\n');
+				}
+
+				stdout_write.call(process.stdout, `crawling ${path}\n`);
+				current = true;
+				mid_line = false;
+			},
+
+			updated: 0
+		};
+
+		console.log('');
+	}
+
+	/** @type {Set<string>} */
+	const resolved_route_ids = new Set();
+
 	/** @type {Map<string, Set<string>>} */
 	const expected_hashlinks = new Map();
 
-	/** @type {Map<string, string[]>} */
+	/** @type {Map<string, Set<string>>} */
 	const actual_hashlinks = new Map();
 
 	/**
@@ -249,13 +371,28 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		/** @type {Map<string, import('types').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		const response = await server.respond(new Request(config.prerender.origin + encoded), {
+		if (progress) {
+			progress.clear();
+			progress.update(decoded);
+
+			if (Date.now() - progress.updated > 50) {
+				progress.updated = Date.now();
+
+				// without this, the update will rarely be visible, and progress will appear stuck
+				await new Promise((f) => setTimeout(f, 0));
+			}
+		}
+
+		const request = new Request(prerender_origin + encoded);
+
+		const response = await server.respond(request, {
 			getClientAddress() {
 				throw new Error('Cannot read clientAddress during prerendering');
 			},
 			prerendering: {
 				dependencies,
-				remote_responses
+				remote_responses,
+				resolved_route_ids
 			},
 			read: (file) => {
 				// stuff we just wrote
@@ -287,6 +424,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 			});
 		}
 
+		if (response.status >= 400) {
+			log_response(response.status, request);
+		}
+
 		const body = Buffer.from(await response.arrayBuffer());
 
 		const category = decoded.startsWith(remote_prefix) ? 'data' : 'pages';
@@ -331,17 +472,25 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		// if it's a 200 HTML response, crawl it. Skip error responses, as we don't save those
-		if (response.ok && config.prerender.crawl && headers['content-type'] === 'text/html') {
-			const { ids, hrefs } = crawl(body.toString(), decoded);
+		if (
+			response.ok &&
+			config.prerender.crawl &&
+			matches_content_type(headers['content-type'], 'text/html')
+		) {
+			const { ids, hrefs, invalid } = crawl(body.toString(), decoded);
 
-			actual_hashlinks.set(decoded, ids);
+			for (const href of invalid) {
+				handle_invalid_url({ href, referrer: decoded });
+			}
+
+			actual_hashlinks.set(decoded, new Set(ids));
 
 			/** @param {string} href */
 			const removePrerenderOrigin = (href) => {
-				if (href.startsWith(config.prerender.origin)) {
-					if (href === config.prerender.origin) return '/';
-					if (href.at(config.prerender.origin.length) !== '/') return href;
-					return href.slice(config.prerender.origin.length);
+				if (href.startsWith(prerender_origin)) {
+					if (href === prerender_origin) return '/';
+					if (href.at(prerender_origin.length) !== '/') return href;
+					return href.slice(prerender_origin.length);
 				}
 				return href;
 			};
@@ -384,7 +533,13 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		const type = headers['content-type'];
-		const is_html = response_type === REDIRECT || type === 'text/html';
+		const is_html = response_type === REDIRECT || matches_content_type(type, 'text/html');
+
+		if (!is_html && response.status === 200 && decoded.slice(config.paths.base.length + 1) === '') {
+			throw new Error(
+				`Cannot prerender a root +server.js that returns a non-HTML response - static hosts always serve an HTML file for \`${config.paths.base || '/'}\``
+			);
+		}
 
 		const file = output_filename(decoded, is_html);
 		const dest = `${config.outDir}/output/prerendered/${category}/${file}`;
@@ -405,9 +560,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				}
 
 				if (!headers['x-sveltekit-normalize']) {
-					mkdirp(dirname(dest));
-
-					log.warn(`${response.status} ${decoded} -> ${location}`);
+					mkdirSync(dirname(dest), { recursive: true });
 
 					writeFileSync(
 						dest,
@@ -453,9 +606,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				);
 			}
 
-			mkdirp(dir);
+			mkdirSync(dir, { recursive: true });
 
-			log.info(`${response.status} ${decoded}`);
 			writeFileSync(dest, body);
 			written.add(file);
 
@@ -471,7 +623,12 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 			prerendered.paths.push(decoded);
 		} else if (response_type !== OK) {
-			handle_http_error({ status: response.status, path: decoded, referrer, referenceType });
+			handle_http_error({
+				status: response.status,
+				path: decoded,
+				referrer,
+				referenceType
+			});
 		}
 
 		manifest.assets.add(file);
@@ -495,12 +652,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	}
 
-	// the user's remote function modules may reference environment variables,
-	// `read` or the `manifest` at the top-level so we need to set them before
-	// evaluating those modules to avoid potential runtime errors
-	internal.set_env(env);
-	internal.set_manifest(manifest);
-	internal.set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
+	// the user's remote function modules may reference `read` or the `manifest` at the top-level
+	// so we need to set them before evaluating those modules to avoid potential runtime errors
+	set_manifest(manifest);
+	set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
 
 	/** @type {Array<import('types').RemotePrerenderInternals>} */
 	const prerender_functions = [];
@@ -554,14 +709,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	}
 
-	const transport = (await internal.get_hooks()).transport ?? {};
 	for (const internals of prerender_functions) {
 		if (internals.has_arg) {
 			for (const arg of (await internals.inputs?.()) ?? []) {
-				void enqueue(
-					null,
-					remote_prefix + internals.id + '/' + stringify_remote_arg(arg, transport)
-				);
+				void enqueue(null, remote_prefix + internals.id + '/' + stringify_remote_arg(arg));
 			}
 		} else {
 			void enqueue(null, remote_prefix + internals.id);
@@ -569,6 +720,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	}
 
 	await q.done();
+	progress?.clear();
 
 	// handle invalid fragment links
 	for (const [key, referrers] of expected_hashlinks) {
@@ -580,7 +732,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		// ignore fragment links to pages that were not prerendered
 		if (!hashlinks) continue;
 
-		if (!hashlinks.includes(id) && !SPECIAL_HASHLINKS.has(id)) {
+		if (!hashlinks.has(id) && !SPECIAL_HASHLINKS.has(id)) {
 			handle_missing_id({ id, path, referrers: Array.from(referrers) });
 		}
 	}

package/src/core/postbuild/queue.js

@@ -28,7 +28,7 @@ export function queue(concurrency) {
 
 			if (task) {
 				current += 1;
-				const promise = Promise.resolve(task.fn());
+				const promise = (async () => task.fn())(); // could throw synchronously
 
 				void promise
 					.then(task.fulfil, (err) => {
@@ -54,6 +54,7 @@ export function queue(concurrency) {
 			const promise = new Promise((fulfil, reject) => {
 				tasks.push({ fn, fulfil, reject });
 			});
+			promise.catch(() => {});
 
 			dequeue();
 			return promise;

package/src/core/sync/create_manifest_data/conflict.js

@@ -60,7 +60,7 @@ function normalize_route_id(id) {
 			.replace(/(?<=^|\/)\(.+?\)(?=$|\/)/g, '')
 
 			.replace(/\[[ux]\+([0-9a-f]+)\]/g, (_, x) =>
-				String.fromCharCode(parseInt(x, 16)).replace(/\//g, '%2f')
+				String.fromCodePoint(parseInt(x, 16)).replace(/\//g, '%2f')
 			)
 
 			// replace `[param]` with `<*>`, `[param=x]` with `<x>`, and `[[param]]` with `<?*>`