@sveltejs/kit 2.62.0 → 2.63.1

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';
@@ -21,13 +29,8 @@ import { build_service_worker } from './build/build_service_worker.js';
 import { assets_base, find_deps, resolve_symlinks } from './build/utils.js';
 import { dev } from './dev/index.js';
 import { preview } from './preview/index.js';
-import {
-	error_for_missing_config,
-	get_config_aliases,
-	get_env,
-	normalize_id,
-	stackless
-} from './utils.js';
+import { error_for_missing_config, get_config_aliases, get_env, normalize_id } from './utils.js';
+import { stackless } from '../../utils/error.js';
 import { write_client_manifest } from '../../core/sync/write_client_manifest.js';
 import prerender from '../../core/postbuild/prerender.js';
 import analyse from '../../core/postbuild/analyse.js';
@@ -40,8 +43,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 +244,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 +357,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 +401,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 +411,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 +482,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 +535,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 +543,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 +582,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 +606,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 +661,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 +703,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 +911,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 +1479,8 @@ async function kit({ svelte_config }) {
 						manifest_data,
 						service_worker_entry_file,
 						prerendered,
-						client_manifest
+						client_manifest,
+						explicit_env_config
 					);
 				}
 
@@ -1414,7 +1503,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 +1537,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/static_analysis/index.js

@@ -1,8 +1,9 @@
+/** @import { PageOptions } from './types.js' */
 import { tsPlugin } from '@sveltejs/acorn-typescript';
 import { Parser } from 'acorn';
 import { read } from '../../../utils/filesystem.js';
 
-const valid_page_options_array = /** @type {const} */ ([
+export const valid_page_options_array = /** @type {const} */ ([
 	'ssr',
 	'prerender',
 	'csr',
@@ -15,9 +16,6 @@ const valid_page_options_array = /** @type {const} */ ([
 /** @type {Set<string>} */
 const valid_page_options = new Set(valid_page_options_array);
 
-/** @typedef {typeof valid_page_options_array[number]} ValidPageOption */
-/** @typedef {Partial<Record<ValidPageOption, any>>} PageOptions */
-
 const skip_parsing_regex = new RegExp(
 	`${Array.from(valid_page_options).join('|')}|(?:export[\\s\\n]+\\*[\\s\\n]+from)`
 );

package/src/exports/vite/static_analysis/types.d.ts

@@ -0,0 +1,14 @@
+import type { PrerenderOption, TrailingSlash } from 'types';
+import type { valid_page_options_array } from './index.js';
+
+type ValidPageOption = (typeof valid_page_options_array)[number];
+
+export type PageOptions = Partial<{
+	[K in ValidPageOption]: K extends 'ssr' | 'csr'
+		? boolean
+		: K extends 'prerender'
+			? PrerenderOption
+			: K extends 'trailingSlash'
+				? TrailingSlash
+				: any;
+}>;

package/src/exports/vite/utils.js

@@ -4,9 +4,11 @@ import { posixify } from '../../utils/filesystem.js';
 import { negotiate } from '../../utils/http.js';
 import { filter_env } from '../../utils/env.js';
 import { escape_html } from '../../utils/escape.js';
+import { stackless } from '../../utils/error.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 +73,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 +158,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';
 	}
@@ -178,18 +185,6 @@ export function normalize_id(id, lib, cwd) {
 	return posixify(id);
 }
 
-/**
- * For times when you need to throw an error, but without
- * displaying a useless stack trace (since the developer
- * can't do anything useful with it)
- * @param {string} message
- */
-export function stackless(message) {
-	const error = new Error(message);
-	error.stack = '';
-	return error;
-}
-
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**

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

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

@@ -0,0 +1 @@
+export * from '#app/env/public';

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

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

package/src/runtime/app/env/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `true` if the app is running in the browser.
+ */
+export const browser: boolean;
+
+/**
+ * Whether the dev server is running. This is not guaranteed to correspond to `NODE_ENV` or `MODE`.
+ */
+export const dev: boolean;
+
+/**
+ * SvelteKit analyses your app during the `build` step by running it. During this process, `building` is `true`. This also applies during prerendering.
+ */
+export const building: boolean;
+
+/**
+ * The value of `config.kit.version.name`.
+ */
+export const version: string;

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

@@ -1,2 +1,8 @@
-export { BROWSER as browser, DEV as dev } from 'esm-env';
-export { building, version } from '__sveltekit/environment';
+import { dev } from '../env/index.js';
+export * from '../env/index.js';
+
+if (dev && __SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__) {
+	console.warn(
+		'Use `$app/env` instead of `$app/environment` when `experimental.explicitEnvironmentVariables` is enabled'
+	);
+}

package/src/runtime/app/server/remote/query.js

@@ -3,7 +3,7 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { create_remote_key, stringify, stringify_remote_arg } from '../../../shared.js';
-import { prerendering } from '__sveltekit/environment';
+import { prerendering } from '$app/env/internal';
 import {
 	create_validator,
 	get_cache,

package/src/runtime/client/ndjson.js

@@ -1,42 +1,15 @@
+import { read_stream } from './stream.js';
+
 /**
  * Yields parsed JSON objects from a ReadableStream of newline-delimited JSON.
  * Each yielded value is the raw `JSON.parse`'d object — callers handle deserialization.
  * @param {ReadableStreamDefaultReader<Uint8Array>} reader
  */
 export async function* read_ndjson(reader) {
-	let done = false;
-	let buffer = '';
-	const decoder = new TextDecoder();
-
-	while (true) {
-		let split = buffer.indexOf('\n');
-		while (split !== -1) {
-			const line = buffer.slice(0, split).trim();
-			buffer = buffer.slice(split + 1);
-
-			if (line) {
-				yield JSON.parse(line);
-			}
-
-			split = buffer.indexOf('\n');
-		}
-
-		if (done) {
-			const line = buffer.trim();
-			if (line) {
-				yield JSON.parse(line);
-			}
-			return;
-		}
-
-		const chunk = await reader.read();
-		done = chunk.done;
-		if (chunk.value) {
-			buffer += decoder.decode(chunk.value, { stream: true });
-		}
-
-		if (done) {
-			buffer += decoder.decode();
+	for await (const block of read_stream(reader, '\n')) {
+		const line = block.trim();
+		if (line) {
+			yield JSON.parse(line);
 		}
 	}
 }

package/src/runtime/client/remote-functions/prerender.svelte.js

@@ -1,6 +1,6 @@
 /** @import { RemotePrerenderFunction } from '@sveltejs/kit' */
 import { app_dir, base } from '$app/paths/internal/client';
-import { version } from '__sveltekit/environment';
+import { version } from '$app/env';
 import * as devalue from 'devalue';
 import { app, prerender_responses } from '../client.js';
 import { get_remote_request_headers, remote_request } from './shared.svelte.js';