@sveltejs/kit 2.3.4 → 2.4.0

package/package.json

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

package/src/core/adapt/builder.js

@@ -1,4 +1,5 @@
-import { existsSync, statSync, createReadStream, createWriteStream } from 'node:fs';
+import colors from 'kleur';
+import { createReadStream, createWriteStream, existsSync, statSync } from 'node:fs';
 import { extname, resolve } from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
@@ -10,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'];
@@ -144,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);
@@ -153,6 +162,16 @@ export function create_builder({
 				env: { ...env.private, ...env.public }
 			});
 
+			if (existsSync(dest)) {
+				console.log(
+					colors
+						.bold()
+						.yellow(
+							`Overwriting ${dest} with fallback page. Consider using a different name for the fallback.`
+						)
+				);
+			}
+
 			write(dest, fallback);
 		},
 

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);
 }

package/src/exports/vite/index.js

@@ -31,7 +31,8 @@ import {
 	env_static_public,
 	service_worker,
 	sveltekit_environment,
-	sveltekit_paths
+	sveltekit_paths,
+	sveltekit_server
 } from './module_ids.js';
 import { pathToFileURL } from 'node:url';
 
@@ -224,6 +225,13 @@ async function kit({ svelte_config }) {
 	const service_worker_entry_file = resolve_entry(kit.files.serviceWorker);
 	const parsed_service_worker = path.parse(kit.files.serviceWorker);
 
+	/**
+	 * A map showing which features (such as `$app/server:read`) are defined
+	 * in which chunks, so that we can later determine which routes use which features
+	 * @type {Record<string, string[]>}
+	 */
+	const tracked_features = {};
+
 	const sourcemapIgnoreList = /** @param {string} relative_path */ (relative_path) =>
 		relative_path.includes('node_modules') || relative_path.includes(kit.outDir);
 
@@ -492,13 +500,29 @@ async function kit({ svelte_config }) {
 						}
 					`;
 				}
+
+				case sveltekit_server: {
+					return dedent`
+						export let read_implementation = null;
+
+						export let manifest = null;
+
+						export function set_read_implementation(fn) {
+							read_implementation = fn;
+						}
+
+						export function set_manifest(_) {
+							manifest = _;
+						}
+					`;
+				}
 			}
 		}
 	};
 
 	/**
 	 * Ensures that client-side code can't accidentally import server-side code,
-	 * whether in `*.server.js` files, `$lib/server`, or `$env/[static|dynamic]/private`
+	 * whether in `*.server.js` files, `$app/server`, `$lib/server`, or `$env/[static|dynamic]/private`
 	 * @type {import('vite').Plugin}
 	 */
 	const plugin_guard = {
@@ -685,6 +709,19 @@ async function kit({ svelte_config }) {
 			}
 		},
 
+		renderChunk(code, chunk) {
+			if (code.includes('__SVELTEKIT_TRACK__')) {
+				return {
+					code: code.replace(/__SVELTEKIT_TRACK__\('(.+?)'\)/g, (_, label) => {
+						(tracked_features[chunk.name + '.js'] ??= []).push(label);
+						// put extra whitespace at the end of the comment to preserve the source size and avoid interfering with source maps
+						return `/* track ${label}            */`;
+					}),
+					map: null // TODO we may need to generate a sourcemap in future
+				};
+			}
+		},
+
 		generateBundle() {
 			if (vite_config.build.ssr) return;
 
@@ -716,6 +753,7 @@ async function kit({ svelte_config }) {
 					app_dir: kit.appDir,
 					app_path: `${kit.paths.base.slice(1)}${kit.paths.base ? '/' : ''}${kit.appDir}`,
 					manifest_data,
+					out_dir: out,
 					service_worker: service_worker_entry_file ? 'service-worker.js' : null, // TODO make file configurable?
 					client: null,
 					server_manifest
@@ -738,6 +776,9 @@ async function kit({ svelte_config }) {
 
 				const metadata = await analyse({
 					manifest_path,
+					manifest_data,
+					server_manifest,
+					tracked_features,
 					env: { ...env.private, ...env.public }
 				});
 

package/src/exports/vite/module_ids.js

@@ -1,7 +1,16 @@
+import { fileURLToPath } from 'node:url';
+
 export const env_static_private = '\0virtual:$env/static/private';
 export const env_static_public = '\0virtual:$env/static/public';
 export const env_dynamic_private = '\0virtual:$env/dynamic/private';
 export const env_dynamic_public = '\0virtual:$env/dynamic/public';
+
 export const service_worker = '\0virtual:$service-worker';
-export const sveltekit_paths = '\0virtual:__sveltekit/paths';
+
 export const sveltekit_environment = '\0virtual:__sveltekit/environment';
+export const sveltekit_paths = '\0virtual:__sveltekit/paths';
+export const sveltekit_server = '\0virtual:__sveltekit/server';
+
+export const app_server = fileURLToPath(
+	new URL('../../runtime/app/server/index.js', import.meta.url)
+);

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

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { lookup } from 'mrmime';
 import sirv from 'sirv';
 import { loadEnv, normalizePath } 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 { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { not_found } from '../utils.js';
@@ -47,7 +47,8 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	const server = new Server(manifest);
 	await server.init({
-		env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, '')
+		env: loadEnv(vite_config.mode, svelte_config.kit.env.dir, ''),
+		read: (file) => createReadableStream(`${dir}/${file}`)
 	});
 
 	return () => {

package/src/runtime/app/server/index.js

@@ -0,0 +1,58 @@
+import { read_implementation, manifest } from '__sveltekit/server';
+import { base } from '__sveltekit/paths';
+import { DEV } from 'esm-env';
+
+/**
+ * Read the contents of an imported asset from the filesystem
+ * @example
+ * ```js
+ * import { read } from '$app/server';
+ * import somefile from './somefile.txt';
+ *
+ * const asset = read(somefile);
+ * const text = await asset.text();
+ * ```
+ * @param {string} asset
+ * @returns {Response}
+ * @since 2.4.0
+ */
+export function read(asset) {
+	__SVELTEKIT_TRACK__('$app/server:read');
+
+	if (!read_implementation) {
+		throw new Error(
+			'No `read` implementation was provided. Please ensure that your adapter is up to date and supports this feature'
+		);
+	}
+
+	// handle inline assets internally
+	if (asset.startsWith('data:')) {
+		const [prelude, data] = asset.split(';');
+		const type = prelude.slice(5) || 'application/octet-stream';
+
+		const decoded = data.startsWith('base64,') ? atob(data.slice(7)) : decodeURIComponent(data);
+
+		return new Response(decoded, {
+			headers: {
+				'Content-Length': decoded.length.toString(),
+				'Content-Type': type
+			}
+		});
+	}
+
+	const file = DEV && asset.startsWith('/@fs') ? asset : asset.slice(base.length + 1);
+
+	if (file in manifest._.server_assets) {
+		const length = manifest._.server_assets[file];
+		const type = manifest.mimeTypes[file.slice(file.lastIndexOf('.'))];
+
+		return new Response(read_implementation(file), {
+			headers: {
+				'Content-Length': '' + length,
+				'Content-Type': type
+			}
+		});
+	}
+
+	throw new Error(`Asset does not exist: ${file}`);
+}

package/src/runtime/server/index.js

@@ -4,6 +4,7 @@ import { options, get_hooks } from '__SERVER__/internal.js';
 import { DEV } from 'esm-env';
 import { filter_private_env, filter_public_env } from '../../utils/env.js';
 import { prerendering } from '__sveltekit/environment';
+import { set_read_implementation, set_manifest } from '__sveltekit/server';
 
 /** @type {ProxyHandler<{ type: 'public' | 'private' }>} */
 const prerender_env_handler = {
@@ -26,14 +27,17 @@ export class Server {
 		/** @type {import('types').SSROptions} */
 		this.#options = options;
 		this.#manifest = manifest;
+
+		set_manifest(manifest);
 	}
 
 	/**
 	 * @param {{
-	 *   env: Record<string, string>
+	 *   env: Record<string, string>;
+	 *   read?: (file: string) => ReadableStream;
 	 * }} opts
 	 */
-	async init({ env }) {
+	async init({ env, read }) {
 		// Take care: Some adapters may have to call `Server.init` per-request to set env vars,
 		// so anything that shouldn't be rerun should be wrapped in an `if` block to make sure it hasn't
 		// been done already.
@@ -55,6 +59,10 @@ export class Server {
 		);
 		set_safe_public_env(public_env);
 
+		if (read) {
+			set_read_implementation(read);
+		}
+
 		if (!this.#options.hooks) {
 			try {
 				const module = await get_hooks();

package/src/runtime/server/page/index.js

@@ -15,6 +15,7 @@ import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { get_option } from '../../../utils/options.js';
 import { get_data_json } from '../data/index.js';
+import { load_page_nodes } from './load_page_nodes.js';
 
 /**
  * The maximum request depth permitted before assuming we're stuck in an infinite loop
@@ -44,11 +45,7 @@ export async function render_page(event, page, options, manifest, state, resolve
 	}
 
 	try {
-		const nodes = await Promise.all([
-			// we use == here rather than === because [undefined] serializes as "[null]"
-			...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-			manifest._.nodes[page.leaf]()
-		]);
+		const nodes = await load_page_nodes(page, manifest);
 
 		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
 

package/src/runtime/server/page/load_page_nodes.js

@@ -0,0 +1,11 @@
+/**
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('@sveltejs/kit').SSRManifest} manifest
+ */
+export function load_page_nodes(page, manifest) {
+	return Promise.all([
+		// we use == here rather than === because [undefined] serializes as "[null]"
+		...page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
+		manifest._.nodes[page.leaf]()
+	]);
+}

package/src/runtime/server/respond.js

@@ -31,6 +31,8 @@ import { json, text } from '../../exports/index.js';
 import { action_json_redirect, is_action_json_request } from './page/actions.js';
 import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM } from '../shared.js';
 import { get_public_env } from './env_module.js';
+import { load_page_nodes } from './page/load_page_nodes.js';
+import { get_page_config } from '../../utils/route_config.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
@@ -217,11 +219,7 @@ export async function respond(request, options, manifest, state) {
 			if (url.pathname === base || url.pathname === base + '/') {
 				trailing_slash = 'always';
 			} else if (route.page) {
-				const nodes = await Promise.all([
-					// we use == here rather than === because [undefined] serializes as "[null]"
-					...route.page.layouts.map((n) => (n == undefined ? n : manifest._.nodes[n]())),
-					manifest._.nodes[route.page.leaf]()
-				]);
+				const nodes = await load_page_nodes(route.page, manifest);
 
 				if (DEV) {
 					const layouts = nodes.slice(0, -1);
@@ -272,6 +270,25 @@ export async function respond(request, options, manifest, state) {
 					});
 				}
 			}
+
+			if (DEV && state.before_handle) {
+				let config = {};
+
+				/** @type {import('types').PrerenderOption} */
+				let prerender = false;
+
+				if (route.endpoint) {
+					const node = await route.endpoint();
+					config = node.config ?? config;
+					prerender = node.prerender ?? prerender;
+				} else if (route.page) {
+					const nodes = await load_page_nodes(route.page, manifest);
+					config = get_page_config(nodes);
+					prerender = get_option(nodes, 'prerender') ?? false;
+				}
+
+				state.before_handle(event, config, prerender);
+			}
 		}
 
 		const { cookies, new_cookies, get_cookie_header, set_internal } = get_cookies(

package/src/types/ambient-private.d.ts

@@ -16,3 +16,13 @@ declare module '__sveltekit/paths' {
 	export function override(paths: { base: string; assets: string }): void;
 	export function set_assets(path: string): void;
 }
+
+/** Internal version of $app/server */
+declare module '__sveltekit/server' {
+	import { SSRManifest } from '@sveltejs/kit';
+
+	export let manifest: SSRManifest;
+	export function read_implementation(path: string): ReadableStream;
+	export function set_manifest(manifest: SSRManifest): void;
+	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
+}

package/src/types/global-private.d.ts

@@ -4,6 +4,21 @@ declare global {
 	const __SVELTEKIT_APP_VERSION_POLL_INTERVAL__: number;
 	const __SVELTEKIT_DEV__: boolean;
 	const __SVELTEKIT_EMBEDDED__: boolean;
+	/**
+	 * This makes the use of specific features visible at both dev and build time, in such a
+	 * way that we can error when they are not supported by the target platform.
+	 *
+	 * During dev, `globalThis.__SVELTEKIT_TRACK__` is a function that grabs the current `event`
+	 * and route `config` (from an AsyncLocalStorage instance) and calls the relevant `supports`
+	 * function on the adapter (e.g. `adapter.supports.read(...)`).
+	 *
+	 * At build time, if the function containing the `__SVELTEKIT_TRACK__` call is untreeshaken,
+	 * we locate it in the `renderChunk` build hook and a) make a note of the chunk that contains
+	 * it and b) replace it with a comment. Later, we can use this information to establish
+	 * which routes use which feature, and use the same `adapter.supports.read(...)` function
+	 * to throw an error if the feature would fail in production.
+	 */
+	var __SVELTEKIT_TRACK__: (label: string) => void;
 	var Bun: object;
 	var Deno: object;
 }

package/src/types/internal.d.ts

@@ -13,7 +13,9 @@ import {
 	HandleFetch,
 	Actions,
 	HandleClientError,
-	Reroute
+	Reroute,
+	RequestEvent,
+	SSRManifest
 } from '@sveltejs/kit';
 import {
 	HttpMethod,
@@ -30,9 +32,11 @@ export interface ServerModule {
 export interface ServerInternalModule {
 	set_assets(path: string): void;
 	set_building(): void;
+	set_manifest(manifest: SSRManifest): void;
 	set_prerendering(): void;
 	set_private_env(environment: Record<string, string>): void;
 	set_public_env(environment: Record<string, string>): void;
+	set_read_implementation(implementation: (path: string) => ReadableStream): void;
 	set_safe_public_env(environment: Record<string, string>): void;
 	set_version(version: string): void;
 	set_fix_stack_trace(fix_stack_trace: (error: unknown) => string): void;
@@ -45,6 +49,7 @@ export interface Asset {
 }
 
 export interface AssetDependencies {
+	assets: string[];
 	file: string;
 	imports: string[];
 	stylesheets: string[];
@@ -55,6 +60,7 @@ export interface BuildData {
 	app_dir: string;
 	app_path: string;
 	manifest_data: ManifestData;
+	out_dir: string;
 	service_worker: string | null;
 	client: {
 		start: string;
@@ -120,12 +126,19 @@ export class InternalServer extends Server {
 		options: RequestOptions & {
 			prerendering?: PrerenderOptions;
 			read: (file: string) => Buffer;
+			/** A hook called before `handle` during dev, so that `AsyncLocalStorage` can be populated */
+			before_handle?: (event: RequestEvent, config: any, prerender: PrerenderOption) => void;
 		}
 	): Promise<Response>;
 }
 
 export interface ManifestData {
 	assets: Asset[];
+	hooks: {
+		client: string | null;
+		server: string | null;
+		universal: string | null;
+	};
 	nodes: PageNode[];
 	routes: RouteData[];
 	matchers: Record<string, string>;
@@ -404,6 +417,7 @@ export interface SSRState {
 	 */
 	prerender_default?: PrerenderOption;
 	read?: (file: string) => Buffer;
+	before_handle?: (event: RequestEvent, config: any, prerender: PrerenderOption) => void;
 }
 
 export type StrictBody = string | ArrayBufferView;

package/src/utils/features.js

@@ -0,0 +1,24 @@
+/**
+ * @param {string} route_id
+ * @param {any} config
+ * @param {string} feature
+ * @param {import('@sveltejs/kit').Adapter | undefined} adapter
+ */
+export function check_feature(route_id, config, feature, adapter) {
+	if (!adapter) return;
+
+	switch (feature) {
+		case '$app/server:read': {
+			const supported = adapter.supports?.read?.({
+				route: { id: route_id },
+				config
+			});
+
+			if (!supported) {
+				throw new Error(
+					`Cannot use \`read\` from \`$app/server\` in ${route_id} when using ${adapter.name}. Please ensure that your adapter is up to date and supports this feature.`
+				);
+			}
+		}
+	}
+}

package/src/utils/route_config.js

@@ -0,0 +1,20 @@
+/**
+ * Do a shallow merge (first level) of the config object
+ * @param {Array<import('types').SSRNode | undefined>} nodes
+ */
+export function get_page_config(nodes) {
+	/** @type {any} */
+	let current = {};
+
+	for (const node of nodes) {
+		if (!node?.universal?.config && !node?.server?.config) continue;
+
+		current = {
+			...current,
+			...node?.universal?.config,
+			...node?.server?.config
+		};
+	}
+
+	return Object.keys(current).length ? current : undefined;
+}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '2.3.4';
+export const VERSION = '2.4.0';

package/types/index.d.ts

@@ -17,6 +17,16 @@ declare module '@sveltejs/kit' {
 		 * @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
@@ -71,6 +81,7 @@ declare module '@sveltejs/kit' {
 		/** 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
@@ -78,6 +89,11 @@ declare module '@sveltejs/kit' {
 		 */
 		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.
 		 */
@@ -1126,7 +1142,10 @@ declare module '@sveltejs/kit' {
 	}
 
 	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 {
@@ -1141,6 +1160,8 @@ declare module '@sveltejs/kit' {
 			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>;
 		};
 	}
 
@@ -1549,6 +1570,7 @@ declare module '@sveltejs/kit' {
 		app_dir: string;
 		app_path: string;
 		manifest_data: ManifestData;
+		out_dir: string;
 		service_worker: string | null;
 		client: {
 			start: string;
@@ -1563,6 +1585,11 @@ declare module '@sveltejs/kit' {
 
 	interface ManifestData {
 		assets: Asset[];
+		hooks: {
+			client: string | null;
+			server: string | null;
+			universal: string | null;
+		};
 		nodes: PageNode[];
 		routes: RouteData[];
 		matchers: Record<string, string>;
@@ -1873,6 +1900,11 @@ declare module '@sveltejs/kit/node' {
 	}): Promise<Request>;
 
 	export function setResponse(res: import('http').ServerResponse, response: Response): Promise<void>;
+	/**
+	 * Converts a file on disk to a readable stream
+	 * @since 2.4.0
+	 */
+	export function createReadableStream(file: string): ReadableStream;
 }
 
 declare module '@sveltejs/kit/node/polyfills' {
@@ -2107,6 +2139,22 @@ declare module '$app/paths' {
 	export function resolveRoute(id: string, params: Record<string, string | undefined>): string;
 }
 
+declare module '$app/server' {
+	/**
+	 * Read the contents of an imported asset from the filesystem
+	 * @example
+	 * ```js
+	 * import { read } from '$app/server';
+	 * import somefile from './somefile.txt';
+	 *
+	 * const asset = read(somefile);
+	 * const text = await asset.text();
+	 * ```
+	 * @since 2.4.0
+	 */
+	export function read(asset: string): Response;
+}
+
 declare module '$app/stores' {
 	export function getStores(): {
 		

package/types/index.d.ts.map

@@ -86,6 +86,7 @@
 		"sequence",
 		"getRequest",
 		"setResponse",
+		"createReadableStream",
 		"installPolyfills",
 		"sveltekit",
 		"browser",
@@ -109,6 +110,7 @@
 		"base",
 		"assets",
 		"resolveRoute",
+		"read",
 		"getStores",
 		"page",
 		"navigating",
@@ -129,6 +131,7 @@
 		"../src/runtime/app/forms.js",
 		"../src/runtime/client/client.js",
 		"../src/runtime/app/paths/types.d.ts",
+		"../src/runtime/app/server/index.js",
 		"../src/runtime/app/stores.js"
 	],
 	"sourcesContent": [
@@ -146,7 +149,8 @@
 		null,
 		null,
 		null,
+		null,
 		null
 	],
-	"mappings": ";;;;;;;;;kBA2BiBA,OAAOA;;;;;;;;;;;;aAYZC,cAAcA;;;;;;aAMdC,cAAcA;;;;;;;;;;;;;;;kBAeTC,aAAaA;;;;;;;;;;;;;;;;kBAgBbC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4FPC,MAAMA;;;;;;;;;;;;;;;;;;;;;kBAqBNC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyDPC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqZdC,MAAMA;;;;;;;;;;;aAWNC,iBAAiBA;;;;;;;;;;;;;aAajBC,iBAAiBA;;;;;;;;;;aAUjBC,WAAWA;;;;;;;;;;aAUXC,OAAOA;;;;;;aAMPC,IAAIA;;;;;;;;;;;;kBAYCC,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4GTC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0BfC,gBAAgBA;;;;;;;;;;;;;;;;;;;;;;;;aAwBrBC,cAAcA;;kBAETC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCVC,cAAcA;;;;;;;;;;kBAUdC,UAAUA;;;;;;;;;;;;;;;;;;kBAkBVC,aAAaA;;;;;;;;;;;;;;;;;;;kBAmBbC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8CTC,YAAYA;;kBAEPC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA4FjBC,cAAcA;;;;;kBAKTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;kBAuBdC,eAAeA;;;;;;;;;;;;;;;cAenBC,MAAMA;;;;;;kBAMFC,iBAAiBA;;;;kBAIjBC,WAAWA;;;;;;;;;;;;;;;;;;;aAmBhBC,UAAUA;;;;;;;kBAOLC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAqEpBC,MAAMA;;;;;;;;;;aAUNC,OAAOA;;;;;;;;;;;;;;;;aAgBPC,YAAYA;;;;;;;;;;;;kBCtvCXC,SAASA;;;;;;;;;;kBAqBTC,QAAQA;;;;;;;aD8vCTC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6BTC,QAAQA;;;;WE1yCRC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkDZC,GAAGA;;;;;;;;;;;;;;;;;;;;;;WAsBHC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmElBC,UAAUA;;WAELC,MAAMA;;;;;;;;;MASXC,YAAYA;;WAEPC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmCXC,yBAAyBA;;;;;;;;;;WAUzBC,yBAAyBA;;;;WAIzBC,sCAAsCA;;;;MAI3CC,8BAA8BA;MAC9BC,8BAA8BA;MAC9BC,2CAA2CA;;;;;;aAM3CC,eAAeA;;WAIVC,cAAcA;;;;;WAKdC,YAAYA;;;;;;MAMjBC,aAAaA;WClMRC,KAAKA;;;;;;WAaLC,SAASA;;;;;;;;;;;;;;;;WAyETC,YAAYA;;;;;;;WAOZC,QAAQA;;;;;;;;;;;;;MAwBbC,iBAAiBA;;;;;;;;WAUZC,UAAUA;;;;;;;;;;;;;WAaVC,SAASA;;;;;;;;;;;;;;;;;;;;;;;WAsGTC,YAAYA;;;;;;;;;;;;;MAajBC,kBAAkBA;;WAEbC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsCZC,aAAaA;;WA2BRC,eAAeA;;;;;;MAMpBC,uBAAuBA;;MAEvBC,WAAWA;;;;;;;;WAQNC,QAAQA;;;;;;;;;MAyCbC,eAAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCzVXC,WAAWA;;;;;;;;;;;iBAcXC,QAAQA;;;;;iBAaRC,UAAUA;;;;;;iBASVC,IAAIA;;;;;;iBA8BJC,IAAIA;;;;;;;;;;;;aApI6CC,QAAQA;aAMVC,YAAYA;cCX9DC,OAAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCiEJC,QAAQA;;;;iBCmCFC,UAAUA;;;;;;iBAeVC,WAAWA;;;;;;;;;iBCpGjBC,gBAAgBA;;;;;;;iBC+HVC,SAASA;;;;;;;cC9IlBC,OAAOA;;;;;cAKPC,GAAGA;;;;;cAKHC,QAAQA;;;;;cAKRC,OAAOA;;;;;;;;;;;;;;;;;;;;;;iBCWJC,WAAWA;;;;;;;;;;;;;;;;;;;;;iBAyCXC,OAAOA;;;;;;;iBC0wDDC,WAAWA;;;;;;;;;iBA5RjBC,aAAaA;;;;;;;;;;;;iBAiBbC,cAAcA;;;;;;;;;;iBAedC,UAAUA;;;;;iBASVC,qBAAqBA;;;;;;;;iBA2BrBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;;;iBAsCJC,UAAUA;;;;iBAmBVC,aAAaA;;;;;;;;;;;;iBAqBPC,WAAWA;;;;;;;;;;;;;;;;;;iBAoCjBC,WAAWA;;;;;iBA2BXC,SAASA;;;;;iBAuCTC,YAAYA;MVhpDhB1D,YAAYA;;;;;;;;;YWvJb2D,IAAIA;;;;;;;YAOJC,MAAMA;;;;;;;;;;;;;;;iBAeDC,YAAYA;;;;iBCnBfC,SAASA;;;;;;;;;;;;;;cAwBTC,IAAIA;;;;;;;;cAeJC,UAAUA;;;;;;cAaVC,OAAOA"
+	"mappings": "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"
 }