@sveltejs/kit 2.62.0 → 2.63.0

package/src/core/sync/write_env.js

@@ -0,0 +1,32 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+import path from 'node:path';
+import { create_explicit_env_types } from '../env.js';
+import { write_if_changed } from './utils.js';
+
+const DOCS = '// See https://svelte.dev/docs/kit/environment-variables for more information';
+
+/**
+ * Writes ambient declarations including types reference to @sveltejs/kit,
+ * and the existing environment variables in process.env to
+ * $env/static/private and $env/static/public
+ * @param {import('types').ValidatedKitConfig} kit
+ * @param {string | null} entry
+ * @param {Record<string, EnvVarConfig<any>> | null} env_config
+ */
+export function write_env(kit, entry, env_config) {
+	const content = [];
+	const out = path.join(kit.outDir, 'env.d.ts');
+
+	if (entry && env_config) {
+		const relative = path.relative(kit.outDir, entry);
+		content.push(
+			`// This file is generated from ${relative}.\n${DOCS}`,
+			create_explicit_env_types(env_config, relative, 'private'),
+			create_explicit_env_types(env_config, relative, 'public')
+		);
+	} else {
+		content.push(DOCS);
+	}
+
+	write_if_changed(out, content.join('\n\n'));
+}

package/src/core/sync/write_root.js

@@ -100,7 +100,7 @@ export function write_root(manifest_data, config, output) {
 			${isSvelte5Plus() ? '<svelte:options runes={true} />' : ''}
 			<script>
 				import { setContext, ${isSvelte5Plus() ? '' : 'afterUpdate, '}onMount, tick } from 'svelte';
-				import { browser } from '$app/environment';
+				import { browser } from '$app/env';
 
 				// stores
 				${

package/src/core/sync/write_server.js

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

package/src/core/sync/write_tsconfig.js

@@ -57,6 +57,7 @@ export function get_tsconfig(kit) {
 
 	const include = new Set([
 		'ambient.d.ts', // careful: changing this name would be a breaking change, because it's referenced in the service-workers documentation
+		'env.d.ts',
 		'non-ambient.d.ts',
 		'./types/**/$types.d.ts',
 		config_relative('vite.config.js'),

package/src/exports/hooks/index.js

@@ -1 +1,14 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+
 export { sequence } from './sequence.js';
+
+/**
+ * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
+ * which are made available via `$app/env/public` and `$app/env/private`.
+ * @template {Record<string, EnvVarConfig<any>>} T
+ * @param {T} variables
+ * @returns {T}
+ */
+export function defineEnvVars(variables) {
+	return variables;
+}

package/src/exports/internal/env.js

@@ -0,0 +1,71 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+
+import { stackless } from '../vite/utils.js';
+
+const MISSING = {
+	message: `Value is missing. If it is optional, add a Standard Schema validator declaring it as such.`
+};
+
+const BAD_VALIDATOR = {
+	message: 'Variable was configured with a validator that does not implement Standard Schema'
+};
+
+const ASYNC_VALIDATOR = {
+	message: 'Variable uses an async validator, which is not supported'
+};
+
+/**
+ * @param {Record<string, EnvVarConfig<any>>} variables
+ * @param {string | undefined} value
+ * @param {string} name
+ * @param {Record<string, StandardSchemaV1.Issue[]>} issues
+ * @returns
+ */
+export function validate(variables, value, name, issues) {
+	const config = variables[name] ?? {};
+	const validator = config.schema;
+
+	if (!validator) {
+		if (!value) issues[name] = [MISSING];
+		return value;
+	}
+
+	if (!validator['~standard']) {
+		issues[name] = [BAD_VALIDATOR];
+		return;
+	}
+
+	const result = validator['~standard'].validate(value);
+
+	if (result instanceof Promise) {
+		issues[name] = [ASYNC_VALIDATOR];
+		return;
+	}
+
+	if (result.issues) {
+		issues[name] = [...result.issues];
+		return;
+	}
+
+	return result.value;
+}
+
+/**
+ * @param {Record<string, StandardSchemaV1.Issue[]>} issues
+ */
+export function handle_issues(issues) {
+	const entries = Object.entries(issues);
+
+	if (entries.length === 0) {
+		return;
+	}
+
+	let message = 'Invalid environment variables\n';
+
+	for (const [name, issues] of entries) {
+		message += `\n${name}\n${issues.map((issue) => `  - ${issue.message}`).join('\n')}\n`;
+	}
+
+	throw stackless(message);
+}

package/src/exports/internal/types.d.ts

@@ -0,0 +1,3 @@
+// We re-export this so we can use it in the `$app/env/*` module declarations
+// without the app needing to depend on this package
+export { StandardSchemaV1 } from '@standard-schema/spec';

package/src/exports/public.d.ts

@@ -476,6 +476,13 @@ export interface KitConfig {
 	};
 	/** Experimental features. Here be dragons. These are not subject to semantic versioning, so breaking changes or removal can happen in any release. */
 	experimental?: {
+		/**
+		 * Whether to enable explicit environment variables using `src/env.js` or `src/env.ts`.
+		 * @since 2.62.0
+		 * @default false
+		 */
+		explicitEnvironmentVariables?: boolean;
+
 		/**
 		 * Options for enabling server-side [OpenTelemetry](https://opentelemetry.io/) tracing for SvelteKit operations including the [`handle` hook](https://svelte.dev/docs/kit/hooks#Server-hooks-handle), [`load` functions](https://svelte.dev/docs/kit/load), [form actions](https://svelte.dev/docs/kit/form-actions), and [remote functions](https://svelte.dev/docs/kit/remote-functions).
 		 * @default { server: false, serverFile: false }
@@ -2314,4 +2321,37 @@ export type RemoteLiveQueryFunction<Input, Output, _Validated = Input> = (
 	arg: undefined extends Input ? Input | void : Input
 ) => RemoteLiveQuery<Output>;
 
+/**
+ * [Environment variables](https://svelte.dev/docs/kit/environment-variables) can be configured by exporting
+ * a `variables` object from `src/env.ts`, using [`defineEnvVars`](https://svelte.dev/docs/kit/@sveltejs-kit-hooks#defineEnvVars).
+ */
+export interface EnvVarConfig<T> {
+	/**
+	 * Whether the environment variable can be accessed by client-side code.
+	 * - if `true`, it can be imported from `$app/env/public`
+	 * - if `false`, it can be imported from `$app/env/private`, which is a [server-only module](https://svelte.dev/docs/kit/server-only-modules)
+	 * @default false
+	 */
+	public?: boolean;
+	/**
+	 * Whether the value is determined at build time or when the app runs.
+	 * - if `true`, the build time value is inlined into the bundle. This enables optimisations like dead-code elimination
+	 * - if `false`, the value is read from the environment when the app starts
+	 * @default false
+	 */
+	static?: boolean;
+	/**
+	 * A [Standard Schema](https://standardschema.dev/) validator that is applied to the value when the app starts.
+	 * The validator can output any value — not necessarily a string — but public, non-static values must be
+	 * serializable by [devalue](https://github.com/sveltejs/devalue) so that they can be sent to the browser.
+	 *
+	 * If omitted, the value must be a non-empty string.
+	 */
+	schema?: StandardSchemaV1<string | undefined, T>;
+	/**
+	 * A description of the variable that will be used for inline documentation on hover.
+	 */
+	description?: string;
+}
+
 export * from './index.js';

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

@@ -1,10 +1,11 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
 import fs from 'node:fs';
 import process from 'node:process';
 import * as vite from 'vite';
 import { dedent } from '../../../core/sync/utils.js';
 import { s } from '../../../utils/misc.js';
 import { get_config_aliases, strip_virtual_prefix, get_env, normalize_id } from '../utils.js';
-import { create_static_module } from '../../../core/env.js';
+import { create_static_module, create_sveltekit_env_public } from '../../../core/env.js';
 import { env_static_public, service_worker } from '../module_ids.js';
 
 // @ts-ignore `vite.rolldownVersion` only exists in `rolldown-vite`
@@ -18,6 +19,7 @@ const is_rolldown = !!vite.rolldownVersion;
  * @param {string} service_worker_entry_file
  * @param {import('types').Prerendered} prerendered
  * @param {import('vite').Manifest} client_manifest
+ * @param {Record<string, EnvVarConfig<any>> | null} env_config
  */
 export async function build_service_worker(
 	out,
@@ -26,7 +28,8 @@ export async function build_service_worker(
 	manifest_data,
 	service_worker_entry_file,
 	prerendered,
-	client_manifest
+	client_manifest,
+	env_config
 ) {
 	const build = new Set();
 	for (const key in client_manifest) {
@@ -85,7 +88,20 @@ export async function build_service_worker(
 			}
 
 			if (id === env_static_public) {
-				return create_static_module('$env/static/public', env.public);
+				return create_static_module(
+					'$env/static/public',
+					env.public,
+					kit.experimental.explicitEnvironmentVariables
+				);
+			}
+
+			if (id === '\0virtual:app/env/public') {
+				// TODO ideally we would only add the `importScripts` if there are dynamic vars that are known to be used
+				return create_sveltekit_env_public(
+					env_config,
+					env.all,
+					`importScripts('${kit.paths.base}/${kit.appDir}/env.script.js'); const env = globalThis.__sveltekit_sw.env;`
+				);
 			}
 
 			const normalized_cwd = vite.normalizePath(process.cwd());
@@ -93,7 +109,7 @@ export async function build_service_worker(
 			const relative = normalize_id(id, normalized_lib, normalized_cwd);
 			const stripped = strip_virtual_prefix(relative);
 			throw new Error(
-				`Cannot import ${stripped} into service-worker code. Only the modules $service-worker and $env/static/public are available in service workers.`
+				`Cannot import ${stripped} into service-worker code. Only the modules $service-worker, $env/static/public and $app/env/public are available in service workers.`
 			);
 		}
 	};

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

@@ -322,7 +322,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 			// ssrFixStacktrace can fail on StackBlitz web containers and we don't know why
 			// by ignoring it the line numbers are wrong, but at least we can show the error
 		}
-		return error.stack;
+		return error.stack?.replaceAll('\0', ''); // remove null bytes from e.g. virtual module IDs, or the response will fail
 	}
 
 	update_manifest();
@@ -587,7 +587,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes) {
 			} catch (e) {
 				const error = coalesce_to_error(e);
 				res.statusCode = 500;
-				res.end(fix_stack_trace(error));
+				res.end(fix_stack_trace(error) || error.message); // handle `stackless` errors
 			}
 		});
 	};

package/src/exports/vite/index.js

@@ -1,3 +1,4 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
 /** @import { Options, SvelteConfig } from '@sveltejs/vite-plugin-svelte' */
 /** @import { PreprocessorGroup } from 'svelte/compiler' */
 /** @import { KitConfig } from '@sveltejs/kit' */
@@ -6,11 +7,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
-
 import colors from 'kleur';
 
 import { copy, mkdirp, posixify, read, resolve_entry, rimraf } from '../../utils/filesystem.js';
-import { create_static_module, create_dynamic_module } from '../../core/env.js';
+import {
+	create_dynamic_module,
+	create_sveltekit_env,
+	create_sveltekit_env_public,
+	create_static_module,
+	resolve_explicit_env_entry,
+	create_sveltekit_env_service_worker_dev,
+	create_sveltekit_env_private
+} from '../../core/env.js';
 import * as sync from '../../core/sync/sync.js';
 import { create_assets } from '../../core/sync/create_manifest_data/index.js';
 import { runtime_directory, logger } from '../../core/utils.js';
@@ -40,8 +48,12 @@ import {
 	env_static_private,
 	env_static_public,
 	service_worker,
-	sveltekit_environment,
-	sveltekit_server
+	sveltekit_env,
+	sveltekit_env_private,
+	sveltekit_env_service_worker,
+	sveltekit_server,
+	sveltekit_env_public_client,
+	sveltekit_env_public_server
 } from './module_ids.js';
 import { import_peer } from '../../utils/import.js';
 import { compact } from '../../utils/array.js';
@@ -237,7 +249,7 @@ async function kit({ svelte_config }) {
 	/** @type {boolean} */
 	let is_build;
 
-	/** @type {{ public: Record<string, string>; private: Record<string, string> }} */
+	/** @type {{ all: Record<string, string>; public: Record<string, string>; private: Record<string, string> }} */
 	let env;
 
 	/** @type {() => Promise<void>} */
@@ -350,7 +362,7 @@ async function kit({ svelte_config }) {
 							// because they for example use esbuild.build with `platform: 'browser'`
 							'esm-env',
 							// This forces `$app/*` modules to be bundled, since they depend on
-							// virtual modules like `__sveltekit/environment` (this isn't a valid bare
+							// virtual modules like `__sveltekit/env` (this isn't a valid bare
 							// import, but it works with vite-node's externalization logic, which
 							// uses basic concatenation)
 							'@sveltejs/kit/src/runtime'
@@ -394,6 +406,7 @@ async function kit({ svelte_config }) {
 
 				const define = {
 					__SVELTEKIT_APP_DIR__: s(kit.appDir),
+					__SVELTEKIT_APP_VERSION__: s(kit.version.name),
 					__SVELTEKIT_EMBEDDED__: s(kit.embedded),
 					__SVELTEKIT_FORK_PRELOADS__: s(kit.experimental.forkPreloads),
 					__SVELTEKIT_PATHS_ASSETS__: s(kit.paths.assets),
@@ -403,6 +416,9 @@ async function kit({ svelte_config }) {
 					__SVELTEKIT_HASH_ROUTING__: s(kit.router.type === 'hash'),
 					__SVELTEKIT_SERVER_TRACING_ENABLED__: s(kit.experimental.tracing.server),
 					__SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__: s(kit.experimental.handleRenderingErrors),
+					__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__: s(
+						kit.experimental.explicitEnvironmentVariables
+					),
 					__SVELTEKIT_DEV__: s(!is_build)
 				};
 
@@ -471,10 +487,50 @@ async function kit({ svelte_config }) {
 		}
 	};
 
+	/** @type {string | null} */
+	let explicit_env_entry = null;
+
+	/** @type {Record<string, EnvVarConfig<any>> | null} */
+	let explicit_env_config = null;
+
 	/** @type {Plugin} */
 	const plugin_virtual_modules = {
 		name: 'vite-plugin-sveltekit-virtual-modules',
 
+		async configResolved(config) {
+			explicit_env_entry = resolve_explicit_env_entry(kit);
+			explicit_env_config = await sync.env(kit, explicit_env_entry, config.mode);
+		},
+
+		configureServer(server) {
+			if (!kit.experimental.explicitEnvironmentVariables) {
+				return;
+			}
+
+			server.watcher.on('all', async (_, file) => {
+				if (!file.includes('env')) {
+					return;
+				}
+
+				const resolved = resolve_explicit_env_entry(kit);
+
+				if (file === explicit_env_entry || file === resolved) {
+					explicit_env_entry = resolved;
+					explicit_env_config = await sync.env(kit, explicit_env_entry, vite_config_env.mode);
+
+					for (const id of [sveltekit_env, sveltekit_env_public_client]) {
+						const module = server.moduleGraph.getModuleById(id);
+
+						if (module) {
+							server.moduleGraph.invalidateModule(module);
+						}
+					}
+
+					server.ws.send({ type: 'full-reload' });
+				}
+			});
+		},
+
 		resolveId(id, importer) {
 			if (id === '__sveltekit/manifest') {
 				return `${out_dir}/generated/client-optimized/app.js`;
@@ -484,6 +540,7 @@ async function kit({ svelte_config }) {
 			// This check won't catch transitive imports, but it will warn when the import comes from a service-worker directly.
 			// Transitive imports will be caught during the build.
 			// TODO move this logic to plugin_guard
+			// TODO allow $app/env/public
 			if (importer) {
 				const parsed_importer = path.parse(importer);
 
@@ -491,13 +548,19 @@ async function kit({ svelte_config }) {
 					parsed_importer.dir === parsed_service_worker.dir &&
 					parsed_importer.name === parsed_service_worker.name;
 
-				if (importer_is_service_worker && id !== '$service-worker' && id !== '$env/static/public') {
+				if (
+					importer_is_service_worker &&
+					id !== '$service-worker' &&
+					id !== '$env/static/public' &&
+					id !== 'virtual:$app/env/public' &&
+					id !== '__sveltekit/env/service-worker'
+				) {
 					throw new Error(
 						`Cannot import ${normalize_id(
 							id,
 							normalized_lib,
 							normalized_cwd
-						)} into service-worker code. Only the modules $service-worker and $env/static/public are available in service workers.`
+						)} into service-worker code. Only the modules $service-worker, $env/static/public and $app/env/public are available in service workers.`
 					);
 				}
 			}
@@ -524,17 +587,20 @@ async function kit({ svelte_config }) {
 				? `globalThis.__sveltekit_${version_hash}`
 				: 'globalThis.__sveltekit_dev';
 
+			const explicit_env_flag = kit.experimental.explicitEnvironmentVariables;
+
 			switch (id) {
 				case env_static_private:
-					return create_static_module('$env/static/private', env.private);
+					return create_static_module('$env/static/private', env.private, explicit_env_flag);
 
 				case env_static_public:
-					return create_static_module('$env/static/public', env.public);
+					return create_static_module('$env/static/public', env.public, explicit_env_flag);
 
 				case env_dynamic_private:
 					return create_dynamic_module(
 						'private',
-						vite_config_env.command === 'serve' ? env.private : undefined
+						vite_config_env.command === 'serve' ? env.private : undefined,
+						explicit_env_flag
 					);
 
 				case env_dynamic_public:
@@ -545,29 +611,35 @@ async function kit({ svelte_config }) {
 
 					return create_dynamic_module(
 						'public',
-						vite_config_env.command === 'serve' ? env.public : undefined
+						vite_config_env.command === 'serve' ? env.public : undefined,
+						explicit_env_flag
 					);
 
 				case service_worker:
 					return create_service_worker_module(svelte_config);
 
-				case sveltekit_environment: {
-					const { version } = svelte_config.kit;
+				case sveltekit_env:
+					return create_sveltekit_env(explicit_env_config, env.all, explicit_env_entry);
 
-					return dedent`
-						export const version = ${s(version.name)};
-						export let building = false;
-						export let prerendering = false;
+				case sveltekit_env_public_client:
+					return create_sveltekit_env_public(
+						explicit_env_config,
+						env.all,
+						`const env = ${global}.env;`
+					);
 
-						export function set_building() {
-							building = true;
-						}
+				case sveltekit_env_public_server:
+					return create_sveltekit_env_public(
+						explicit_env_config,
+						env.all,
+						`import { rendered_env as env } from '__sveltekit/env';`
+					);
 
-						export function set_prerendering() {
-							prerendering = true;
-						}
-					`;
-				}
+				case sveltekit_env_private:
+					return create_sveltekit_env_private(explicit_env_config, env.all);
+
+				case sveltekit_env_service_worker:
+					return create_sveltekit_env_service_worker_dev(explicit_env_config, env.all, global);
 
 				case sveltekit_server: {
 					return dedent`
@@ -594,7 +666,7 @@ async function kit({ svelte_config }) {
 
 	/**
 	 * Ensures that client-side code can't accidentally import server-side code,
-	 * whether in `*.server.js` files, `$app/server`, `$lib/server`, or `$env/[static|dynamic]/private`
+	 * whether in `*.server.js` files, `$app/server`, `$lib/server`, `$app/env/private`, or `$env/[static|dynamic]/private`
 	 * @type {Plugin}
 	 */
 	const plugin_guard = {
@@ -636,6 +708,7 @@ async function kit({ svelte_config }) {
 			const is_server_only =
 				normalized === '$env/static/private' ||
 				normalized === '$env/dynamic/private' ||
+				normalized === '$app/env/private' ||
 				normalized === '$app/server' ||
 				normalized.startsWith('$lib/server/') ||
 				(is_internal && server_only_pattern.test(path.basename(id)));
@@ -843,6 +916,26 @@ async function kit({ svelte_config }) {
 		}
 	};
 
+	/** @type {Plugin} */
+	const plugin_service_worker_env = {
+		name: 'vite-plugin-sveltekit-service-worker-env',
+
+		transform: {
+			filter: {
+				id: service_worker_entry_file || '<skip>'
+			},
+			handler(code) {
+				// in dev, we prepend the service worker with an import that
+				// configures `env`, in case `$app/env/public` is imported,
+				// in prod, where we currently use non-module service
+				// workers, we have to use `importScripts` instead
+				return {
+					code: `import '__sveltekit/env/service-worker';\n${code}`
+				};
+			}
+		}
+	};
+
 	/** @type {Plugin} */
 	const plugin_compile = {
 		name: 'vite-plugin-sveltekit-compile',
@@ -1391,7 +1484,8 @@ async function kit({ svelte_config }) {
 						manifest_data,
 						service_worker_entry_file,
 						prerendered,
-						client_manifest
+						client_manifest,
+						explicit_env_config
 					);
 				}
 
@@ -1414,7 +1508,8 @@ async function kit({ svelte_config }) {
 							prerender_map,
 							log,
 							remotes,
-							vite_config
+							vite_config,
+							explicit_env_config
 						);
 					} else {
 						console.log(colors.bold().yellow('\nNo adapter specified'));
@@ -1447,6 +1542,9 @@ async function kit({ svelte_config }) {
 		kit.experimental.remoteFunctions && plugin_remote,
 		plugin_virtual_modules,
 		plugin_guard,
+		kit.experimental.explicitEnvironmentVariables &&
+			service_worker_entry_file &&
+			plugin_service_worker_env,
 		plugin_compile
 	].filter((p) => !!p);
 }

package/src/exports/vite/module_ids.js

@@ -6,11 +6,20 @@ 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 sveltekit_env = '\0virtual:__sveltekit/env';
+export const sveltekit_env_public_client = '\0virtual:__sveltekit/env/public/client';
+export const sveltekit_env_public_server = '\0virtual:__sveltekit/env/public/server';
+export const sveltekit_env_private = '\0virtual:__sveltekit/env/private';
+export const sveltekit_env_service_worker = '\0virtual:__sveltekit/env/service-worker';
+
 export const service_worker = '\0virtual:service-worker';
 
-export const sveltekit_environment = '\0virtual:__sveltekit/environment';
 export const sveltekit_server = '\0virtual:__sveltekit/server';
 
 export const app_server = posixify(
 	fileURLToPath(new URL('../../runtime/app/server/index.js', import.meta.url))
 );
+
+export const app_env_private = posixify(
+	fileURLToPath(new URL('../../runtime/app/env/private.js', import.meta.url))
+);

package/src/exports/vite/utils.js

@@ -7,6 +7,7 @@ import { escape_html } from '../../utils/escape.js';
 import { dedent } from '../../core/sync/utils.js';
 import {
 	app_server,
+	app_env_private,
 	env_dynamic_private,
 	env_dynamic_public,
 	env_static_private,
@@ -71,6 +72,7 @@ export function get_env(env_config, mode) {
 	const env = loadEnv(mode, env_config.dir, '');
 
 	return {
+		all: env,
 		public: filter_env(env, public_prefix, private_prefix),
 		private: filter_env(env, private_prefix, public_prefix)
 	};
@@ -155,6 +157,10 @@ export function normalize_id(id, lib, cwd) {
 		return '$app/server';
 	}
 
+	if (id === app_env_private) {
+		return '$app/env/private';
+	}
+
 	if (id === env_static_private) {
 		return '$env/static/private';
 	}

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

@@ -0,0 +1,2 @@
+export { BROWSER as browser, DEV as dev } from 'esm-env';
+export { building, version } from './internal.js';

package/src/runtime/app/env/internal.js

@@ -0,0 +1,11 @@
+export const version = __SVELTEKIT_APP_VERSION__;
+export let building = false;
+export let prerendering = false;
+
+export function set_building() {
+	building = true;
+}
+
+export function set_prerendering() {
+	prerendering = true;
+}

package/src/runtime/app/env/private.js

@@ -0,0 +1 @@
+export * from '__sveltekit/env/private';

package/src/runtime/app/env/public/client.js

@@ -0,0 +1,7 @@
+export * from '__sveltekit/env/public/client';
+
+if (!__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__) {
+	throw new Error(
+		'Cannot import `$app/env/public` unless `experimental.explicitEnvironmentVariables` is enabled'
+	);
+}