@sveltejs/kit 3.0.0-next.20 → 3.0.0-next.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.20",
+  "version": "3.0.0-next.22",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -18,6 +18,7 @@
   "homepage": "https://svelte.dev",
   "type": "module",
   "dependencies": {
+    "@rolldown/pluginutils": "^1.0.1",
     "@standard-schema/spec": "^1.1.0",
     "@sveltejs/acorn-typescript": "^1.0.12",
     "acorn": "^8.18.0",
@@ -37,7 +38,6 @@
     "@types/node": "^22.19.19",
     "dts-buddy": "^0.8.3",
     "jsdom": "^30.0.0",
-    "rolldown": "^1.2.3",
     "svelte": "^5.56.8",
     "svelte-preprocess": "^6.0.5",
     "typescript": "~6.0.3",
@@ -129,6 +129,10 @@
       "types": "./types/index.d.ts",
       "import": "./src/exports/params/index.js"
     },
+    "./remote": {
+      "types": "./types/index.d.ts",
+      "import": "./src/exports/remote/index.js"
+    },
     "./vite": {
       "types": "./types/index.d.ts",
       "import": "./src/exports/vite/index.js"
@@ -153,7 +157,7 @@
     "test:server-side-route-resolution:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:server-side-route-resolution:build",
     "test:svelte-async:dev": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:svelte-async:dev",
     "test:svelte-async:build": "pnpm -r --workspace-concurrency 1 --filter=\"./test/**\" test:svelte-async:build",
-    "test:unit": "vitest run ./",
+    "test:unit": "vitest run -c vitest.kit.config.js",
     "tsc-native": "node node_modules/@typescript/native/bin/tsc",
     "generate:version": "node scripts/generate-version.js",
     "generate:types": "node scripts/generate-dts.js"

package/src/cli.js

@@ -105,8 +105,8 @@ if (command === 'sync') {
 		const sync = await import('./core/sync/sync.js');
 		sync.all_types(sveltekit_config, vite_config.root);
 
-		const explicit_env_entry = resolve_explicit_env_entry(sveltekit_config.kit);
-		await sync.env(vite, sveltekit_config.kit, explicit_env_entry, vite_config.root, values.mode);
+		const explicit_env_entry = resolve_explicit_env_entry(sveltekit_config);
+		await sync.env(vite, sveltekit_config, explicit_env_entry, vite_config.root, values.mode);
 	} catch (error) {
 		handle_error(error);
 	} finally {

package/src/core/adapt/builder.js

@@ -141,15 +141,15 @@ export function create_builder({
 		},
 
 		async generateFallback(dest) {
-			const manifest_path = `${config.kit.outDir}/output/server/manifest-full.js`;
-			const env = loadEnv(vite_config.mode, config.kit.env.dir, '');
+			const manifest_path = `${config.outDir}/output/server/manifest-full.js`;
+			const env = loadEnv(vite_config.mode, config.env.dir, '');
 
 			const fallback = await generate_fallback({
 				manifest_path,
 				env,
-				out_dir: config.kit.outDir,
-				origin: config.kit.paths.origin || 'http://sveltekit-prerender',
-				assets: config.kit.files.assets
+				out_dir: config.outDir,
+				origin: config.paths.origin || 'http://sveltekit-prerender',
+				assets: config.files.assets
 			});
 
 			if (existsSync(dest)) {
@@ -164,8 +164,8 @@ export function create_builder({
 		generateEnvModule() {
 			if (!build_data.client?.uses_env_dynamic_public) return;
 
-			const dest = `${config.kit.outDir}/output/prerendered/dependencies/${config.kit.appDir}`;
-			const env = loadEnv(vite_config.mode, config.kit.env.dir, '');
+			const dest = `${config.outDir}/output/prerendered/dependencies/${config.appDir}`;
+			const env = loadEnv(vite_config.mode, config.env.dir, '');
 
 			/** @type {Record<string, any>} */
 			const values = {};
@@ -200,15 +200,15 @@ export function create_builder({
 		},
 
 		getBuildDirectory(name) {
-			return `${config.kit.outDir}/${name}`;
+			return `${config.outDir}/${name}`;
 		},
 
 		getClientDirectory() {
-			return `${config.kit.outDir}/output/client`;
+			return `${config.outDir}/output/client`;
 		},
 
 		getServerDirectory() {
-			return `${config.kit.outDir}/output/server`;
+			return `${config.outDir}/output/server`;
 		},
 
 		getAppPath() {
@@ -216,14 +216,14 @@ export function create_builder({
 		},
 
 		writeClient(dest) {
-			return copy(`${config.kit.outDir}/output/client`, dest, {
+			return copy(`${config.outDir}/output/client`, dest, {
 				// avoid making vite build artefacts public
 				filter: (basename) => basename !== '.vite'
 			});
 		},
 
 		writePrerendered(dest) {
-			const source = `${config.kit.outDir}/output/prerendered`;
+			const source = `${config.outDir}/output/prerendered`;
 
 			return [
 				...copy(`${source}/pages`, dest),
@@ -233,11 +233,11 @@ export function create_builder({
 		},
 
 		writeServer(dest) {
-			return copy(`${config.kit.outDir}/output/server`, dest);
+			return copy(`${config.outDir}/output/server`, dest);
 		},
 
 		hasServerInstrumentationFile() {
-			return existsSync(`${config.kit.outDir}/output/server/instrumentation.server.js`);
+			return existsSync(`${config.outDir}/output/server/instrumentation.server.js`);
 		},
 
 		instrument({

package/src/core/adapt/index.js

@@ -23,12 +23,26 @@ export async function adapt(
 	vite_config,
 	explicit_env_config
 ) {
-	const { name, adapt } = config.kit.adapter;
+	const { name, adapt } = config.adapter;
 
 	console.log(styleText(['bold', 'cyan'], `\n> Using ${name}`));
 
+	let warned = false;
+
 	const builder = create_builder({
-		config,
+		config: {
+			...config,
+			get kit() {
+				if (!warned) {
+					warned = true;
+					log.warn(
+						`Reading \`config.kit\` inside adapters is deprecated — it should access configuration on the \`config\` object directly. You may need to update your adapter`
+					);
+				}
+
+				return config;
+			}
+		},
 		build_data,
 		server_metadata,
 		route_data: build_data.manifest_data.routes.filter((route) => route.page || route.endpoint),

package/src/core/config/index.js

@@ -1,5 +1,4 @@
-/** @import { Config, KitConfig } from '@sveltejs/kit' */
-/** @import { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
+/** @import { Config } from '@sveltejs/kit/vite' */
 /** @import { ValidatedConfig } from 'types' */
 /** @import { ResolvedConfig } from 'vite' */
 import fs from 'node:fs';
@@ -7,12 +6,7 @@ import path from 'node:path';
 import process from 'node:process';
 import * as url from 'node:url';
 import { styleText } from 'node:util';
-import {
-	validate_kit_options,
-	kit_options,
-	kit_experimental_options,
-	validate_svelte_options
-} from './options.js';
+import { validate_options, kit_options, kit_experimental_options } from './options.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { import_peer } from '../../utils/import.js';
 import { stackless } from '../../utils/error.js';
@@ -23,23 +17,21 @@ import { stackless } from '../../utils/error.js';
  * `vite-plugin-svelte`. SvelteKit makes no assumptions about which options
  * `vite-plugin-svelte` accepts — it plucks out its own options and passes
  * everything else along (`vite-plugin-svelte` does its own validation).
- * @param {KitConfig & Omit<Options, 'onwarn'> & Pick<SvelteConfig, 'vitePlugin'>} config
+ * @param {Config} config
  * @returns {{ svelte_config: Config, vite_plugin_svelte_config: Record<string, any> }}
  */
 export function split_config(config) {
-	const { extensions, compilerOptions, vitePlugin, preprocess, ...rest } = config;
-
-	/** @type {KitConfig} */
-	const kit = {};
+	/** @type {Config} */
+	const svelte_config = {};
 
 	/** @type {Record<string, any>} */
 	const vite_plugin_svelte_config = {};
 
-	for (const key in rest) {
+	for (const key in config) {
 		if (key === 'experimental') {
 			// `experimental` is a namespace that both SvelteKit and vite-plugin-svelte
 			// use, so pluck out the flags SvelteKit recognises and pass the rest along
-			const experimental = /** @type {Record<string, any>} */ (rest[key]) ?? {};
+			const experimental = /** @type {Record<string, any>} */ (config[key]) ?? {};
 
 			/** @type {Record<string, any>} */
 			const kit_experimental = {};
@@ -55,21 +47,21 @@ export function split_config(config) {
 			}
 
 			if (Object.keys(kit_experimental).length > 0) {
-				kit.experimental = kit_experimental;
+				svelte_config.experimental = kit_experimental;
 			}
 			if (Object.keys(vps_experimental).length > 0) {
 				vite_plugin_svelte_config.experimental = vps_experimental;
 			}
 		} else if (kit_options.includes(key)) {
 			// @ts-expect-error - we've verified this is one of SvelteKit's own options
-			kit[key] = rest[key];
+			svelte_config[key] = config[key];
 		} else {
-			vite_plugin_svelte_config[key] = /** @type {Record<string, any>} */ (rest)[key];
+			vite_plugin_svelte_config[key] = /** @type {Record<string, any>} */ (config)[key];
 		}
 	}
 
 	return {
-		svelte_config: { extensions, compilerOptions, vitePlugin, preprocess, kit },
+		svelte_config,
 		vite_plugin_svelte_config
 	};
 }
@@ -80,8 +72,8 @@ export function split_config(config) {
  * @param {string} cwd
  * @param {ValidatedConfig} config
  */
-export function load_template(cwd, { kit }) {
-	const { files } = kit;
+export function load_template(cwd, config) {
+	const { files } = config;
 
 	const relative = path.relative(cwd, files.appTemplate);
 
@@ -107,11 +99,11 @@ export function load_template(cwd, { kit }) {
  * @param {ValidatedConfig} config
  */
 export function load_error_page(config) {
-	let { errorTemplate } = config.kit.files;
+	let { errorTemplate } = config.files;
 
 	// Don't do this inside resolving the config, because that would mean
 	// adding/removing error.html isn't detected and would require a restart.
-	if (!fs.existsSync(config.kit.files.errorTemplate)) {
+	if (!fs.existsSync(config.files.errorTemplate)) {
 		errorTemplate = url.fileURLToPath(new URL('./default-error.html', import.meta.url));
 	}
 
@@ -144,27 +136,27 @@ export function extract_svelte_config(vite_config) {
  */
 export function process_config(config, cwd) {
 	if (
-		config.kit.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
-		config.kit.serviceWorker.register &&
-		resolve_entry(path.resolve(cwd, config.kit.files.serviceWorker)) &&
-		!config.kit.csp?.directives?.['trusted-types']?.includes('sveltekit-trusted-url')
+		config.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
+		config.serviceWorker.register &&
+		resolve_entry(path.resolve(cwd, config.files.serviceWorker)) &&
+		!config.csp?.directives?.['trusted-types']?.includes('sveltekit-trusted-url')
 	) {
 		throw new Error(
 			"The `csp.directives['trusted-types']` option must include 'sveltekit-trusted-url' when `serviceWorker.register` is true"
 		);
 	}
 
-	config.kit.outDir = path.resolve(cwd, config.kit.outDir);
-	config.kit.env.dir = path.resolve(cwd, config.kit.env.dir);
+	config.outDir = path.resolve(cwd, config.outDir);
+	config.env.dir = path.resolve(cwd, config.env.dir);
 
-	for (const key in config.kit.files) {
+	for (const key in config.files) {
 		if (key === 'hooks') {
-			config.kit.files.hooks.client = path.resolve(cwd, config.kit.files.hooks.client);
-			config.kit.files.hooks.server = path.resolve(cwd, config.kit.files.hooks.server);
-			config.kit.files.hooks.universal = path.resolve(cwd, config.kit.files.hooks.universal);
+			config.files.hooks.client = path.resolve(cwd, config.files.hooks.client);
+			config.files.hooks.server = path.resolve(cwd, config.files.hooks.server);
+			config.files.hooks.universal = path.resolve(cwd, config.files.hooks.universal);
 		} else if (key !== 'lib' /* TODO remove when we remove the `lib` option altogether */) {
 			// @ts-expect-error
-			config.kit.files[key] = path.resolve(cwd, config.kit.files[key]);
+			config.files[key] = path.resolve(cwd, config.files[key]);
 		}
 	}
 
@@ -183,11 +175,8 @@ export function validate_config(config) {
 			);
 		}
 
-		const validated = /** @type {ValidatedConfig} */ ({
-			...validate_svelte_options(config, 'config'),
-			kit: validate_kit_options(config.kit, 'config')
-		});
-		const files = validated.kit.files;
+		const validated = validate_options(config, 'config');
+		const files = validated.files;
 
 		files.hooks.client ??= path.join(files.src, 'hooks.client');
 		files.hooks.server ??= path.join(files.src, 'hooks.server');
@@ -198,13 +187,13 @@ export function validate_config(config) {
 		files.appTemplate ??= path.join(files.src, 'app.html');
 		files.errorTemplate ??= path.join(files.src, 'error.html');
 
-		if (validated.kit.router.resolution === 'server') {
-			if (validated.kit.router.type === 'hash') {
+		if (validated.router.resolution === 'server') {
+			if (validated.router.type === 'hash') {
 				throw new Error(
 					"The `router.resolution` option cannot be 'server' if `router.type` is 'hash'"
 				);
 			}
-			if (validated.kit.output.bundleStrategy !== 'split') {
+			if (validated.output.bundleStrategy !== 'split') {
 				throw new Error(
 					"The `router.resolution` option cannot be 'server' if `output.bundleStrategy` is 'inline' or 'single'"
 				);
@@ -212,8 +201,8 @@ export function validate_config(config) {
 		}
 
 		if (
-			validated.kit.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
-			!validated.kit.csp?.directives?.['trusted-types']?.includes('svelte-trusted-html')
+			validated.csp?.directives?.['require-trusted-types-for']?.includes('script') &&
+			!validated.csp?.directives?.['trusted-types']?.includes('svelte-trusted-html')
 		) {
 			throw new Error(
 				"The `csp.directives['trusted-types']` option must include 'svelte-trusted-html'"

package/src/core/config/options.js

@@ -1,5 +1,4 @@
-/** @import { SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
-/** @import { ValidatedKitConfig } from 'types' */
+/** @import { ValidatedConfig } from 'types' */
 /** @import { Validator } from './types.js' */
 import { styleText } from 'node:util';
 
@@ -37,38 +36,13 @@ const directives = object({
 	referrer: string_array()
 });
 
-/** @type {Validator<{ extensions: string[] } & SvelteConfig>} */
-export const validate_svelte_options = object(
-	{
-		extensions: validate(['.svelte'], (input, keypath) => {
-			if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
-				throw new Error(`${keypath} must be an array of strings`);
-			}
-
-			input.forEach((extension) => {
-				if (extension[0] !== '.') {
-					throw new Error(`Each member of ${keypath} must start with '.' — saw '${extension}'`);
-				}
-
-				if (!/^(\.[a-z0-9]+)+$/i.test(extension)) {
-					throw new Error(`File extensions must be alphanumeric — saw '${extension}'`);
-				}
-			});
-
-			return input;
-		})
-	},
-	true
-);
-
 const prerender_handler = validate(undefined, (input, keypath) => {
 	if (typeof input === 'function') return input;
 	if (['fail', 'warn', 'ignore'].includes(input)) return input;
 	throw new Error(`${keypath} should be "fail", "warn", "ignore" or a custom function`);
 });
 
-/** @type {Validator<ValidatedKitConfig>} */
-export const validate_kit_options = object({
+const options = {
 	adapter: validate(undefined, (input, keypath) => {
 		if (typeof input !== 'object' || !input.adapt) {
 			const message = `The SvelteKit Vite plugin ${keypath} should be an object with an \`adapt\` method`;
@@ -110,6 +84,8 @@ export const validate_kit_options = object({
 		return input;
 	}),
 
+	compilerOptions: any(),
+
 	csp: object({
 		mode: list(['auto', 'hash', 'nonce']),
 		directives,
@@ -129,18 +105,39 @@ export const validate_kit_options = object({
 		dir: string('')
 	}),
 
-	experimental: object({
-		tracing: removed(
-			(keypath) =>
-				`\`${keypath}\` has been removed. Server-side tracing is now configured via \`tracing.server\``
-		),
-		instrumentation: removed(
-			(keypath) =>
-				`\`${keypath}\` has been removed. \`src/instrumentation.server.js\` is now included in the build automatically when it exists; no opt-in is required`
-		),
-		remoteFunctions: boolean(false),
-		forkPreloads: boolean(false),
-		handleRenderingErrors: removed()
+	experimental: object(
+		{
+			tracing: removed(
+				(keypath) =>
+					`\`${keypath}\` has been removed. Server-side tracing is now configured via \`tracing.server\``
+			),
+			instrumentation: removed(
+				(keypath) =>
+					`\`${keypath}\` has been removed. \`src/instrumentation.server.js\` is now included in the build automatically when it exists; no opt-in is required`
+			),
+			remoteFunctions: boolean(false),
+			forkPreloads: boolean(false),
+			handleRenderingErrors: removed()
+		},
+		true
+	),
+
+	extensions: validate(['.svelte'], (input, keypath) => {
+		if (!Array.isArray(input) || !input.every((page) => typeof page === 'string')) {
+			throw new Error(`${keypath} must be an array of strings`);
+		}
+
+		input.forEach((extension) => {
+			if (extension[0] !== '.') {
+				throw new Error(`Each member of ${keypath} must start with '.' — saw '${extension}'`);
+			}
+
+			if (!/^(\.[a-z0-9]+)+$/i.test(extension)) {
+				throw new Error(`File extensions must be alphanumeric — saw '${extension}'`);
+			}
+		});
+
+		return input;
 	}),
 
 	files: object({
@@ -166,6 +163,16 @@ export const validate_kit_options = object({
 
 	moduleExtensions: string_array(['.js', '.ts']),
 
+	kit: validate(undefined, (input) => {
+		const keys = Object.keys(input)
+			.map((key) => `\`${key}\``)
+			.join(', ');
+
+		throw new Error(
+			`SvelteKit configuration (${keys}) no longer lives inside a \`kit\` namespace. Pass it directly to the \`sveltekit(...)\` Vite plugin`
+		);
+	}),
+
 	outDir: string('.svelte-kit'),
 
 	output: object({
@@ -239,6 +246,8 @@ export const validate_kit_options = object({
 		relative: boolean(true)
 	}),
 
+	preprocess: any(),
+
 	prerender: object({
 		concurrency: number(1),
 		crawl: boolean(true),
@@ -298,8 +307,16 @@ export const validate_kit_options = object({
 	version: object({
 		name: string(Date.now().toString()),
 		pollInterval: number(3_600_000)
-	})
-});
+	}),
+
+	vitePlugin: removed(
+		(keypath) =>
+			`\`${keypath}\` has been removed. Pass \`vite-plugin-svelte\` options directly to the \`sveltekit(...)\` Vite plugin`
+	)
+};
+
+/** @type {Validator<ValidatedConfig>} */
+export const validate_options = object(options, true);
 
 /**
  * @param {Validator} fn
@@ -323,7 +340,7 @@ function deprecate(
 // Derive the names of SvelteKit's own config options from the schema, so they
 // stay in sync automatically. These are used to separate Kit's options from
 // `vite-plugin-svelte`'s options when config is passed via the Vite plugin.
-const kit_defaults = validate_kit_options({}, 'config');
+const kit_defaults = validate_options({}, 'config');
 
 /** The names of the options that live under the `kit` namespace */
 export const kit_options = Object.keys(kit_defaults);
@@ -363,7 +380,8 @@ export function object(children, allow_unknown = false) {
 		for (const key in input) {
 			if (!(key in children)) {
 				if (allow_unknown) {
-					output[key] = input[key];
+					const value = input[key];
+					if (value !== undefined) output[key] = value;
 				} else {
 					let message = `Unexpected option ${keypath}.${key}`;
 
@@ -485,6 +503,10 @@ function fun(fallback) {
 	});
 }
 
+function any() {
+	return validate(undefined, (input) => input);
+}
+
 /**
  * @param {string} input
  * @param {string} keypath

package/src/core/env.js

@@ -1,6 +1,6 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 /** @import { EnvVarConfig } from '@sveltejs/kit/env' */
-/** @import { ValidatedKitConfig } from 'types' */
+/** @import { ValidatedConfig } from 'types' */
 import path from 'node:path';
 import * as devalue from 'devalue';
 import { GENERATED_COMMENT } from '../constants.js';
@@ -16,7 +16,7 @@ import { get_runner } from '../runner.js';
  */
 
 /**
- * @param {import('types').ValidatedKitConfig} config
+ * @param {ValidatedConfig} config
  * @returns {string | null}
  */
 export function resolve_explicit_env_entry(config) {
@@ -25,7 +25,7 @@ export function resolve_explicit_env_entry(config) {
 
 /**
  * @param {typeof import('vite')} vite
- * @param {ValidatedKitConfig} kit
+ * @param {ValidatedConfig} kit
  * @param {string | null} file
  * @param {string} root
  * @param {string} mode

package/src/core/postbuild/analyse.js

@@ -38,7 +38,7 @@ async function analyse({
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	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 server_root = join(config.outDir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */

package/src/core/postbuild/prerender.js

@@ -153,7 +153,7 @@ async function prerender({
 
 	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';
 
@@ -275,8 +275,8 @@ async function prerender({
 	/** @type {Map<string, Promise<any>>} */
 	const remote_responses = new Map();
 
-	/** @type {(path: string) => void} */
-	let progress_line = noop;
+	/** @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
@@ -284,34 +284,51 @@ async function prerender({
 		// 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;
 
-		process.stdout.write = new Proxy(stdout_write, {
+		/** @type {ProxyHandler<typeof stdout_write>} */
+		const track_output = {
 			apply(target, this_arg, args) {
-				current = false;
+				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.stderr.write = new Proxy(stderr_write, {
-			apply(target, this_arg, args) {
-				current = false;
-				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;
 
-		progress_line = (path) => {
-			// 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) {
 				moveCursor(process.stdout, 0, -1);
 				clearLine(process.stdout, 0);
-			}
+			},
 
-			stdout_write.call(process.stdout, `rendering ${path}...\n`);
-			current = true;
+			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>} */
@@ -354,7 +371,17 @@ async function prerender({
 		/** @type {Map<string, import('types').PrerenderDependency>} */
 		const dependencies = new Map();
 
-		progress_line(decoded);
+		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);
 
@@ -693,6 +720,7 @@ async function prerender({
 	}
 
 	await q.done();
+	progress?.clear();
 
 	// handle invalid fragment links
 	for (const [key, referrers] of expected_hashlinks) {