@sveltejs/kit 2.3.5 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.3.5",
+  "version": "2.4.1",
   "description": "The fastest way to build Svelte apps",
   "repository": {
     "type": "git",

package/src/core/adapt/builder.js

@@ -11,6 +11,7 @@ import { get_env } from '../../exports/vite/utils.js';
 import generate_fallback from '../postbuild/fallback.js';
 import { write } from '../sync/utils.js';
 import { list_files } from '../utils.js';
+import { find_server_assets } from '../generate_manifest/find_server_assets.js';
 
 const pipe = promisify(pipeline);
 const extensions = ['.html', '.js', '.mjs', '.json', '.css', '.svg', '.xml', '.wasm'];
@@ -145,6 +146,13 @@ export function create_builder({
 			}
 		},
 
+		findServerAssets(route_data) {
+			return find_server_assets(
+				build_data,
+				route_data.map((route) => /** @type {import('types').RouteData} */ (lookup.get(route)))
+			);
+		},
+
 		async generateFallback(dest) {
 			const manifest_path = `${config.kit.outDir}/output/server/manifest-full.js`;
 			const env = get_env(config.kit.env, vite_config.mode);

package/src/core/generate_manifest/find_server_assets.js

@@ -0,0 +1,52 @@
+import { find_deps } from '../../exports/vite/build/utils.js';
+
+/**
+ * Finds all the assets that are imported by server files associated with `routes`
+ * @param {import('types').BuildData} build_data
+ * @param {import('types').RouteData[]} routes
+ */
+export function find_server_assets(build_data, routes) {
+	/**
+	 * All nodes actually used in the routes definition (prerendered routes are omitted).
+	 * Root layout/error is always included as they are needed for 404 and root errors.
+	 * @type {Set<any>}
+	 */
+	const used_nodes = new Set([0, 1]);
+
+	// TODO add hooks.server.js asset imports
+	/** @type {Set<string>} */
+	const server_assets = new Set();
+
+	/** @param {string} id */
+	function add_assets(id) {
+		if (id in build_data.server_manifest) {
+			const deps = find_deps(build_data.server_manifest, id, false);
+			for (const asset of deps.assets) {
+				server_assets.add(asset);
+			}
+		}
+	}
+
+	for (const route of routes) {
+		if (route.page) {
+			for (const i of route.page.layouts) used_nodes.add(i);
+			for (const i of route.page.errors) used_nodes.add(i);
+			used_nodes.add(route.page.leaf);
+		}
+
+		if (route.endpoint) {
+			add_assets(route.endpoint.file);
+		}
+	}
+
+	for (const n of used_nodes) {
+		const node = build_data.manifest_data.nodes[n];
+		if (node?.server) add_assets(node.server);
+	}
+
+	if (build_data.manifest_data.hooks.server) {
+		add_assets(build_data.manifest_data.hooks.server);
+	}
+
+	return Array.from(server_assets);
+}

package/src/core/generate_manifest/index.js

@@ -1,9 +1,13 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as mime from 'mrmime';
 import { s } from '../../utils/misc.js';
 import { get_mime_lookup } from '../utils.js';
 import { resolve_symlinks } from '../../exports/vite/build/utils.js';
 import { compact } from '../../utils/array.js';
 import { join_relative } from '../../utils/filesystem.js';
 import { dedent } from '../sync/utils.js';
+import { find_server_assets } from './find_server_assets.js';
 
 /**
  * Generates the data used to write the server-side manifest.js file. This data is used in the Vite
@@ -26,6 +30,8 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 	 */
 	const used_nodes = new Set([0, 1]);
 
+	const server_assets = find_server_assets(build_data, routes);
+
 	for (const route of routes) {
 		if (route.page) {
 			for (const i of route.page.layouts) used_nodes.add(i);
@@ -63,6 +69,17 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 		return `[${string},]`;
 	}
 
+	const mime_types = get_mime_lookup(build_data.manifest_data);
+
+	/** @type {Record<string, number>} */
+	const files = {};
+	for (const file of server_assets) {
+		files[file] = fs.statSync(path.resolve(build_data.out_dir, 'server', file)).size;
+
+		const ext = path.extname(file);
+		mime_types[ext] ??= mime.lookup(ext) || '';
+	}
+
 	// prettier-ignore
 	// String representation of
 	/** @template {import('@sveltejs/kit').SSRManifest} T */
@@ -71,7 +88,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 			appDir: ${s(build_data.app_dir)},
 			appPath: ${s(build_data.app_path)},
 			assets: new Set(${s(assets)}),
-			mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
+			mimeTypes: ${s(mime_types)},
 			_: {
 				client: ${s(build_data.client)},
 				nodes: [
@@ -80,7 +97,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 				routes: [
 					${routes.map(route => {
 						if (!route.page && !route.endpoint) return;
-						
+
 						route.params.forEach(param => {
 							if (param.matcher) matchers.add(param.matcher);
 						});
@@ -98,11 +115,12 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 				],
 				matchers: async () => {
 					${Array.from(
-						matchers, 
+						matchers,
 						type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`
 					).join('\n')}
 					return { ${Array.from(matchers).join(', ')} };
-				}
+				},
+				server_assets: ${s(files)}
 			}
 		}
 	`;

package/src/core/postbuild/analyse.js

@@ -14,16 +14,22 @@ import { installPolyfills } from '../../exports/node/polyfills.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { resolve_route } from '../../utils/routing.js';
+import { get_page_config } from '../../utils/route_config.js';
+import { check_feature } from '../../utils/features.js';
+import { createReadableStream } from '@sveltejs/kit/node';
 
 export default forked(import.meta.url, analyse);
 
 /**
  * @param {{
  *   manifest_path: string;
+ *   manifest_data: import('types').ManifestData;
+ *   server_manifest: import('vite').Manifest;
+ *   tracked_features: Record<string, string[]>;
  *   env: Record<string, string>
  * }} opts
  */
-async function analyse({ manifest_path, env }) {
+async function analyse({ manifest_path, manifest_data, server_manifest, tracked_features, env }) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
@@ -48,6 +54,8 @@ async function analyse({ manifest_path, env }) {
 	internal.set_private_env(private_env);
 	internal.set_public_env(public_env);
 	internal.set_safe_public_env(public_env);
+	internal.set_manifest(manifest);
+	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -89,12 +97,26 @@ async function analyse({ manifest_path, env }) {
 			}
 		}
 
+		const route_config = page?.config ?? endpoint?.config ?? {};
+		const prerender = page?.prerender ?? endpoint?.prerender;
+
+		if (prerender !== true) {
+			for (const feature of list_features(
+				route,
+				manifest_data,
+				server_manifest,
+				tracked_features
+			)) {
+				check_feature(route.id, route_config, feature, config.adapter);
+			}
+		}
+
 		const page_methods = page?.methods ?? [];
 		const api_methods = endpoint?.methods ?? [];
 		const entries = page?.entries ?? endpoint?.entries;
 
 		metadata.routes.set(route.id, {
-			config: page?.config ?? endpoint?.config,
+			config: route_config,
 			methods: Array.from(new Set([...page_methods, ...api_methods])),
 			page: {
 				methods: page_methods
@@ -102,7 +124,7 @@ async function analyse({ manifest_path, env }) {
 			api: {
 				methods: api_methods
 			},
-			prerender: page?.prerender ?? endpoint?.prerender,
+			prerender,
 			entries:
 				entries && (await entries()).map((entry_object) => resolve_route(route.id, entry_object))
 		});
@@ -163,7 +185,7 @@ function analyse_page(layouts, leaf) {
 	validate_page_exports(leaf.universal, leaf.universal_id);
 
 	return {
-		config: get_config([...layouts, leaf]),
+		config: get_page_config([...layouts, leaf]),
 		entries: leaf.universal?.entries ?? leaf.server?.entries,
 		methods,
 		prerender: get_option([...layouts, leaf], 'prerender') ?? false
@@ -171,22 +193,51 @@ function analyse_page(layouts, leaf) {
 }
 
 /**
- * Do a shallow merge (first level) of the config object
- * @param {Array<import('types').SSRNode | undefined>} nodes
+ * @param {import('types').SSRRoute} route
+ * @param {import('types').ManifestData} manifest_data
+ * @param {import('vite').Manifest} server_manifest
+ * @param {Record<string, string[]>} tracked_features
  */
-function get_config(nodes) {
-	/** @type {any} */
-	let current = {};
+function list_features(route, manifest_data, server_manifest, tracked_features) {
+	const features = new Set();
 
-	for (const node of nodes) {
-		if (!node?.universal?.config && !node?.server?.config) continue;
+	const route_data = /** @type {import('types').RouteData} */ (
+		manifest_data.routes.find((r) => r.id === route.id)
+	);
 
-		current = {
-			...current,
-			...node?.universal?.config,
-			...node?.server?.config
-		};
+	/** @param {string} id */
+	function visit(id) {
+		const chunk = server_manifest[id];
+		if (!chunk) return;
+
+		if (chunk.file in tracked_features) {
+			for (const feature of tracked_features[chunk.file]) {
+				features.add(feature);
+			}
+		}
+
+		if (chunk.imports) {
+			for (const id of chunk.imports) {
+				visit(id);
+			}
+		}
+	}
+
+	let page_node = route_data?.leaf;
+	while (page_node) {
+		if (page_node.server) visit(page_node.server);
+		page_node = page_node.parent ?? null;
+	}
+
+	if (route_data.endpoint) {
+		visit(route_data.endpoint.file);
+	}
+
+	if (manifest_data.hooks.server) {
+		// TODO if hooks.server.js imports `read`, it will be in the entry chunk
+		// we don't currently account for that case
+		visit(manifest_data.hooks.server);
 	}
 
-	return Object.keys(current).length ? current : undefined;
+	return Array.from(features);
 }

package/src/core/postbuild/prerender.js

@@ -12,6 +12,7 @@ import { queue } from './queue.js';
 import { crawl } from './crawl.js';
 import { forked } from '../../utils/fork.js';
 import * as devalue from 'devalue';
+import { createReadableStream } from '@sveltejs/kit/node';
 
 export default forked(import.meta.url, prerender);
 
@@ -430,7 +431,10 @@ async function prerender({ out, manifest_path, metadata, verbose, env }) {
 	log.info('Prerendering');
 
 	const server = new Server(manifest);
-	await server.init({ env });
+	await server.init({
+		env,
+		read: (file) => createReadableStream(`${config.outDir}/output/server/${file}`)
+	});
 
 	for (const entry of config.prerender.entries) {
 		if (entry === '*') {

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

@@ -3,7 +3,7 @@ import path from 'node:path';
 import colors from 'kleur';
 import { lookup } from 'mrmime';
 import { list_files, runtime_directory } from '../../utils.js';
-import { posixify } from '../../../utils/filesystem.js';
+import { posixify, resolve_entry } from '../../../utils/filesystem.js';
 import { parse_route_id } from '../../../utils/routing.js';
 import { sort_routes } from './sort.js';
 
@@ -22,6 +22,7 @@ export default function create_manifest_data({
 	cwd = process.cwd()
 }) {
 	const assets = create_assets(config);
+	const hooks = create_hooks(config, cwd);
 	const matchers = create_matchers(config, cwd);
 	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
 
@@ -35,6 +36,7 @@ export default function create_manifest_data({
 
 	return {
 		assets,
+		hooks,
 		matchers,
 		nodes,
 		routes
@@ -52,6 +54,22 @@ export function create_assets(config) {
 	}));
 }
 
+/**
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} cwd
+ */
+function create_hooks(config, cwd) {
+	const client = resolve_entry(config.kit.files.hooks.client);
+	const server = resolve_entry(config.kit.files.hooks.server);
+	const universal = resolve_entry(config.kit.files.hooks.universal);
+
+	return {
+		client: client && posixify(path.relative(cwd, client)),
+		server: server && posixify(path.relative(cwd, server)),
+		universal: universal && posixify(path.relative(cwd, universal))
+	};
+}
+
 /**
  * @param {import('types').ValidatedConfig} config
  * @param {string} cwd

package/src/core/sync/write_server.js

@@ -30,6 +30,7 @@ const server_template = ({
 import root from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';
 import { set_building, set_prerendering } from '__sveltekit/environment';
 import { set_assets } from '__sveltekit/paths';
+import { set_manifest, set_read_implementation } from '__sveltekit/server';
 import { set_private_env, set_public_env, set_safe_public_env } from '${runtime_directory}/shared-server.js';
 
 export const options = {
@@ -68,7 +69,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_prerendering, set_private_env, set_public_env, set_safe_public_env };
+export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation, set_safe_public_env };
 `;
 
 // TODO need to re-run this whenever src/app.html or src/error.html are

package/src/exports/node/index.js

@@ -1,3 +1,5 @@
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
 import * as set_cookie_parser from 'set-cookie-parser';
 import { SvelteKitError } from '../../runtime/control.js';
 
@@ -189,3 +191,13 @@ export async function setResponse(res, response) {
 		}
 	}
 }
+
+/**
+ * Converts a file on disk to a readable stream
+ * @param {string} file
+ * @returns {ReadableStream}
+ * @since 2.4.0
+ */
+export function createReadableStream(file) {
+	return /** @type {ReadableStream} */ (Readable.toWeb(createReadStream(file)));
+}

package/src/exports/public.d.ts

@@ -35,6 +35,16 @@ export interface Adapter {
 	 * @param builder An object provided by SvelteKit that contains methods for adapting the app
 	 */
 	adapt(builder: Builder): MaybePromise<void>;
+	/**
+	 * Checks called during dev and build to determine whether specific features will work in production with this adapter
+	 */
+	supports?: {
+		/**
+		 * Test support for `read` from `$app/server`
+		 * @param config The merged route config
+		 */
+		read?: (details: { config: any; route: { id: string } }) => boolean;
+	};
 }
 
 export type LoadProperties<input extends Record<string, any> | void> = input extends void
@@ -89,6 +99,7 @@ export interface Builder {
 	/** An array of all routes (including prerendered) */
 	routes: RouteDefinition[];
 
+	// TODO 3.0 remove this method
 	/**
 	 * Create separate functions that map to one or more routes of your app.
 	 * @param fn A function that groups a set of routes into an entry point
@@ -96,6 +107,11 @@ export interface Builder {
 	 */
 	createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
 
+	/**
+	 * Find all the assets imported by server files belonging to `routes`
+	 */
+	findServerAssets(routes: RouteDefinition[]): string[];
+
 	/**
 	 * Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps.
 	 */
@@ -1144,7 +1160,10 @@ export class Server {
 }
 
 export interface ServerInitOptions {
+	/** A map of environment variables */
 	env: Record<string, string>;
+	/** A function that turns an asset filename into a `ReadableStream`. Required for the `read` export from `$app/server` to work */
+	read?: (file: string) => ReadableStream;
 }
 
 export interface SSRManifest {
@@ -1159,6 +1178,8 @@ export interface SSRManifest {
 		nodes: SSRNodeLoader[];
 		routes: SSRRoute[];
 		matchers(): Promise<Record<string, ParamMatcher>>;
+		/** A `[file]: size` map of all assets imported by server code */
+		server_assets: Record<string, number>;
 	};
 }
 

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

@@ -20,7 +20,7 @@ export function find_deps(manifest, entry, add_dynamic_css) {
 	const stylesheets = new Set();
 
 	/** @type {Set<string>} */
-	const fonts = new Set();
+	const imported_assets = new Set();
 
 	/**
 	 * @param {string} current
@@ -36,9 +36,7 @@ export function find_deps(manifest, entry, add_dynamic_css) {
 
 		if (chunk.assets) {
 			for (const asset of chunk.assets) {
-				if (/\.(woff2?|ttf|otf)$/.test(asset)) {
-					fonts.add(asset);
-				}
+				imported_assets.add(asset);
 			}
 		}
 
@@ -59,11 +57,15 @@ export function find_deps(manifest, entry, add_dynamic_css) {
 
 	traverse(file, true);
 
+	const assets = Array.from(imported_assets);
+
 	return {
+		assets,
 		file: chunk.file,
 		imports: Array.from(imports),
 		stylesheets: Array.from(stylesheets),
-		fonts: Array.from(fonts)
+		// TODO do we need this separately?
+		fonts: assets.filter((asset) => /\.(woff2?|ttf|otf)$/.test(asset))
 	};
 }
 

package/src/exports/vite/dev/index.js

@@ -1,10 +1,11 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { URL } from 'node:url';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import colors from 'kleur';
 import sirv from 'sirv';
 import { isCSSRequest, loadEnv, buildErrorMessage } from 'vite';
-import { getRequest, setResponse } from '../../../exports/node/index.js';
+import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { installPolyfills } from '../../../exports/node/polyfills.js';
 import { coalesce_to_error } from '../../../utils/error.js';
 import { posixify, resolve_entry, to_fs } from '../../../utils/filesystem.js';
@@ -15,6 +16,7 @@ import { get_mime_lookup, runtime_base } from '../../../core/utils.js';
 import { compact } from '../../../utils/array.js';
 import { not_found } from '../utils.js';
 import { SCHEME } from '../../../utils/url.js';
+import { check_feature } from '../../../utils/features.js';
 
 const cwd = process.cwd();
 
@@ -27,6 +29,15 @@ const cwd = process.cwd();
 export async function dev(vite, vite_config, svelte_config) {
 	installPolyfills();
 
+	const async_local_storage = new AsyncLocalStorage();
+
+	globalThis.__SVELTEKIT_TRACK__ = (label) => {
+		const context = async_local_storage.getStore();
+		if (!context || context.prerender === true) return;
+
+		check_feature(context.event.route.id, context.config, label, svelte_config.kit.adapter);
+	};
+
 	const fetch = globalThis.fetch;
 	globalThis.fetch = (info, init) => {
 		if (typeof info === 'string' && !SCHEME.test(info)) {
@@ -123,6 +134,13 @@ export async function dev(vite, vite_config, svelte_config) {
 					fonts: [],
 					uses_env_dynamic_public: true
 				},
+				server_assets: new Proxy(
+					{},
+					{
+						has: (_, /** @type {string} */ file) => fs.existsSync(file.replace(/^\/@fs/, '')),
+						get: (_, /** @type {string} */ file) => fs.statSync(file.replace(/^\/@fs/, '')).size
+					}
+				),
 				nodes: manifest_data.nodes.map((node, index) => {
 					return async () => {
 						/** @type {import('types').SSRNode} */
@@ -470,7 +488,10 @@ export async function dev(vite, vite_config, svelte_config) {
 
 				const server = new Server(manifest);
 
-				await server.init({ env });
+				await server.init({
+					env,
+					read: (file) => createReadableStream(file.replace(/^\/@fs/, ''))
+				});
 
 				const request = await getRequest({
 					base,
@@ -505,7 +526,10 @@ export async function dev(vite, vite_config, svelte_config) {
 						if (remoteAddress) return remoteAddress;
 						throw new Error('Could not determine clientAddress');
 					},
-					read: (file) => fs.readFileSync(path.join(svelte_config.kit.files.assets, file))
+					read: (file) => fs.readFileSync(path.join(svelte_config.kit.files.assets, file)),
+					before_handle: (event, config, prerender) => {
+						async_local_storage.enterWith({ event, config, prerender });
+					}
 				});
 
 				if (rendered.status === 404) {

package/src/exports/vite/graph_analysis/index.js

@@ -1,9 +1,9 @@
 import path from 'node:path';
 import { posixify } from '../../../utils/filesystem.js';
 import { strip_virtual_prefix } from '../utils.js';
-import { env_dynamic_private, env_static_private } from '../module_ids.js';
+import { app_server, env_dynamic_private, env_static_private } from '../module_ids.js';
 
-const ILLEGAL_IMPORTS = new Set([env_dynamic_private, env_static_private]);
+const ILLEGAL_IMPORTS = new Set([env_dynamic_private, env_static_private, app_server]);
 const ILLEGAL_MODULE_NAME_PATTERN = /.*\.server\..+/;
 
 /**
@@ -101,5 +101,9 @@ export function normalize_id(id, lib, cwd) {
 		id = path.relative(cwd, id);
 	}
 
+	if (id === app_server) {
+		return '$app/server';
+	}
+
 	return posixify(id);
 }