@sveltejs/kit 2.62.0 → 3.0.0-next.0

package/src/core/config/options.js

@@ -1,8 +1,6 @@
 /** @import { Validator } from './types.js' */
 
 import process from 'node:process';
-import colors from 'kleur';
-import { supportsTrustedTypes } from '../sync/utils.js';
 
 const directives = object({
 	'child-src': string_array(),
@@ -29,14 +27,8 @@ const directives = object({
 	'navigate-to': string_array(),
 	'report-uri': string_array(),
 	'report-to': string_array(),
-	'require-trusted-types-for': validate(undefined, (input, keypath) => {
-		assert_trusted_types_supported(keypath);
-		return string_array()(input, keypath);
-	}),
-	'trusted-types': validate(undefined, (input, keypath) => {
-		assert_trusted_types_supported(keypath);
-		return string_array()(input, keypath);
-	}),
+	'require-trusted-types-for': string_array(),
+	'trusted-types': string_array(),
 	'upgrade-insecure-requests': boolean(false),
 	'require-sri-for': string_array(),
 	'block-all-mixed-content': boolean(false),
@@ -66,15 +58,9 @@ const options = object(
 		}),
 
 		kit: object({
-			adapter: validate(null, (input, keypath) => {
+			adapter: validate(undefined, (input, keypath) => {
 				if (typeof input !== 'object' || !input.adapt) {
-					let message = `${keypath} should be an object with an "adapt" method`;
-
-					if (Array.isArray(input) || typeof input === 'string') {
-						// for the early adapter adopters
-						message += ', rather than the name of an adapter';
-					}
-
+					const message = `The SvelteKit Vite plugin ${keypath} should be an object with an \`adapt\` method`;
 					throw new Error(`${message}. See https://svelte.dev/docs/kit/adapters`);
 				}
 
@@ -116,10 +102,8 @@ const options = object(
 			}),
 
 			csrf: object({
-				checkOrigin: deprecate(
-					boolean(true),
-					(keypath) =>
-						`\`${keypath}\` has been deprecated in favour of \`csrf.trustedOrigins\`. It will be removed in a future version`
+				checkOrigin: removed(
+					(keypath) => `\`${keypath}\` has been removed in favour of \`csrf.trustedOrigins\``
 				),
 				trustedOrigins: string_array([])
 			}),
@@ -127,9 +111,7 @@ const options = object(
 			embedded: boolean(false),
 
 			env: object({
-				dir: string(process.cwd()),
-				publicPrefix: string('PUBLIC_'),
-				privatePrefix: string('')
+				dir: string(process.cwd())
 			}),
 
 			experimental: object({
@@ -167,7 +149,10 @@ const options = object(
 			outDir: string('.svelte-kit'),
 
 			output: object({
-				preloadStrategy: list(['modulepreload', 'preload-js', 'preload-mjs']),
+				linkHeaderPreload: boolean(false),
+				preloadStrategy: removed(
+					(keypath) => `\`${keypath}\` has been removed. modulepreload will always be used`
+				),
 				bundleStrategy: list(['split', 'single', 'inline'])
 			}),
 
@@ -325,22 +310,37 @@ const options = object(
 	true
 );
 
+// /**
+//  * @param {Validator} fn
+//  * @param {(keypath: string) => string} get_message
+//  * @returns {Validator}
+//  */
+// function deprecate(
+// 	fn,
+// 	get_message = (keypath) =>
+// 		`The \`${keypath}\` option is deprecated, and will be removed in a future version`
+// ) {
+// 	return (input, keypath) => {
+// 		if (input !== undefined) {
+// 			console.warn(styleText(['bold', 'yellow'], get_message(keypath)));
+// 		}
+
+// 		return fn(input, keypath);
+// 	};
+// }
+
 /**
- * @param {Validator} fn
  * @param {(keypath: string) => string} get_message
  * @returns {Validator}
  */
-function deprecate(
-	fn,
+function removed(
 	get_message = (keypath) =>
-		`The \`${keypath}\` option is deprecated, and will be removed in a future version`
+		`The \`${keypath}\` option has been removed. Please see the list of breaking changes for your major release`
 ) {
 	return (input, keypath) => {
-		if (input !== undefined) {
-			console.warn(colors.bold().yellow(get_message(keypath)));
+		if (typeof input !== 'undefined') {
+			throw new Error(get_message(keypath));
 		}
-
-		return fn(input, keypath);
 	};
 }
 
@@ -349,7 +349,7 @@ function deprecate(
  * @param {boolean} [allow_unknown]
  * @returns {Validator}
  */
-function object(children, allow_unknown = false) {
+export function object(children, allow_unknown = false) {
 	return (input, keypath) => {
 		/** @type {Record<string, any>} */
 		const output = {};
@@ -389,7 +389,7 @@ function object(children, allow_unknown = false) {
  * @param {(value: any, keypath: string) => any} fn
  * @returns {Validator}
  */
-function validate(fallback, fn) {
+export function validate(fallback, fn) {
 	return (input, keypath) => {
 		return input === undefined ? fallback : fn(input, keypath);
 	};
@@ -493,13 +493,4 @@ function assert_string(input, keypath) {
 	}
 }
 
-/** @param {string} keypath */
-function assert_trusted_types_supported(keypath) {
-	if (!supportsTrustedTypes()) {
-		throw new Error(
-			`${keypath} is not supported by your version of Svelte. Please upgrade to Svelte 5.51.0 or later to use this directive.`
-		);
-	}
-}
-
 export default options;

package/src/core/env.js

@@ -1,99 +1,279 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @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';
-import { runtime_base } from './utils.js';
+import { runtime_directory } from './utils.js';
+import { resolve_entry } from '../utils/filesystem.js';
+import { handle_issues, validate } from '../exports/internal/env.js';
+import { get_config_aliases } from '../exports/vite/utils.js';
 
 /**
  * @typedef {'public' | 'private'} EnvType
  */
 
 /**
- * @param {string} id
+ * @param {import('types').ValidatedKitConfig} config
+ * @returns {string | null}
+ */
+export function resolve_explicit_env_entry(config) {
+	return resolve_entry(path.join(config.files.src, 'env')) ?? null;
+}
+
+/**
+ * @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) {
+	if (!file) return null;
+
+	const server = await vite.createServer({
+		configFile: false,
+		logLevel: 'silent',
+		mode,
+		define: {
+			__SVELTEKIT_APP_VERSION__: JSON.stringify(kit.version.name) // needed by $app/env
+		},
+		resolve: {
+			alias: [
+				{ find: '$app/env', replacement: `${runtime_directory}/app/env` },
+				...get_config_aliases(kit, root)
+			]
+		}
+	});
+
+	/** @type {Record<string, EnvVarConfig<any>>} */
+	let variables;
+
+	try {
+		({ variables } = await server.ssrLoadModule(file));
+
+		if (!variables || typeof variables !== 'object') {
+			throw new Error(`${file} must export a variables object`);
+		}
+
+		// validate
+		for (const name of Object.keys(variables)) {
+			if (!valid_identifier.test(name) || reserved.has(name)) {
+				throw new Error(`Invalid environment variable name ${JSON.stringify(name)}`);
+			}
+		}
+	} catch (e) {
+		const error = /** @type {any} */ (e || {});
+
+		if (
+			error.code === 'ERR_MODULE_NOT_FOUND' &&
+			error.message?.includes(`Cannot find module '$app`)
+		) {
+			throw new Error(
+				`Cannot import \`$app/*\` modules other than \`$app/env\` inside \`src/env\``,
+				{ cause: e }
+			);
+		}
+
+		throw error;
+	} finally {
+		await server.close();
+	}
+
+	return variables;
+}
+
+/**
+ * Creates the `__sveltekit/env` module
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
  * @param {Record<string, string>} env
- * @returns {string}
+ * @param {string | null} entry
  */
-export function create_static_module(id, env) {
-	/** @type {string[]} */
+export function create_sveltekit_env(variables, env, entry) {
+	const imports = entry
+		? [
+				`import { variables } from ${JSON.stringify(entry)};`,
+				`import { validate, handle_issues } from '@sveltejs/kit/internal/env';`
+			]
+		: [`const variables = {};`, `const handle_issues = () => {};`];
+
 	const declarations = [];
+	const setters = [];
 
-	for (const key in env) {
-		if (!valid_identifier.test(key) || reserved.has(key)) {
-			continue;
-		}
+	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+	const issues = {};
 
-		const comment = `/** @type {import('${id}').${key}} */`;
-		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
+	for (const [name, config] of Object.entries(variables ?? {})) {
+		if (config.static) {
+			if (config.public) {
+				const value = validate(variables ?? {}, env[name], name, issues);
+				declarations.push(`explicit_public_env.${name} = ${devalue.uneval(value)};`);
+			}
+		} else {
+			setters.push(
+				`const ${name} = validate(variables, env.${name}, ${JSON.stringify(name)}, issues);`
+			);
 
-		declarations.push(`${comment}\n${declaration}`);
+			if (config.public) {
+				setters.push(`explicit_public_env.${name} = ${name};`);
+				setters.push(`rendered_env.${name} = ${name};`);
+			} else {
+				setters.push(`dynamic_private_env.${name} = ${name};`);
+			}
+		}
 	}
 
-	return GENERATED_COMMENT + declarations.join('\n\n');
+	handle_issues(issues);
+
+	const blocks = [
+		GENERATED_COMMENT,
+		imports.join('\n'),
+		`const issues = {};`,
+		'export { variables }',
+		'export const dynamic_private_env = {};',
+		'export const explicit_public_env = {};',
+		'export const rendered_env = {};',
+		...declarations,
+		`handle_issues(issues);`,
+		dedent`
+			export function set_env(env) {
+				const issues = {};
+				${setters.join('\n')}
+				handle_issues(issues);
+			}`
+	];
+
+	const module = blocks.join('\n\n');
+
+	return module;
 }
 
 /**
- * @param {EnvType} type
- * @param {Record<string, string> | undefined} dev_values If in a development mode, values to pre-populate the module with.
+ * Creates the `__sveltekit/env/private` module
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, string>} env
  */
-export function create_dynamic_module(type, dev_values) {
-	if (dev_values) {
-		const keys = Object.entries(dev_values).map(
-			([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`
-		);
-		return `export const env = {\n${keys.join(',\n')}\n}`;
+export function create_sveltekit_env_private(variables, env) {
+	if (!variables) {
+		return '';
+	}
+
+	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+	const issues = {};
+
+	/** @type {string[]} */
+	const exports = [];
+
+	for (const [name, config] of Object.entries(variables)) {
+		if (config.public) continue;
+
+		const value = config.static
+			? devalue.uneval(validate(variables, env[name], name, issues))
+			: `env.${name}`;
+
+		exports.push(`export const ${name} = ${value};\n`);
 	}
-	return `export { ${type}_env as env } from '${runtime_base}/shared-server.js';`;
+
+	handle_issues(issues);
+
+	return `import { dynamic_private_env as env } from '__sveltekit/env';\n\n${exports.join('')}`;
 }
 
 /**
- * @param {EnvType} id
- * @param {import('types').Env} env
- * @returns {string}
+ * Creates the `__sveltekit/env/public/*` modules
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, string>} env
+ * @param {string} prelude
  */
-export function create_static_types(id, env) {
-	const declarations = Object.keys(env[id])
-		.filter((k) => valid_identifier.test(k))
-		.map((k) => `export const ${k}: string;`);
+export function create_sveltekit_env_public(variables, env, prelude) {
+	if (!variables) {
+		return '';
+	}
 
-	return dedent`
-		declare module '$env/static/${id}' {
-			${declarations.join('\n')}
-		}
-	`;
+	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+	const issues = {};
+
+	/** @type {string[]} */
+	const exports = [];
+
+	for (const [name, config] of Object.entries(variables)) {
+		if (!config.public) continue;
+
+		const value = config.static
+			? devalue.uneval(validate(variables, env[name], name, issues))
+			: `env.${name}`;
+
+		exports.push(`export const ${name} = ${value};\n`);
+	}
+
+	handle_issues(issues);
+
+	return `${prelude}\n\n${exports.join('')}`;
 }
 
 /**
- * @param {EnvType} id
- * @param {import('types').Env} env
- * @param {{
- * 	public_prefix: string;
- * 	private_prefix: string;
- * }} prefixes
- * @returns {string}
+ * Creates the `__sveltekit/env/service-worker` module used in development
+ * (but not in prod, which goes through build_service_worker instead)
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
+ * @param {Record<string, string>} env
+ * @param {string} global
  */
-export function create_dynamic_types(id, env, { public_prefix, private_prefix }) {
-	const properties = Object.keys(env[id])
-		.filter((k) => valid_identifier.test(k))
-		.map((k) => `${k}: string;`);
+export function create_sveltekit_env_service_worker_dev(variables, env, global) {
+	/** @type {string[]} */
+	const properties = [];
 
-	const public_prefixed = `[key: \`${public_prefix}\${string}\`]`;
-	const private_prefixed = `[key: \`${private_prefix}\${string}\`]`;
+	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+	const issues = {};
 
-	if (id === 'private') {
-		if (public_prefix) {
-			properties.push(`${public_prefixed}: undefined;`);
-		}
-		properties.push(`${private_prefixed}: string | undefined;`);
-	} else {
-		if (private_prefix) {
-			properties.push(`${private_prefixed}: undefined;`);
-		}
-		properties.push(`${public_prefixed}: string | undefined;`);
+	for (const [name, config] of Object.entries(variables ?? {})) {
+		if (!config.public) continue;
+
+		const value = validate(variables ?? {}, env[name], name, issues);
+		properties.push(`${name}: ${devalue.uneval(value)}`);
 	}
 
+	handle_issues(issues);
+
 	return dedent`
-		declare module '$env/dynamic/${id}' {
-			export const env: {
-				${properties.join('\n')}
+		globalThis.__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ = true;
+
+		${global} = {
+			env: {
+				${properties.join(',\n\t\t') || '// empty'}
 			}
+		};
+	`;
+}
+
+/** @param {string} description */
+function create_jsdoc(description) {
+	return `/**\n${description
+		.split('\n')
+		.map((line) => ` * ${line.replaceAll('*/', '*\\/')}`)
+		.join('\n')}\n */`;
+}
+
+/**
+ * @param {Record<string, EnvVarConfig<any>>} variables
+ * @param {string} relative
+ * @param {EnvType} type
+ */
+export function create_explicit_env_types(variables, relative, type) {
+	const declarations = Object.entries(variables)
+		.filter(([_, config]) => !!config.public === (type === 'public'))
+		.map(([name, config]) => {
+			const comment = config.description ? `${create_jsdoc(config.description)}\n` : '';
+			const type = config.schema
+				? `import('@sveltejs/kit/internal/types').StandardSchemaV1.InferOutput<typeof import('${relative}').variables.${name}.schema>`
+				: 'string';
+			return `${comment}export const ${name}: ${type};`;
+		});
+
+	return dedent`
+		declare module '$app/env/${type}' {
+			${declarations.join('\n') || `// no ${type} environment variables were defined`}
 		}
 	`;
 }

package/src/core/generate_manifest/find_server_assets.js

@@ -4,8 +4,9 @@ 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
+ * @param {string} root
  */
-export function find_server_assets(build_data, routes) {
+export function find_server_assets(build_data, routes, root) {
 	/**
 	 * 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.
@@ -19,7 +20,7 @@ export function find_server_assets(build_data, routes) {
 	/** @param {string} id */
 	function add_assets(id) {
 		if (id in build_data.server_manifest) {
-			const deps = find_deps(build_data.server_manifest, id, false);
+			const deps = find_deps(build_data.server_manifest, id, false, root);
 			for (const asset of deps.assets) {
 				server_assets.add(asset);
 			}

package/src/core/generate_manifest/index.js

@@ -20,9 +20,17 @@ import { uneval } from 'devalue';
  *   relative_path: string;
  *   routes: import('types').RouteData[];
  *   remotes: RemoteChunk[];
+ *   root: string;
  * }} opts
  */
-export function generate_manifest({ build_data, prerendered, relative_path, routes, remotes }) {
+export function generate_manifest({
+	build_data,
+	prerendered,
+	relative_path,
+	routes,
+	remotes,
+	root
+}) {
 	/**
 	 * @type {Map<any, number>} The new index of each node in the filtered nodes array
 	 */
@@ -34,7 +42,7 @@ export function generate_manifest({ build_data, prerendered, relative_path, rout
 	 */
 	const used_nodes = new Set([0, 1]);
 
-	const server_assets = find_server_assets(build_data, routes);
+	const server_assets = find_server_assets(build_data, routes, root);
 
 	for (const route of routes) {
 		if (route.page) {
@@ -119,7 +127,7 @@ export function generate_manifest({ build_data, prerendered, relative_path, rout
 								pattern: ${route.pattern},
 								params: ${s(route.params)},
 								page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
-								endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
+								endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file, root).chunk.file)) : 'null'}
 							}
 						`;
 					}).filter(Boolean).join(',\n')}

package/src/core/postbuild/analyse.js

@@ -1,12 +1,11 @@
+/** @import { Adapter } from '@sveltejs/kit' */
 /** @import { RemoteChunk } from 'types' */
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { validate_server_exports } from '../../utils/exports.js';
-import { load_config } from '../config/index.js';
+import { extract_svelte_config, load_vite_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
-import { installPolyfills } from '../../exports/node/polyfills.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
-import { filter_env } from '../../utils/env.js';
 import { has_server_load, resolve_route } from '../../utils/routing.js';
 import { check_feature } from '../../utils/features.js';
 import { createReadableStream } from '@sveltejs/kit/node';
@@ -25,6 +24,8 @@ export default forked(import.meta.url, analyse);
  *   env: Record<string, string>;
  *   out: string;
  *   remotes: RemoteChunk[];
+ *   root: string;
+ *   vite_config_file: string | undefined;
  * }} opts
  */
 async function analyse({
@@ -35,36 +36,39 @@ async function analyse({
 	tracked_features,
 	env,
 	out,
-	remotes
+	remotes,
+	root,
+	vite_config_file
 }) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
-	/** @type {import('types').ValidatedKitConfig} */
-	const config = (await load_config()).kit;
+	const vite_config = await load_vite_config(vite_config_file);
+
+	const config = extract_svelte_config(vite_config).kit;
+
+	// TODO i think this can just be config.adapter?
+	/** @type {Adapter | undefined} */
+	const adapter = vite_config.plugins.find(
+		(plugin) => plugin.name === 'vite-plugin-sveltekit-adapter'
+	)?.api?.adapter;
 
 	const server_root = join(config.outDir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */
 	const internal = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
 
-	installPolyfills();
-
-	// configure `import { building } from '$app/environment'` —
+	// configure `import { building } from '$app/env'` —
 	// essential we do this before analysing the code
 	internal.set_building();
 
 	// set env, `read`, and `manifest`, in case they're used in initialisation
-	const { publicPrefix: public_prefix, privatePrefix: private_prefix } = config.env;
-	const private_env = filter_env(env, private_prefix, public_prefix);
-	const public_env = filter_env(env, public_prefix, private_prefix);
-	internal.set_private_env(private_env);
-	internal.set_public_env(public_env);
+	internal.set_env(env);
 	internal.set_manifest(manifest);
 	internal.set_read_implementation((file) => createReadableStream(`${server_root}/server/${file}`));
 
 	// first, build server nodes without the client manifest so we can analyse it
-	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null);
+	build_server_nodes(out, config, manifest_data, server_manifest, null, null, null, root);
 
 	/** @type {import('types').ServerMetadata} */
 	const metadata = {
@@ -130,7 +134,7 @@ async function analyse({
 				server_manifest,
 				tracked_features
 			)) {
-				check_feature(route.id, route_config, feature, config.adapter);
+				check_feature(route.id, route_config, feature, adapter);
 			}
 		}
 

package/src/core/postbuild/fallback.js

@@ -1,7 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { installPolyfills } from '../../exports/node/polyfills.js';
 import { forked } from '../../utils/fork.js';
 
 export default forked(import.meta.url, generate_fallback);
@@ -16,8 +15,6 @@ export default forked(import.meta.url, generate_fallback);
  * }} opts
  */
 async function generate_fallback({ manifest_path, env, out_dir, origin, assets }) {
-	installPolyfills();
-
 	const server_root = join(out_dir, 'output');
 
 	/** @type {import('types').ServerInternalModule} */