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

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/node/index.js

@@ -116,12 +116,13 @@ function get_raw_body(req, body_size_limit) {
 /**
  * @param {{
  *   request: import('http').IncomingMessage;
+ *   response?: import('http').ServerResponse;
  *   base: string;
  *   bodySizeLimit?: number;
  * }} options
  * @returns {Request}
  */
-export function getRequest({ request, base, bodySizeLimit }) {
+export function getRequest({ request, response, base, bodySizeLimit }) {
 	let headers = /** @type {Record<string, string>} */ (request.headers);
 	if (request.httpVersionMajor >= 2) {
 		// the Request constructor rejects headers with ':' in the name
@@ -144,6 +145,15 @@ export function getRequest({ request, base, bodySizeLimit }) {
 		}
 	});
 
+	// `readableAborted` stays false once the request has been fully read (or drained),
+	// so a client disconnect must also be detected on the response side. `writableEnded`
+	// rather than `writableFinished` because HTTP/2 marks cancelled streams as finished
+	response?.once('close', () => {
+		if (!response.writableEnded) {
+			controller.abort();
+		}
+	});
+
 	return new Request(base + request.url, {
 		// @ts-expect-error
 		duplex: 'half',
@@ -214,14 +224,14 @@ export function setResponse(res, response) {
 		}
 	}
 
-	res.writeHead(response.status);
-
 	if (!response.body) {
+		res.writeHead(response.status);
 		res.end();
 		return;
 	}
 
 	if (response.body.locked) {
+		res.writeHead(response.status);
 		res.end(
 			'Fatal error: Response body is locked. ' +
 				"This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
@@ -249,11 +259,73 @@ export function setResponse(res, response) {
 	res.on('close', cancel);
 	res.on('error', cancel);
 
-	void next();
+	/** @type {Uint8Array<ArrayBuffer>[]} */
+	const buffered = [];
+
+	/** @type {ReturnType<typeof reader.read> | null} */
+	let pending = null;
+
+	void probe();
+
+	// a fixed body (a string, buffer or blob, however constructed) settles all its
+	// reads before the next macrotask, so it can be measured and sent with a
+	// `content-length`; a genuine stream leaves a read pending and only has its
+	// headers delayed by a single tick
+	async function probe() {
+		try {
+			/** @type {Promise<undefined>} */
+			const deadline = new Promise((fulfil) => setImmediate(() => fulfil(undefined)));
+
+			while (buffered.length < 2) {
+				pending = reader.read();
+				const result = await Promise.race([pending, deadline]);
+
+				if (!result) break; // deadline hit — treat the body as a stream
+
+				pending = null;
+
+				if (result.done) {
+					// a `content-length` next to a `transfer-encoding` would be invalid
+					if (!res.hasHeader('content-length') && !res.hasHeader('transfer-encoding')) {
+						res.setHeader(
+							'content-length',
+							buffered.reduce((total, chunk) => total + chunk.byteLength, 0)
+						);
+					}
+					break;
+				}
+
+				buffered.push(result.value);
+			}
+
+			if (res.destroyed) return;
+
+			res.writeHead(response.status);
+			await next();
+		} catch (error) {
+			if (!res.headersSent) res.writeHead(response.status);
+			cancel(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+
 	async function next() {
 		try {
 			for (;;) {
-				const { done, value } = await reader.read();
+				/** @type {Awaited<ReturnType<typeof reader.read>>} */
+				let result;
+				if (buffered.length > 0) {
+					result = {
+						done: false,
+						value: /** @type {Uint8Array<ArrayBuffer>} */ (buffered.shift())
+					};
+				} else if (pending) {
+					result = await pending;
+					pending = null;
+				} else {
+					result = await reader.read();
+				}
+
+				const { done, value } = result;
 
 				if (done) break;
 

package/src/exports/vite/build/build_server.js

@@ -128,7 +128,7 @@ export function build_server_nodes(
 		/** @type {string[]} */
 		let stylesheets = [];
 
-		/** @type {string[]} */
+		/** @type {import('types').FontDependency[]} */
 		let fonts = [];
 
 		/** @type {Set<string>} */
@@ -187,7 +187,7 @@ export function build_server_nodes(
 			}
 
 			if (client_manifest) {
-				const entry_path = `${out_dir}/generated/client-optimized/nodes/${i}.js`;
+				const entry_path = `${out_dir}/generated/build/client-optimized/nodes/${i}.js`;
 				const entry = find_deps(client_manifest, entry_path, true, root);
 
 				// Eagerly load client stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
@@ -212,7 +212,7 @@ export function build_server_nodes(
 
 				imported = entry.imports;
 				stylesheets = Array.from(eager_css);
-				fonts = filter_fonts(Array.from(eager_assets));
+				fonts = filter_fonts(Array.from(eager_assets), client_manifest, root);
 			} else {
 				for (const entry of [component, universal]) {
 					if (!entry) continue;