@sveltejs/kit 3.0.0-next.13 → 3.0.0-next.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.13",
+  "version": "3.0.0-next.16",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -30,12 +30,12 @@
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@playwright/test": "~1.61.0",
+    "@playwright/test": "^1.62.0",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@types/connect": "^3.4.38",
     "@types/node": "^22.19.19",
     "dts-buddy": "^0.8.3",
-    "jsdom": "^29.1.1",
+    "jsdom": "^30.0.0",
     "rolldown": "^1.2.0",
     "svelte": "^5.56.3",
     "svelte-preprocess": "^6.0.5",
@@ -71,6 +71,9 @@
     "svelte-kit.js"
   ],
   "imports": {
+    "#app/internal/transport": {
+      "default": "./src/runtime/app/internal/transport.js"
+    },
     "#app/paths": {
       "workerd": "./src/runtime/app/paths/server.js",
       "browser": "./src/runtime/app/paths/client.js",
@@ -127,7 +130,7 @@
   },
   "types": "types/index.d.ts",
   "engines": {
-    "node": ">=22"
+    "node": ">=22.17"
   },
   "scripts": {
     "lint": "prettier --config ../../.prettierrc --check .",

package/src/cli.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { parseArgs, styleText } from 'node:util';
 import { extract_svelte_config, load_vite_config } from './core/config/index.js';
-import { coalesce_to_error } from './utils/error.js';
 import { resolve_explicit_env_entry } from './core/env.js';
+import { coalesce_to_error } from './utils/error.js';
+import { import_peer } from './utils/import.js';
 
 /** @param {unknown} e */
 function handle_error(e) {
@@ -75,10 +76,10 @@ if (!command) {
 }
 
 if (command === 'sync') {
-	// create placeholder node_modules/$app/tsconfig/tsconfig.json if necessary, to squelch warnings.
+	// create placeholder node_modules/$app/tsconfig.json if necessary, to squelch warnings.
 	// this isn't bulletproof — if someone has some esoteric config, it will continue
 	// to harmlessly warn — but we handle the 90% case and clean up after ourselves
-	const dir = 'node_modules/$app/tsconfig';
+	const dir = 'node_modules/$app';
 	const base_tsconfig = `${dir}/tsconfig.json`;
 	const base_tsconfig_json = '{}';
 
@@ -96,14 +97,16 @@ if (command === 'sync') {
 	}
 
 	try {
-		const vite_config = await load_vite_config(values.config);
+		const vite = /** @type {import('vite')} */ (await import_peer('vite', process.cwd()));
+
+		const vite_config = await load_vite_config(values.config, vite);
 		const sveltekit_config = extract_svelte_config(vite_config);
 
 		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(sveltekit_config.kit, explicit_env_entry, vite_config.root, values.mode);
+		await sync.env(vite, sveltekit_config.kit, explicit_env_entry, vite_config.root, values.mode);
 	} catch (error) {
 		handle_error(error);
 	} finally {

package/src/core/adapt/builder.js

@@ -5,12 +5,19 @@
 /** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger, RemoteChunk } from 'types' */
 import { loadEnv } from 'vite';
 import * as devalue from 'devalue';
-import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
+import {
+	createReadStream,
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	rmSync,
+	statSync
+} from 'node:fs';
 import { extname, resolve, join, dirname, relative } from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
-import { copy, rimraf, mkdirp } from '../../utils/filesystem.js';
+import { copy } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { generate_manifest } from '../generate_manifest/index.js';
 import { get_route_segments } from '../../utils/routing.js';
@@ -99,8 +106,8 @@ export function create_builder({
 
 	return {
 		log,
-		rimraf,
-		mkdirp,
+		rimraf: (dir) => rmSync(dir, { force: true, recursive: true }),
+		mkdirp: (dir) => mkdirSync(dir, { recursive: true }),
 		copy,
 
 		config,
@@ -109,16 +116,19 @@ export function create_builder({
 
 		async compress(directory) {
 			if (!existsSync(directory)) {
-				return;
+				return [];
 			}
 
-			const files = list_files(directory, (file) => extensions.includes(extname(file))).map(
-				(file) => resolve(directory, file)
-			);
+			const files = list_files(directory, (file) => extensions.includes(extname(file)));
 
 			await Promise.all(
-				files.flatMap((file) => [compress_file(file, 'gz'), compress_file(file, 'br')])
+				files.flatMap((file) => {
+					const abs = resolve(directory, file);
+					return [compress_file(abs, 'gz'), compress_file(abs, 'br')];
+				})
 			);
+
+			return files;
 		},
 
 		findServerAssets(route_data) {
@@ -268,7 +278,7 @@ export function create_builder({
 							exports: module.exports
 						});
 
-			rimraf(entrypoint);
+			rmSync(entrypoint, { force: true, recursive: true });
 			write(entrypoint, facade);
 		}
 	};

package/src/core/config/index.js

@@ -120,13 +120,12 @@ export function load_error_page(config) {
 
 /**
  * @param {string} [config]
+ * @param {typeof import('vite')} [vite]
  */
-export async function load_vite_config(config) {
-	const { resolveConfig } = /** @type {import('vite')} */ (
-		await import_peer('vite', process.cwd())
-	);
+export async function load_vite_config(config, vite) {
+	vite ??= /** @type {import('vite')} */ (await import_peer('vite', process.cwd()));
 
-	return resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
+	return vite.resolveConfig({ configFile: config }, 'build', process.env.MODE ?? 'production');
 }
 
 /**

package/src/core/env.js

@@ -2,7 +2,6 @@
 /** @import { EnvVarConfig } from '@sveltejs/kit' */
 /** @import { ValidatedKitConfig } from 'types' */
 import path from 'node:path';
-import * as vite from 'vite';
 import * as devalue from 'devalue';
 import { GENERATED_COMMENT } from '../constants.js';
 import { dedent } from './sync/utils.js';
@@ -25,13 +24,14 @@ export function resolve_explicit_env_entry(config) {
 }
 
 /**
+ * @param {typeof import('vite')} vite
  * @param {ValidatedKitConfig} kit
  * @param {string | null} file
  * @param {string} root
  * @param {string} mode
  * @returns {Promise<Record<string, EnvVarConfig<any>> | null>}
  */
-export async function load_explicit_env(kit, file, root, mode) {
+export async function load_explicit_env(vite, kit, file, root, mode) {
 	if (!file) return null;
 
 	const server = await vite.createServer({
@@ -53,7 +53,7 @@ export async function load_explicit_env(kit, file, root, mode) {
 	/** @type {Record<string, EnvVarConfig<any>>} */
 	let variables;
 
-	const runner = get_runner(server);
+	const runner = get_runner(vite, server);
 
 	/** @type {import('../runtime/app/env/internal.js')} */ (
 		await runner.import(`${runtime_directory}/app/env/internal.js`)

package/src/core/generate_manifest/index.js

@@ -94,6 +94,12 @@ export function generate_manifest({
 		mime_types[ext] ??= mime_lookup(ext) || '';
 	}
 
+	// record extensions that only exist in prerendered output, e.g. a prerendered favicon.ico
+	for (const pathname of prerendered) {
+		const ext = path.extname(pathname);
+		if (ext) mime_types[ext] ??= mime_lookup(ext) || '';
+	}
+
 	// prettier-ignore
 	// String representation of
 	/** @template {import('@sveltejs/kit').SSRManifest} T */

package/src/core/postbuild/entities.js

@@ -2236,7 +2236,7 @@ const entities = {
 	'zwnj;': '‌'
 };
 
-const numeric = /&#(x)?([0-9a-f]+);/i;
+const numeric = /&#(x)?([0-9a-f]+);/gi;
 const named = new RegExp(
 	`&(${Object.keys(entities)
 		.sort((a, b) => b.length - a.length)
@@ -2247,6 +2247,12 @@ const named = new RegExp(
 /** @param {string} str */
 export function decode(str) {
 	return str
-		.replace(numeric, (_match, hex, code) => String.fromCharCode(hex ? parseInt(code, 16) : +code))
+		.replace(numeric, (_match, hex, code) => {
+			const codepoint = hex ? parseInt(code, 16) : +code;
+			// mirror the HTML parser, which replaces invalid numeric references with U+FFFD
+			return Number.isInteger(codepoint) && codepoint <= 0x10ffff
+				? String.fromCodePoint(codepoint)
+				: '\ufffd';
+		})
 		.replace(named, (_match, entity) => entities[entity]);
 }

package/src/core/postbuild/fallback.js

@@ -39,7 +39,8 @@ async function generate_fallback({ manifest_path, env, out_dir, origin, assets }
 		prerendering: {
 			fallback: true,
 			dependencies: new Map(),
-			remote_responses: new Map()
+			remote_responses: new Map(),
+			resolved_route_ids: new Set()
 		},
 		read: (file) => readFileSync(join(assets, file))
 	});

package/src/core/postbuild/prerender.js

@@ -1,7 +1,7 @@
-import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { mkdirp, walk } from '../../utils/filesystem.js';
+import { walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { noop } from '../../utils/functions.js';
 import { decode_uri, is_root_relative, resolve } from '../../utils/url.js';
@@ -17,6 +17,7 @@ import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
 import { log_response } from '../../exports/vite/utils.js';
+import { matches_content_type } from '../../utils/http.js';
 
 export default forked(import.meta.url, prerender);
 
@@ -156,7 +157,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const file = output_filename('/', true);
 		const dest = `${config.outDir}/output/prerendered/pages/${file}`;
 
-		mkdirp(dirname(dest));
+		mkdirSync(dirname(dest), { recursive: true });
 		writeFileSync(dest, fallback);
 
 		prerendered.pages.set('/', { file });
@@ -262,6 +263,9 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	/** @type {Map<string, Promise<any>>} */
 	const remote_responses = new Map();
 
+	/** @type {Set<string>} */
+	const resolved_route_ids = new Set();
+
 	/** @type {Map<string, Set<string>>} */
 	const expected_hashlinks = new Map();
 
@@ -307,7 +311,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 			},
 			prerendering: {
 				dependencies,
-				remote_responses
+				remote_responses,
+				resolved_route_ids
 			},
 			read: (file) => {
 				// stuff we just wrote
@@ -387,7 +392,11 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		// if it's a 200 HTML response, crawl it. Skip error responses, as we don't save those
-		if (response.ok && config.prerender.crawl && headers['content-type'] === 'text/html') {
+		if (
+			response.ok &&
+			config.prerender.crawl &&
+			matches_content_type(headers['content-type'], 'text/html')
+		) {
 			const { ids, hrefs, invalid } = crawl(body.toString(), decoded);
 
 			for (const href of invalid) {
@@ -444,7 +453,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		const headers = Object.fromEntries(response.headers);
 
 		const type = headers['content-type'];
-		const is_html = response_type === REDIRECT || type === 'text/html';
+		const is_html = response_type === REDIRECT || matches_content_type(type, 'text/html');
 
 		if (!is_html && response.status === 200 && decoded.slice(config.paths.base.length + 1) === '') {
 			throw new Error(
@@ -471,7 +480,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				}
 
 				if (!headers['x-sveltekit-normalize']) {
-					mkdirp(dirname(dest));
+					mkdirSync(dirname(dest), { recursive: true });
 
 					writeFileSync(
 						dest,
@@ -517,7 +526,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 				);
 			}
 
-			mkdirp(dir);
+			mkdirSync(dir, { recursive: true });
 
 			writeFileSync(dest, body);
 			written.add(file);
@@ -620,14 +629,10 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		}
 	}
 
-	const transport = (await internal.get_hooks()).transport ?? {};
 	for (const internals of prerender_functions) {
 		if (internals.has_arg) {
 			for (const arg of (await internals.inputs?.()) ?? []) {
-				void enqueue(
-					null,
-					remote_prefix + internals.id + '/' + stringify_remote_arg(arg, transport)
-				);
+				void enqueue(null, remote_prefix + internals.id + '/' + stringify_remote_arg(arg));
 			}
 		} else {
 			void enqueue(null, remote_prefix + internals.id);

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

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

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

@@ -41,6 +41,34 @@ export default function create_manifest_data({
 	};
 }
 
+/**
+ * Whether this route has a `+page`. Independent of `is_endpoint_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_page_route(route) {
+	return !!route.page;
+}
+
+/**
+ * Whether this route has a `+server`. Independent of `is_page_route` — a route can be both.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_endpoint_route(route) {
+	return !!route.endpoint;
+}
+
+/**
+ * Whether the router can match this route. `manifest_data.routes` also contains entries for
+ * directories with layouts or errors, which never reach `event.route.id`.
+ * @param {import('types').RouteData} route
+ * @returns {boolean}
+ */
+export function is_app_route(route) {
+	return is_page_route(route) || is_endpoint_route(route);
+}
+
 /**
  * Returns a list of files in the `static` directory.
  * @param {import('types').ValidatedConfig} config
@@ -85,7 +113,7 @@ function resolve_params(config, cwd) {
  */
 function create_routes_and_nodes(cwd, config, fallback) {
 	/** @type {import('types').RouteData[]} */
-	const routes = [];
+	let routes = [];
 
 	const routes_base = posixify(path.relative(cwd, config.kit.files.routes));
 
@@ -125,7 +153,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 						);
 					}
 
-					return String.fromCharCode(parseInt(code, 16));
+					return String.fromCodePoint(parseInt(code, 16));
 				}
 			});
 
@@ -440,6 +468,9 @@ function create_routes_and_nodes(cwd, config, fallback) {
 		}
 	}
 
+	// remove route objects with no route file
+	routes = routes.filter((route) => route.endpoint || route.leaf || route.layout || route.error);
+
 	// add parents to error nodes so that we can compute which page options apply to them
 	for (const route of routes) {
 		if (!route.error) continue;

package/src/core/sync/sync.js

@@ -89,13 +89,14 @@ export function all_types(config, root) {
 
 /**
  * Generate modules and types for explicit env vars
+ * @param {typeof import('vite')} vite
  * @param {import('types').ValidatedKitConfig} kit
  * @param {string | null} entry
  * @param {string} root The Vite root
  * @param {string} mode The Vite mode
  */
-export async function env(kit, entry, root, mode) {
-	const env_config = await load_explicit_env(kit, entry, root, mode);
+export async function env(vite, kit, entry, root, mode) {
+	const env_config = await load_explicit_env(vite, kit, entry, root, mode);
 
 	write_env(entry, env_config, root);
 

package/src/core/sync/utils.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
-import { mkdirp, resolve_entry } from '../../utils/filesystem.js';
+import { resolve_entry } from '../../utils/filesystem.js';
 
 /** @type {Map<string, string>} */
 const previous_contents = new Map();
@@ -22,7 +22,7 @@ export function write_if_changed(file, code) {
  */
 export function write(file, code) {
 	previous_contents.set(file, code);
-	mkdirp(path.dirname(file));
+	fs.mkdirSync(path.dirname(file), { recursive: true });
 	fs.writeFileSync(file, code);
 }
 

package/src/core/sync/write_app_types.js

@@ -4,15 +4,42 @@ import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { write_if_changed } from './utils.js';
 import { s } from '../../utils/misc.js';
-import { get_route_segments } from '../../utils/routing.js';
-
-const replace_optional_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[\[[^\]]+\]\]/g, '${string}');
-const replace_required_params = (/** @type {string} */ id) =>
-	id.replace(/\/\[[^\]]+\]/g, '/${string}');
-/** Convert route ID to pathname by removing layout groups */
-const remove_group_segments = (/** @type {string} */ id) => {
-	return '/' + get_route_segments(id).join('/');
+import {
+	decode_escape_sequence,
+	encode_pathname_chars,
+	get_route_segments,
+	segment_pattern
+} from '../../utils/routing.js';
+import { is_app_route, is_endpoint_route, is_page_route } from './create_manifest_data/index.js';
+
+const optional_param_pattern = /^\[\[[\w-]+(?:=[\w-]+)?\]\]$/;
+const rest_param_pattern = /^\[\.\.\.[\w-]+(?:=[\w-]+)?\]$/;
+
+/**
+ * Convert a route ID to the pathnames it can match (relative to the base path), in which each
+ * param is replaced with `${string}` and each escape sequence is expanded. A param that fills an
+ * entire segment can be absent, so it contributes a pathname with the segment and one without,
+ * rather than one that absorbs the `/`
+ * @param {string} id
+ */
+const get_pathname_patterns = (id) => {
+	let pathnames = [''];
+
+	for (const segment of get_route_segments(id)) {
+		const omittable = optional_param_pattern.test(segment) || rest_param_pattern.test(segment);
+		const content = omittable
+			? '${string}'
+			: segment.replace(segment_pattern, (_, escape_type, escape_code) =>
+					escape_type ? encode_pathname_chars(decode_escape_sequence(escape_code)) : '${string}'
+				);
+
+		pathnames = pathnames.flatMap((pathname) => {
+			const joined = pathname === '' ? content : `${pathname}/${content}`;
+			return omittable ? [joined, pathname] : [joined];
+		});
+	}
+
+	return [...new Set(pathnames)];
 };
 
 /**
@@ -142,6 +169,15 @@ function generate_app_types(manifest_data, config, dir) {
 	/** @type {Set<string>} */
 	const pathnames = new Set();
 
+	/** @type {string[]} */
+	const page_route_ids = [];
+
+	/** @type {string[]} */
+	const endpoint_route_ids = [];
+
+	/** @type {string[]} */
+	const app_route_ids = [];
+
 	/** @type {string[]} */
 	const dynamic_routes = [];
 
@@ -150,15 +186,17 @@ function generate_app_types(manifest_data, config, dir) {
 
 	/** @type {Map<string, Map<string, { optional: boolean, matchers: Set<string> | null }>>} */
 	const layout_params_by_route = new Map(
-		manifest_data.routes.map((route) => [
-			route.id,
-			new Map(
-				route.params.map((p) => [
-					p.name,
-					{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
-				])
-			)
-		])
+		manifest_data.routes
+			.filter((route) => route.layout)
+			.map((route) => [
+				route.id,
+				new Map(
+					route.params.map((p) => [
+						p.name,
+						{ optional: p.optional, matchers: p.matcher ? new Set([p.matcher]) : null }
+					])
+				)
+			])
 	);
 
 	for (const route of manifest_data.routes) {
@@ -192,8 +230,11 @@ function generate_app_types(manifest_data, config, dir) {
 	}
 
 	for (const route of manifest_data.routes) {
-		const pathname = remove_group_segments(route.id);
-		let normalized_pathname = pathname.slice(1);
+		const id = s(route.id);
+
+		if (is_page_route(route)) page_route_ids.push(id);
+		if (is_endpoint_route(route)) endpoint_route_ids.push(id);
+		if (is_app_route(route)) app_route_ids.push(id);
 
 		/** @type {(path: string) => string} */
 		let serialise = s;
@@ -203,16 +244,18 @@ function generate_app_types(manifest_data, config, dir) {
 				const type = get_matcher_type(p.matcher);
 				return `${/^\w+$/.test(p.name) ? p.name : `'${p.name}'`}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
 			});
-			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
 
-			dynamic_routes.push(route_type);
+			if (is_app_route(route)) {
+				dynamic_routes.push(`${s(route.id)}: { ${params.join('; ')} }`);
+			}
 
-			normalized_pathname = replace_required_params(replace_optional_params(pathname)).slice(1);
 			serialise = (p) => `\`${p}\` & {}`;
 		}
 
-		for (const p of get_pathnames_for_trailing_slash(normalized_pathname, route)) {
-			pathnames.add(serialise(p));
+		for (const pathname of get_pathname_patterns(route.id)) {
+			for (const p of get_pathnames_for_trailing_slash(pathname, route)) {
+				pathnames.add(serialise(p));
+			}
 		}
 
 		let layout_type = 'Record<string, never>';
@@ -229,7 +272,7 @@ function generate_app_types(manifest_data, config, dir) {
 			if (params.length > 0) layout_type = `{ ${params} }`;
 		}
 
-		layouts.push(`${s(route.id)}: ${layout_type}`);
+		if (route.layout) layouts.push(`${s(route.id)}: ${layout_type}`);
 	}
 
 	const assets = manifest_data.assets.map((asset) => s(asset.file));
@@ -237,7 +280,9 @@ function generate_app_types(manifest_data, config, dir) {
 	return [
 		'declare module "$app/types" {',
 		'\texport interface AppTypes {',
-		`\t\tRouteId(): ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
+		`\t\tPageRouteId(): ${page_route_ids.join(' | ') || 'never'};`,
+		`\t\tEndpointRouteId(): ${endpoint_route_ids.join(' | ') || 'never'};`,
+		`\t\tRouteId(): ${app_route_ids.join(' | ') || 'never'};`,
 		`\t\tRouteParams(): {\n\t\t\t${dynamic_routes.join(';\n\t\t\t')}\n\t\t};`,
 		`\t\tLayoutParams(): {\n\t\t\t${layouts.join(';\n\t\t\t')}\n\t\t};`,
 		`\t\tPath(): ${Array.from(pathnames).join(' | ')};`,