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

package/src/core/postbuild/prerender.js

@@ -1,10 +1,8 @@
 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 { 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';
 import { escape_html } from '../../utils/escape.js';
@@ -64,7 +62,7 @@ async function prerender({
 
 	// `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')} */
+	/** @type {typeof import('<sveltekit:generated>/env/config.js')} */
 	const { set_env } = await import(pathToFileURL(`${out}/server/env.js`).href);
 	set_env(env);
 
@@ -257,13 +255,13 @@ async function prerender({
 		return file;
 	}
 
-	const files = new Set(walk(`${out}/client`).map(posixify));
+	const files = new Set(walk(`${out}/client`));
 	files.add(`${config.appDir}/env.js`);
 
 	const immutable = `${config.appDir}/immutable`;
 	if (existsSync(`${out}/server/${immutable}`)) {
 		for (const file of walk(`${out}/server/${immutable}`)) {
-			files.add(posixify(`${config.appDir}/immutable/${file}`));
+			files.add(`${config.appDir}/immutable/${file}`);
 		}
 	}
 
@@ -283,26 +281,31 @@ async function prerender({
 		// 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
+		const { stdout, stderr } = process;
+
 		let current = false;
-		let mid_line = false;
-		const stdout_write = process.stdout.write;
-		const stderr_write = process.stderr.write;
+		let needs_newline = true;
+
+		const write = stdout.write;
+
+		/** @param {string} value */
+		const print = (value) => write.call(stdout, value);
 
-		/** @type {ProxyHandler<typeof stdout_write>} */
-		const track_output = {
+		/** @type {ProxyHandler<typeof stdout.write>} */
+		const intercept = {
 			apply(target, this_arg, args) {
 				const chunk = args[0];
 				if (chunk.length > 0) {
 					current = false;
-					mid_line =
+					needs_newline =
 						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);
+		stdout.write = new Proxy(stdout.write, intercept);
+		stderr.write = new Proxy(stderr.write, intercept);
 
 		progress = {
 			clear: () => {
@@ -310,25 +313,21 @@ async function prerender({
 				// the previous progress log, because that will corrupt things
 				if (!current) return;
 
-				moveCursor(process.stdout, 0, -1);
-				clearLine(process.stdout, 0);
+				print('\x1B[1A'); // move cursor to start of progress update
+				print('\x1B[2K'); // clear current line
 			},
 
 			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');
-				}
+				// if we're in the middle of a line, start a new one
+				if (needs_newline) print('\n');
 
-				stdout_write.call(process.stdout, `crawling ${path}\n`);
+				print(`crawling ${path}\n`);
 				current = true;
-				mid_line = false;
+				needs_newline = false;
 			},
 
 			updated: 0
 		};
-
-		console.log('');
 	}
 
 	/** @type {Set<string>} */

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

@@ -1,11 +1,12 @@
+/** @import { ValidatedConfig } from 'types' */
 import { lookup } from '../../../utils/mime.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
-import { resolve_entry } from '../../../utils/filesystem.js';
+import { resolve_entry, walk } from '../../../utils/filesystem.js';
 import { posixify } from '../../../utils/os.js';
 import { parse_route_id } from '../../../utils/routing.js';
-import { list_files, runtime_directory } from '../../utils.js';
+import { runtime_directory } from '../../utils.js';
 import { prevent_conflicts } from './conflict.js';
 import { sort_routes } from './sort.js';
 import {
@@ -13,24 +14,27 @@ import {
 	get_page_options
 } from '../../../exports/vite/static_analysis/index.js';
 
+const component_name_pattern = /^\+(?:(page(?:@(.*))?)|(layout(?:@(.*))?)|(error))$/;
+
+const module_name_pattern =
+	/^\+(?:(server)|(page(?:(@[a-zA-Z0-9_-]*))?(\.server)?)|(layout(?:(@[a-zA-Z0-9_-]*))?(\.server)?))$/;
+
 /**
  * Generates the manifest data used for the client-side manifest and types generation.
- * @param {{
- *   config: import('types').ValidatedConfig;
- *   fallback?: string;
- *   cwd: string;
- * }} opts
+ * @param {ValidatedConfig} config
+ * @param {string} root
+ * @param {string} [fallback] Where to look for fallback components
  * @returns {import('types').ManifestData}
  */
-export default function create_manifest_data({
+export default function create_manifest_data(
 	config,
-	fallback = `${runtime_directory}/components`,
-	cwd
-}) {
+	root,
+	fallback = `${runtime_directory}/components`
+) {
 	const assets = create_assets(config);
-	const hooks = create_hooks(config, cwd);
-	const params = resolve_params(config, cwd);
-	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
+	const hooks = create_hooks(config, root);
+	const params = resolve_params(config, root);
+	const { nodes, routes } = create_routes_and_nodes(root, config, fallback);
 
 	return {
 		assets,
@@ -74,7 +78,9 @@ export function is_app_route(route) {
  * @param {import('types').ValidatedConfig} config
  */
 export function create_assets(config) {
-	return list_files(config.files.assets).map((file) => ({
+	if (!fs.existsSync(config.files.assets)) return [];
+
+	return [...walk(config.files.assets)].map((file) => ({
 		file,
 		size: fs.statSync(path.resolve(config.files.assets, file)).size,
 		type: lookup(file) || null
@@ -232,13 +238,12 @@ function create_routes_and_nodes(cwd, config, fallback) {
 
 				if (!file.name.startsWith('+')) {
 					const name = file.name.slice(0, -ext.length);
+					const pattern = config.extensions.includes(ext)
+						? component_name_pattern
+						: module_name_pattern;
+
 					// check if it is a valid route filename but missing the + prefix
-					const typo =
-						/^(?:(page(?:@(.*))?)|(layout(?:@(.*))?)|(error))$/.test(name) ||
-						/^(?:(server)|(page(?:(@[a-zA-Z0-9_-]*))?(\.server)?)|(layout(?:(@[a-zA-Z0-9_-]*))?(\.server)?))$/.test(
-							name
-						);
-					if (typo) {
+					if (pattern.test(`+${name}`)) {
 						console.log(
 							styleText(
 								['bold', 'yellow'],
@@ -265,13 +270,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 					const ext = valid_extensions.find((ext) => name.endsWith(ext));
 					if (ext) name = name.slice(0, -ext.length);
 
-					const valid =
-						/^\+(?:(page(?:@(.*))?)|(layout(?:@(.*))?)|(error))$/.test(name) ||
-						/^\+(?:(server)|(page(?:(@[a-zA-Z0-9_-]*))?(\.server)?)|(layout(?:(@[a-zA-Z0-9_-]*))?(\.server)?))$/.test(
-							name
-						);
-
-					if (valid) continue;
+					if (component_name_pattern.test(name) || module_name_pattern.test(name)) continue;
 				}
 
 				const project_relative = posixify(path.relative(cwd, path.join(dir, file.name)));
@@ -535,8 +534,7 @@ function analyze(project_relative, file, component_extensions, module_extensions
 	const component_extension = component_extensions.find((ext) => file.endsWith(ext));
 	if (component_extension) {
 		const name = file.slice(0, -component_extension.length);
-		const pattern = /^\+(?:(page(?:@(.*))?)|(layout(?:@(.*))?)|(error))$/;
-		const match = pattern.exec(name);
+		const match = component_name_pattern.exec(name);
 		if (!match) {
 			throw new Error(`Files prefixed with + are reserved (saw ${project_relative})`);
 		}
@@ -553,9 +551,7 @@ function analyze(project_relative, file, component_extensions, module_extensions
 	const module_extension = module_extensions.find((ext) => file.endsWith(ext));
 	if (module_extension) {
 		const name = file.slice(0, -module_extension.length);
-		const pattern =
-			/^\+(?:(server)|(page(?:(@[a-zA-Z0-9_-]*))?(\.server)?)|(layout(?:(@[a-zA-Z0-9_-]*))?(\.server)?))$/;
-		const match = pattern.exec(name);
+		const match = module_name_pattern.exec(name);
 		if (!match) {
 			throw new Error(`Files prefixed with + are reserved (saw ${project_relative})`);
 		} else if (match[3] || match[6]) {

package/src/core/sync/sync.js

@@ -1,3 +1,4 @@
+/** @import { ValidatedConfig, ManifestData } from 'types' */
 import path from 'node:path';
 import create_manifest_data from './create_manifest_data/index.js';
 import { write_client_manifest } from './write_client_manifest.js';
@@ -11,39 +12,30 @@ import {
 } from '../../exports/vite/static_analysis/index.js';
 import { load_explicit_env } from '../env.js';
 import { write_env } from './write_env.js';
-
-/**
- * Initialize SvelteKit's generated files that only depend on the config and mode.
- * @param {import('types').ValidatedConfig} config
- * @param {string} root The project root directory
- */
-export function init(config, root) {
-	write_tsconfig(config, root);
-}
+import { write_app_manifest } from './write_app_manifest.js';
 
 /**
  * Update SvelteKit's generated files
- * @param {import('types').ValidatedConfig} config
+ * @param {ValidatedConfig} config
  * @param {string} root The project root directory
+ * @param {ManifestData} manifest_data
+ * @param {boolean} is_build
  */
-export function create(config, root) {
-	const manifest_data = create_manifest_data({ config, cwd: root });
+export function create(config, root, manifest_data, is_build) {
+	const output = path.join(config.outDir, `generated/${is_build ? 'build' : 'dev'}`);
 
-	const output = path.join(config.outDir, 'generated');
-
-	write_client_manifest(config, manifest_data, `${output}/client`);
+	write_app_manifest(output, manifest_data, is_build);
+	write_client_manifest(config, manifest_data, `${output}/client`, root);
 	write_server(config, output, root);
 	write_all_types(config, manifest_data, root);
 	write_app_types(config, manifest_data, root);
-
-	return { manifest_data };
 }
 
 /**
  * Update SvelteKit's generated files in response to a single file content update.
  * Do not call this when the file in question was created/deleted.
  *
- * @param {import('types').ValidatedConfig} config
+ * @param {ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
  * @param {string} file
  * @param {string} root The project root directory
@@ -79,48 +71,39 @@ export function update(config, manifest_data, file, root) {
 }
 
 /**
- * Run sync.init and sync.create in series, returning the result from sync.create.
- * @param {import('types').ValidatedConfig} config
+ * Run write_tsconfig and sync.create in series during build
+ * @param {ValidatedConfig} config
  * @param {string} root The project root directory
+ * @param {ManifestData} manifest_data
  */
-export function all(config, root) {
-	init(config, root);
-	return create(config, root);
+export function all(config, root, manifest_data) {
+	write_tsconfig(config, root);
+	create(config, root, manifest_data, true);
 }
 
 /**
  * Run sync.init and then generate all type files.
- * @param {import('types').ValidatedConfig} config
+ * @param {ValidatedConfig} config
  * @param {string} root
  */
 export function all_types(config, root) {
-	init(config, root);
-	const manifest_data = create_manifest_data({ config, cwd: root });
+	write_tsconfig(config, root);
+	const manifest_data = create_manifest_data(config, root);
 	write_all_types(config, manifest_data, root);
 	write_app_types(config, manifest_data, root);
 }
 
 /**
  * Generate modules and types for explicit env vars
- * @param {typeof import('vite')} vite
- * @param {import('types').ValidatedConfig} kit
+ * @param {ValidatedConfig} kit
  * @param {string | null} entry
  * @param {string} root The Vite root
  * @param {string} mode The Vite mode
  */
-export async function env(vite, kit, entry, root, mode) {
-	const env_config = await load_explicit_env(vite, kit, entry, root, mode);
+export async function env(kit, entry, root, mode) {
+	const env_config = await load_explicit_env(kit, entry, root, mode);
 
-	write_env(entry, env_config, root);
+	write_env(entry, env_config.variables, root);
 
 	return env_config;
 }
-
-/**
- * Regenerate __SERVER__/internal.js in response to src/{app.html,error.html,service-worker.js} changing
- * @param {import('types').ValidatedConfig} config
- * @param {string} root The project root directory
- */
-export function server(config, root) {
-	write_server(config, path.join(config.outDir, 'generated'), root);
-}

package/src/core/sync/write_app_manifest.js

@@ -0,0 +1,83 @@
+/** @import { Asset, ManifestData, RouteData } from 'types' */
+
+import { s } from '../../utils/misc.js';
+import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
+import { dedent, write_if_changed } from './utils.js';
+
+/**
+ * Creates the `$app/manifest` data module. During development, real values
+ * are emitted for `assets` and `routes` (the only data known at that point).
+ *
+ * During build, bare identifier placeholders (fake globals) are emitted.
+ * The bundler leaves these as unresolved global references in the output,
+ * which are then replaced with real values by scanning the output chunks
+ * after each build completes. This avoids the content-hash feedback loop:
+ * the manifest data lives in its own chunk with a fixed filename, so
+ * importers' hashes are stable regardless of the manifest content.
+ *
+ * @param {string} out
+ * @param {ManifestData | undefined} manifest_data
+ * @param {boolean} is_build
+ */
+export function write_app_manifest(out, manifest_data, is_build) {
+	const code = is_build
+		? // Bare identifiers (fake globals) — the bundler leaves these as
+			// unresolved global references in the output. They are replaced
+			// with real values by `replace_manifest_placeholder_variables`
+			// after each build completes.
+			dedent`
+			export const immutable = __SVELTEKIT_MANIFEST_IMMUTABLE__;
+			export const assets = __SVELTEKIT_MANIFEST_ASSETS__;
+			export const prerendered = __SVELTEKIT_MANIFEST_PRERENDERED__;
+			export const routes = __SVELTEKIT_MANIFEST_ROUTES__;
+		`
+		: // In dev, an empty manifest is written before dependency scanning starts.
+			// `configureServer` replaces it with the full manifest before modules are served.
+			dedent`
+		// empty during dev
+		export const immutable = [];
+		export const prerendered = [];
+
+		export const assets = [
+			${stringify_assets(manifest_data?.assets)}
+		];
+
+		export const routes = [
+			${stringify_routes(manifest_data?.routes)}
+		];
+	`;
+
+	write_if_changed(`${out}/app-manifest.js`, code);
+}
+
+/**
+ * @param {Asset[] | undefined} assets
+ * @returns {string}
+ */
+function stringify_assets(assets) {
+	return assets?.map((asset) => s({ path: asset.file })).join(',\n') ?? '';
+}
+
+/**
+ * @param {RouteData[] | undefined} routes
+ * @returns {Array<{ id: string; page: boolean; endpoint: boolean }>}
+ */
+export function get_manifest_routes(routes) {
+	return (
+		routes?.filter(is_app_route).map((route) => ({
+			id: route.id,
+			page: is_page_route(route),
+			endpoint: is_endpoint_route(route)
+		})) ?? []
+	);
+}
+
+/**
+ * @param {RouteData[] | undefined} routes
+ * @returns {string}
+ */
+function stringify_routes(routes) {
+	return get_manifest_routes(routes)
+		.map((route) => s(route))
+		.join(',\n');
+}

package/src/core/sync/write_client_manifest.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { check_spelling, dedent, write_if_changed } from './utils.js';
 import { relative_path, resolve_entry } from '../../utils/filesystem.js';
 import { s } from '../../utils/misc.js';
@@ -8,9 +9,10 @@ import { s } from '../../utils/misc.js';
  * @param {import('types').ValidatedConfig} kit
  * @param {import('types').ManifestData} manifest_data
  * @param {string} output
+ * @param {string} root The project root directory
  * @param {import('types').ServerMetadata['nodes']} [metadata] If this is omitted, we have to assume that all routes with a `+layout/page.server.js` file have a server load function
  */
-export function write_client_manifest(kit, manifest_data, output, metadata) {
+export function write_client_manifest(kit, manifest_data, output, root, metadata) {
 	const client_routing = kit.router.resolution === 'client';
 
 	/**
@@ -22,7 +24,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 
 		if (node.universal) {
 			declarations.push(
-				`import * as universal from ${s(relative_path(`${output}/nodes`, node.universal))};`,
+				`import * as universal from ${s(relative_path(`${output}/nodes`, path.resolve(root, node.universal)))};`,
 				'export { universal };'
 			);
 		}
@@ -30,7 +32,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 		if (node.component) {
 			declarations.push(
 				`export { default as component } from ${s(
-					relative_path(`${output}/nodes`, node.component)
+					relative_path(`${output}/nodes`, path.resolve(root, node.component))
 				)};`
 			);
 		}
@@ -180,7 +182,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 		const module =
 			!manifest_data.params || !uses_matchers
 				? 'export const matchers = {};'
-				: `import { params as matchers } from ${s(relative_path(output, manifest_data.params))};\n\nexport { matchers };`;
+				: `import { params as matchers } from ${s(relative_path(output, path.resolve(root, manifest_data.params)))};\n\nexport { matchers };`;
 
 		write_if_changed(`${output}/matchers.js`, module);
 	}

package/src/core/sync/write_server.js

@@ -6,6 +6,7 @@ import { s } from '../../utils/misc.js';
 import { load_error_page, load_template } from '../config/index.js';
 import { check_spelling, write_if_changed } from './utils.js';
 import { escape_html } from '../../utils/escape.js';
+import { runtime_directory } from '../utils.js';
 
 /**
  * @param {{
@@ -14,6 +15,7 @@ import { escape_html } from '../../utils/escape.js';
  *   config: import('types').ValidatedConfig;
  *   has_service_worker: boolean;
  *   template: string;
+ *   runtime_directory: string;
  * }} opts
  */
 const server_template = ({
@@ -21,12 +23,13 @@ const server_template = ({
 	server_hooks,
 	universal_hooks,
 	has_service_worker,
-	template
+	template,
+	runtime_directory
 }) => `
-import { set_building, set_prerendering } from '$app/env/internal';
+import { set_building, set_prerendering } from '$app/env/server';
 import { set_assets } from '$app/paths/internal/server';
-import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '__sveltekit/server';
-import error from '../shared/error-template.js';
+import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '${runtime_directory}/server/internal.js';
+import error from './shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
@@ -103,7 +106,7 @@ export function write_server(config, output, root) {
 
 	/** @param {string} file */
 	function relative(file) {
-		return posixify(path.relative(`${output}/server`, file));
+		return posixify(path.relative(output, file));
 	}
 
 	write_if_changed(
@@ -116,9 +119,10 @@ export function write_server(config, output, root) {
 	// Contains the stringified version of
 	/** @type {import('types').SSROptions} */
 	write_if_changed(
-		`${output}/server/internal.js`,
+		`${output}/server.js`,
 		server_template({
 			config,
+			runtime_directory: relative(runtime_directory),
 			server_hooks: server_hooks_file ? relative(server_hooks_file) : null,
 			universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
 			has_service_worker:

package/src/core/sync/write_types/index.js

@@ -42,12 +42,12 @@ export function write_all_types(config, manifest_data, root) {
 		posixify(path.relative(root, config.files.routes))
 	);
 	const expected_directories = new Set(
-		manifest_data.routes.map((route) => path.join(routes_dir, route.id))
+		manifest_data.routes.map((route) => path.posix.join(routes_dir, route.id))
 	);
 
 	if (fs.existsSync(types_dir)) {
 		for (const file of walk(types_dir)) {
-			const dir = path.dirname(file);
+			const dir = path.posix.dirname(file);
 			if (!expected_directories.has(dir)) {
 				fs.rmSync(path.join(types_dir, file), { force: true, recursive: true });
 			}

package/src/core/utils.js

@@ -1,4 +1,3 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
@@ -85,30 +84,3 @@ export function get_mime_lookup(manifest_data) {
 
 	return mime;
 }
-
-/**
- * @param {string} dir
- * @param {(file: string) => boolean} [filter]
- */
-export function list_files(dir, filter) {
-	/** @type {string[]} */
-	const files = [];
-
-	/** @param {string} current */
-	function walk(current) {
-		for (const file of fs.readdirSync(path.resolve(dir, current))) {
-			const child = path.posix.join(current, file);
-			if (fs.statSync(path.resolve(dir, child)).isDirectory()) {
-				walk(child);
-			} else {
-				if (!filter || filter(child)) {
-					files.push(child);
-				}
-			}
-		}
-	}
-
-	if (fs.existsSync(dir)) walk('');
-
-	return files;
-}

package/src/exports/hooks/public.d.ts

@@ -170,9 +170,17 @@ export interface ResolveOptions {
 	 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
 	 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
 	 * By default, `js` and `css` files will be preloaded.
+	 *
+	 * For `font` files, `input` also has a `filename` property, the source file's pathname relative
+	 * to the project root, so that a filter can match on it instead of the hashed path. `js` and
+	 * `css` files are bundled and have no single source file name.
 	 * @param input the type of the file and its path
 	 */
-	preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
+	preload?: (
+		input:
+			| { type: 'css' | 'js' | 'asset'; path: string }
+			| { type: 'font'; path: string; filename: string }
+	) => boolean;
 }
 
 type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {

package/src/exports/index.js

@@ -270,6 +270,16 @@ export function invalid(...issues) {
 	);
 }
 
+/**
+ * Checks whether this is a validation error thrown by {@link invalid}.
+ * @param {unknown} e The object to check.
+ * @return {e is import('./public.js').ValidationError}
+ * @since 2.47.3
+ */
+export function isValidationError(e) {
+	return e instanceof ValidationError;
+}
+
 /**
  * Strips possible SvelteKit-internal suffixes and trailing slashes from the URL pathname.
  * Returns the normalized URL as well as a method for adding the potential suffix back