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

package/src/core/postbuild/prerender.js

@@ -3,7 +3,6 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'no
 import { dirname, join } from 'node:path';
 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';
@@ -53,7 +52,7 @@ async function prerender({
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */
-	const { set_building, set_prerendering, set_manifest, set_read_implementation, log_response } =
+	const { set_building, set_prerendering, set_manifest, set_read_implementation, format_response } =
 		await import(pathToFileURL(`${out}/server/internal.js`).href);
 
 	// configure `import { building } from `$app/env` —
@@ -63,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);
 
@@ -256,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}`);
 		}
 	}
 
@@ -425,7 +424,7 @@ async function prerender({
 		}
 
 		if (response.status >= 400) {
-			log_response(response.status, request);
+			console.log(format_response(response.status, request));
 		}
 
 		const body = Buffer.from(await response.arrayBuffer());

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

@@ -1,44 +1,37 @@
 import path from 'node:path';
-import { hash } from '../../utils/hash.js';
 import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 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 {{
  *   server_hooks: string | null;
  *   universal_hooks: string | null;
  *   config: import('types').ValidatedConfig;
- *   has_service_worker: boolean;
  *   template: string;
+ *   runtime_directory: string;
  * }} opts
  */
 const server_template = ({
 	config,
 	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, format_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%')},
 	csp: ${s(config.csp)},
-	csrf_check_origin: ${s(!config.csrf.trustedOrigins.includes('*'))},
 	csrf_trusted_origins: ${s(config.csrf.trustedOrigins)},
-	embedded: ${config.embedded},
-	hash_routing: ${s(config.router.type === 'hash')},
-	hooks: null, // added lazily, via \`get_hooks\`
-	link_header_preload: ${s(config.output.linkHeaderPreload)},
-	paths_origin: ${s(config.paths.origin)},
-	service_worker: ${has_service_worker},
 	service_worker_options: ${config.serviceWorker.register ? s(config.serviceWorker.options) : 'null'},
 	templates: {
 		app: ({ head, body, assets, nonce, env }) => ${s(template)
@@ -52,9 +45,7 @@ export const options = {
 				(_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
 			)},
 		error
-	},
-	version: ${s(config.version.name)},
-	version_hash: ${s(hash(config.version.name))}
+	}
 };
 
 export async function get_hooks() {
@@ -78,7 +69,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, log_response };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, format_response };
 `;
 
 /**
@@ -103,7 +94,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,13 +107,12 @@ 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:
-				config.serviceWorker.register && !!resolve_entry(config.files.serviceWorker),
 			template: load_template(root, config)
 		})
 	);

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,10 +1,10 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
 import { to_fs } from '../utils/vite.js';
 import { noop } from '../utils/functions.js';
 import { posixify } from '../utils/os.js';
+import { hash } from '../utils/hash.js';
 
 /**
  * Resolved path of the `runtime` directory posix-ified
@@ -16,6 +16,15 @@ import { posixify } from '../utils/os.js';
  */
 export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
 
+/**
+ * The name of the `globalThis.__sveltekit_xxx` object the app's payload is attached to
+ * @param {string} version_name
+ * @param {boolean} dev
+ */
+export function get_global_name(version_name, dev) {
+	return dev ? '__sveltekit_dev' : `__sveltekit_${hash(version_name)}`;
+}
+
 /**
  * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
  * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
@@ -85,30 +94,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/adapter.js

@@ -0,0 +1,22 @@
+import { REROUTED_URL_HEADER } from '../constants.js';
+
+/**
+ * Helps a catch-all request handler pass the request to a different handler if
+ * the `reroute` hook has returned a URL pathname that's different from the
+ * incoming request.
+ *
+ * If your adapter is capable of deploying multiple serverless functions, it's a
+ * good idea to also deploy a "catch-all" one to handle uncaught requests.
+ * Running this in that function allows the app's `reroute` hook to rewrite
+ * the request URL and invoke the next appropriate serverless function, if any.
+ * @param {Response} response The response returned from the SvelteKit `server.respond` function
+ * @param {(url: URL) => Response | Promise<Response>} next Your platform-specific implementation for invoking the next handler with a different request URL
+ * @returns {Response | Promise<Response>}
+ * @since 3.0.0
+ */
+export function applyReroute(response, next) {
+	const rerouted_url = response.headers.get(REROUTED_URL_HEADER);
+	if (!rerouted_url) return response;
+
+	return next(new URL(rerouted_url));
+}

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'> & {