@sveltejs/kit 2.61.1 → 2.63.0

package/src/runtime/app/state/client.js

@@ -1,3 +1,4 @@
+import { DEV } from 'esm-env';
 import {
 	page as _page,
 	navigating as _navigating,
@@ -53,12 +54,15 @@ export const navigating = {
 	}
 };
 
-Object.defineProperty(navigating, 'current', {
-	get() {
-		// between 2.12.0 and 2.12.1 `navigating.current` existed
-		throw new Error('Replace navigating.current.<prop> with navigating.<prop>');
-	}
-});
+// TODO: remove in 3.0
+if (DEV) {
+	Object.defineProperty(navigating, 'current', {
+		get() {
+			// between 2.12.0 and 2.12.1 `navigating.current` existed
+			throw new Error('Replace navigating.current.<prop> with navigating.<prop>');
+		}
+	});
+}
 
 export const updated = {
 	get current() {

package/src/runtime/client/client.js

@@ -1,3 +1,4 @@
+/** @import { ServerNodesResponse, ServerRedirectNode } from 'types' */
 /** @import { CacheEntry } from './remote-functions/cache.svelte.js' */
 /** @import { Query } from './remote-functions/query/instance.svelte.js' */
 /** @import { LiveQuery } from './remote-functions/query-live/instance.svelte.js' */
@@ -231,6 +232,7 @@ let load_cache = null;
 function discard_load_cache() {
 	void load_cache?.fork?.then((f) => f?.discard());
 	load_cache = null;
+	current_a = { element: undefined, href: undefined };
 }
 
 /**
@@ -1842,8 +1844,10 @@ async function navigate({
 	if (load_cache?.fork && !load_cache_fork) {
 		// discard fork of different route
 		discard_load_cache();
+	} else {
+		load_cache = null;
+		current_a = { element: undefined, href: undefined };
 	}
-	load_cache = null;
 
 	navigation_result.props.page.state = state;
 
@@ -2029,11 +2033,16 @@ if (import.meta.hot) {
 
 /** @typedef {(typeof PRELOAD_PRIORITIES)['hover'] | (typeof PRELOAD_PRIORITIES)['tap']} PreloadDataPriority */
 
+/**
+ * The anchor element whose href is being preloaded. It is reset after navigation
+ * or changes when a different anchor element is being preloaded.
+ * @type {{ element: Element | SVGAElement | undefined; href: string | SVGAnimatedString | undefined }}
+ */
+let current_a = { element: undefined, href: undefined };
+
 function setup_preload() {
 	/** @type {NodeJS.Timeout} */
 	let mousemove_timeout;
-	/** @type {{ element: Element | SVGAElement | undefined; href: string | SVGAnimatedString | undefined }} */
-	let current_a = { element: undefined, href: undefined };
 	/** @type {PreloadDataPriority} */
 	let current_priority;
 
@@ -2626,7 +2635,7 @@ function _start_router() {
 	});
 
 	// @ts-expect-error this isn't supported everywhere yet
-	if (!navigator.connection?.saveData && !/2g/.test(navigator.connection?.effectiveType)) {
+	if (!navigator.connection?.saveData) {
 		setup_preload();
 	}
 
@@ -3067,61 +3076,69 @@ async function load_data(url, invalid) {
 		throw new HttpError(res.status, message);
 	}
 
-	// TODO: fix eslint error / figure out if it actually applies to our situation
-	// eslint-disable-next-line
-	return new Promise(async (resolve) => {
-		/**
-		 * Map of deferred promises that will be resolved by a subsequent chunk of data
-		 * @type {Map<string, import('types').Deferred>}
-		 */
-		const deferreds = new Map();
-		const reader = /** @type {ReadableStream<Uint8Array>} */ (res.body).getReader();
-
-		/**
-		 * @param {any} data
-		 */
-		function deserialize(data) {
-			return devalue.unflatten(data, {
-				...app.decoders,
-				Promise: (id) => {
-					return new Promise((fulfil, reject) => {
-						deferreds.set(id, { fulfil, reject });
-					});
-				}
-			});
-		}
+	return new Promise((resolve, reject) => {
+		process_stream(resolve, res).catch(reject);
+	});
 
-		for await (const node of read_ndjson(reader)) {
-			if (node.type === 'redirect') {
-				return resolve(node);
-			}
+	// TODO edge case handling necessary? stream() read fails?
+}
 
-			if (node.type === 'data') {
-				// This is the first (and possibly only, if no pending promises) chunk
-				node.nodes?.forEach((/** @type {any} */ node) => {
-					if (node?.type === 'data') {
-						node.uses = deserialize_uses(node.uses);
-						node.data = deserialize(node.data);
-					}
+/**
+ * @param {(value: ServerNodesResponse | ServerRedirectNode) => void} resolve
+ * @param {Response} res
+ * @returns {Promise<void>}
+ */
+async function process_stream(resolve, res) {
+	const reader = /** @type {ReadableStream<Uint8Array>} */ (res.body).getReader();
+
+	/**
+	 * Map of deferred promises that will be resolved by a subsequent chunk of data
+	 * @type {Map<string, import('types').Deferred>}
+	 */
+	const deferreds = new Map();
+
+	/**
+	 * @param {any} data
+	 */
+	function deserialize(data) {
+		return devalue.unflatten(data, {
+			...app.decoders,
+			Promise: (id) => {
+				return new Promise((fulfil, reject) => {
+					deferreds.set(id, { fulfil, reject });
 				});
+			}
+		});
+	}
 
-				resolve(node);
-			} else if (node.type === 'chunk') {
-				// This is a subsequent chunk containing deferred data
-				const { id, data, error } = node;
-				const deferred = /** @type {import('types').Deferred} */ (deferreds.get(id));
-				deferreds.delete(id);
+	for await (const node of read_ndjson(reader)) {
+		if (node.type === 'redirect') {
+			return resolve(node);
+		}
 
-				if (error) {
-					deferred.reject(deserialize(error));
-				} else {
-					deferred.fulfil(deserialize(data));
+		if (node.type === 'data') {
+			// This is the first (and possibly only, if no pending promises) chunk
+			node.nodes?.forEach((/** @type {any} */ node) => {
+				if (node?.type === 'data') {
+					node.uses = deserialize_uses(node.uses);
+					node.data = deserialize(node.data);
 				}
+			});
+
+			resolve(node);
+		} else if (node.type === 'chunk') {
+			// This is a subsequent chunk containing deferred data
+			const { id, data, error } = node;
+			const deferred = /** @type {import('types').Deferred} */ (deferreds.get(id));
+			deferreds.delete(id);
+
+			if (error) {
+				deferred.reject(deserialize(error));
+			} else {
+				deferred.fulfil(deserialize(data));
 			}
 		}
-	});
-
-	// TODO edge case handling necessary? stream() read fails?
+	}
 }
 
 /**

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';

package/src/runtime/client/utils.js

@@ -1,7 +1,7 @@
 import { BROWSER, DEV } from 'esm-env';
 import { writable } from 'svelte/store';
 import { assets } from '$app/paths';
-import { version } from '__sveltekit/environment';
+import { version } from '$app/env';
 import { noop } from '../../utils/functions.js';
 import { PRELOAD_PRIORITIES } from './constants.js';
 

package/src/runtime/server/env_module.js

@@ -1,7 +1,9 @@
+import * as devalue from 'devalue';
 import { public_env } from '../shared-server.js';
+import { rendered_env } from '__sveltekit/env';
 
 /** @type {string} */
-let body;
+let payload;
 
 /** @type {string} */
 let etag;
@@ -14,7 +16,11 @@ let headers;
  * @returns {Response}
  */
 export function get_public_env(request) {
-	body ??= `export const env=${JSON.stringify(public_env)}`;
+	const script = request.url.endsWith('.script.js');
+
+	const env = __SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ ? rendered_env : public_env;
+
+	payload ??= devalue.uneval(env);
 	etag ??= `W/${Date.now()}`;
 	headers ??= new Headers({
 		'content-type': 'application/javascript; charset=utf-8',
@@ -25,5 +31,9 @@ export function get_public_env(request) {
 		return new Response(undefined, { status: 304, headers });
 	}
 
-	return new Response(body, { headers });
+	if (script) {
+		return new Response(`globalThis.__sveltekit_sw={env:${payload}}`, { headers });
+	}
+
+	return new Response(`export const env=${payload}`, { headers });
 }

package/src/runtime/server/fetch.js

@@ -1,5 +1,6 @@
 import * as set_cookie_parser from 'set-cookie-parser';
 import { noop } from '../../utils/functions.js';
+import { get_set_cookies } from '../../utils/http.js';
 import { respond } from './respond.js';
 import * as paths from '$app/paths/internal/server';
 import { read_implementation } from '__sveltekit/server';
@@ -152,22 +153,19 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 
 				const response = await internal_fetch(request, options, manifest, state);
 
-				const set_cookie = response.headers.get('set-cookie');
-				if (set_cookie) {
-					for (const str of set_cookie_parser.splitCookiesString(set_cookie)) {
-						const { name, value, ...options } = set_cookie_parser.parseString(str, {
-							decodeValues: false
-						});
+				for (const str of get_set_cookies(response.headers)) {
+					const { name, value, ...options } = set_cookie_parser.parseString(str, {
+						decodeValues: false
+					});
 
-						const path = options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
+					const path = options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
 
-						// options.sameSite is string, something more specific is required - type cast is safe
-						set_internal(name, value, {
-							path,
-							encode: (value) => value,
-							.../** @type {import('cookie').CookieSerializeOptions} */ (options)
-						});
-					}
+					// options.sameSite is string, something more specific is required - type cast is safe
+					set_internal(name, value, {
+						path,
+						encode: (value) => value,
+						.../** @type {import('cookie').CookieSerializeOptions} */ (options)
+					});
 				}
 
 				return response;

package/src/runtime/server/index.js

@@ -8,6 +8,7 @@ import { options, get_hooks } from '__SERVER__/internal.js';
 import { filter_env } from '../../utils/env.js';
 import { format_server_error } from './utils.js';
 import { set_read_implementation, set_manifest } from '__sveltekit/server';
+import { set_env } from '__sveltekit/env';
 import { set_app } from './app.js';
 
 /** @type {Promise<any>} */
@@ -62,6 +63,7 @@ export class Server {
 
 		set_private_env(filter_env(env, env_private_prefix, env_public_prefix));
 		set_public_env(filter_env(env, env_public_prefix, env_private_prefix));
+		set_env(env);
 
 		if (read) {
 			// Wrap the read function to handle MaybePromise<ReadableStream>

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

@@ -23,6 +23,7 @@ import {
 } from '../utils.js';
 import { create_remote_key } from '../../shared.js';
 import { get_status } from '../../../utils/error.js';
+import * as env from '__sveltekit/env';
 
 // TODO rename this function/module
 
@@ -404,7 +405,10 @@ export async function render_response({
 		// import the env.js module so that it evaluates before any user code can evaluate.
 		// TODO revert to using top-level await once https://bugs.webkit.org/show_bug.cgi?id=242740 is fixed
 		// https://github.com/sveltejs/kit/pull/11601
-		const load_env_eagerly = client.uses_env_dynamic_public && state.prerendering;
+		const load_env_eagerly =
+			(__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__ ||
+				client.uses_env_dynamic_public) &&
+			state.prerendering;
 
 		const properties = [`base: ${base_expression}`];
 
@@ -412,7 +416,9 @@ export async function render_response({
 			properties.push(`assets: ${s(paths.assets)}`);
 		}
 
-		if (client.uses_env_dynamic_public) {
+		if (__SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__) {
+			properties.push(`env: ${load_env_eagerly ? 'null' : devalue.uneval(env.rendered_env)}`);
+		} else if (client.uses_env_dynamic_public) {
 			properties.push(`env: ${load_env_eagerly ? 'null' : s(public_env)}`);
 		}
 
@@ -677,7 +683,9 @@ export async function render_response({
 		body,
 		assets,
 		nonce: /** @type {string} */ (csp.nonce),
-		env: public_env
+		env: __SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__
+			? env.explicit_public_env
+			: public_env
 	});
 
 	// TODO flush chunks as early as we can

package/src/runtime/server/respond.js

@@ -8,7 +8,7 @@ import { is_endpoint_request, render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
 import { render_response } from './page/render.js';
 import { respond_with_error } from './page/respond_with_error.js';
-import { is_form_content_type } from '../../utils/http.js';
+import { get_set_cookies, is_form_content_type } from '../../utils/http.js';
 import {
 	handle_fatal_error,
 	has_prerendered_path,
@@ -317,7 +317,7 @@ export async function internal_respond(request, options, manifest, state) {
 		return resolve_route(resolved_path, new URL(request.url), manifest);
 	}
 
-	if (resolved_path === `/${app_dir}/env.js`) {
+	if (resolved_path === `/${app_dir}/env.js` || resolved_path === `/${app_dir}/env.script.js`) {
 		return get_public_env(request);
 	}
 
@@ -511,19 +511,16 @@ export async function internal_respond(request, options, manifest, state) {
 			if (if_none_match_value === etag) {
 				const headers = new Headers({ etag });
 
-				// https://datatracker.ietf.org/doc/html/rfc7232#section-4.1 + set-cookie
-				for (const key of [
-					'cache-control',
-					'content-location',
-					'date',
-					'expires',
-					'vary',
-					'set-cookie'
-				]) {
+				// https://datatracker.ietf.org/doc/html/rfc7232#section-4.1
+				for (const key of ['cache-control', 'content-location', 'date', 'expires', 'vary']) {
 					const value = response.headers.get(key);
 					if (value) headers.set(key, value);
 				}
 
+				for (const cookie of get_set_cookies(response.headers)) {
+					headers.append('set-cookie', cookie);
+				}
+
 				return new Response(undefined, {
 					status: 304,
 					headers

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

@@ -1,12 +1,3 @@
-/** Internal version of $app/environment */
-declare module '__sveltekit/environment' {
-	export const building: boolean;
-	export const prerendering: boolean;
-	export const version: string;
-	export function set_building(): void;
-	export function set_prerendering(): void;
-}
-
 /** Internal version of $app/paths */
 declare module '__sveltekit/paths' {
 	export let base: '' | `/${string}`;
@@ -27,3 +18,28 @@ declare module '__sveltekit/server' {
 	export function set_manifest(manifest: SSRManifest): void;
 	export function set_read_implementation(fn: (path: string) => ReadableStream): void;
 }
+
+declare module '__sveltekit/env' {
+	// exported environment variables are defined in env.d.ts
+
+	/** Populate exported environment variables */
+	export function set_env(environment: Record<string, string>): void;
+
+	/** public env vars */
+	export const explicit_public_env: Record<string, any>;
+
+	/** public env vars that should be inlined when a page is rendered */
+	export const rendered_env: Record<string, any>;
+}
+
+declare module '__sveltekit/env/private' {
+	// exported environment variables are defined in env.d.ts
+}
+
+declare module '__sveltekit/env/public/client' {
+	// exported environment variables are defined in env.d.ts
+}
+
+declare module '__sveltekit/env/public/server' {
+	// exported environment variables are defined in env.d.ts
+}

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

@@ -1,6 +1,7 @@
 declare global {
 	const __SVELTEKIT_ADAPTER_NAME__: string;
 	const __SVELTEKIT_APP_DIR__: string;
+	const __SVELTEKIT_APP_VERSION__: string;
 	const __SVELTEKIT_APP_VERSION_FILE__: string;
 	const __SVELTEKIT_APP_VERSION_POLL_INTERVAL__: number;
 	/**
@@ -63,6 +64,7 @@ declare global {
 	 */
 	var __SVELTEKIT_TRACK__: (label: string) => void;
 	var __SVELTEKIT_EXPERIMENTAL_USE_TRANSFORM_ERROR__: boolean;
+	var __SVELTEKIT_EXPERIMENTAL_EXPLICIT_ENVIRONMENT_VARIABLES__: boolean;
 	var Bun: object;
 	var Deno: object;
 }

package/src/types/internal.d.ts

@@ -44,6 +44,7 @@ export interface ServerModule {
 export interface ServerInternalModule {
 	set_assets(path: string): void;
 	set_building(): void;
+	set_env(environment: Record<string, string>): void;
 	set_manifest(manifest: SSRManifest): void;
 	set_prerendering(): void;
 	set_private_env(environment: Record<string, string>): void;

package/src/utils/http.js

@@ -1,3 +1,4 @@
+import * as set_cookie_parser from 'set-cookie-parser';
 import { BINARY_FORM_CONTENT_TYPE } from '../runtime/form-utils.js';
 
 /**
@@ -56,6 +57,26 @@ export function negotiate(accept, types) {
 	return accepted;
 }
 
+/**
+ * Reads all `Set-Cookie` headers as separate values. `Headers.get('set-cookie')`
+ * collapses them into a single comma-joined string that browsers cannot parse, so
+ * we use `Headers.getSetCookie()` where available and fall back to splitting the
+ * joined string otherwise.
+ *
+ * TODO 3.0 `getSetCookie` is available in Node 19.7+; once we drop support for
+ * older versions we can use it directly and remove the `splitCookiesString` fallback
+ * @param {Headers} headers
+ * @returns {string[]}
+ */
+export function get_set_cookies(headers) {
+	if (typeof headers.getSetCookie === 'function') {
+		return headers.getSetCookie();
+	}
+
+	const set_cookie = headers.get('set-cookie');
+	return set_cookie ? set_cookie_parser.splitCookiesString(set_cookie) : [];
+}
+
 /**
  * Returns `true` if the request contains a `content-type` header with the given type
  * @param {Request} request

package/src/utils/import.js

@@ -45,8 +45,8 @@ function resolve_peer(dependency) {
  */
 export async function import_peer(dependency) {
 	try {
-		return await import(resolve_peer(dependency));
+		return await import(/* @vite-ignore */ resolve_peer(dependency));
 	} catch {
-		return await import(dependency);
+		return await import(/* @vite-ignore */ dependency);
 	}
 }

package/src/version.js

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

package/types/index.d.ts

@@ -116,7 +116,7 @@ declare module '@sveltejs/kit' {
 		generateFallback: (dest: string) => Promise<void>;
 
 		/**
-		 * Generate a module exposing build-time environment variables as `$env/dynamic/public`.
+		 * Generate a module exposing build-time environment variables as `$env/dynamic/public` if the app uses it.
 		 */
 		generateEnvModule: () => void;
 
@@ -450,6 +450,13 @@ declare module '@sveltejs/kit' {
 		};
 		/** 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 }
@@ -2287,6 +2294,39 @@ declare module '@sveltejs/kit' {
 	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;
+	}
 	interface AdapterEntry {
 		/**
 		 * A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication.
@@ -2923,7 +2963,7 @@ declare module '@sveltejs/kit' {
 	class Redirect_1 {
 		
 		constructor(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308, location: string);
-		status: 301 | 302 | 303 | 307 | 308 | 300 | 304 | 305 | 306;
+		status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308;
 		location: string;
 	}
 
@@ -2931,7 +2971,12 @@ declare module '@sveltejs/kit' {
 }
 
 declare module '@sveltejs/kit/hooks' {
-	import type { Handle } from '@sveltejs/kit';
+	import type { EnvVarConfig, Handle } from '@sveltejs/kit';
+	/**
+	 * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
+	 * which are made available via `$app/env/public` and `$app/env/private`.
+	 * */
+	export function defineEnvVars<T extends Record<string, EnvVarConfig<any>>>(variables: T): T;
 	/**
 	 * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
 	 * The behavior for the `handle` options is as follows:
@@ -3036,11 +3081,38 @@ declare module '@sveltejs/kit/node/polyfills' {
 }
 
 declare module '@sveltejs/kit/vite' {
+	import type { KitConfig } from '@sveltejs/kit';
+	import type { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
 	import type { Plugin } from 'vite';
 	/**
 	 * Returns the SvelteKit Vite plugins.
+	 * Since version 2.62.0 you can pass [configuration](configuration) directly, in which case `svelte.config.js` is ignored.
 	 * */
-	export function sveltekit(): Promise<Plugin[]>;
+	export function sveltekit(config?: KitConfig & Omit<SvelteConfig, "onwarn">): Promise<Plugin[]>;
+
+	export {};
+}
+
+declare module '$app/env' {
+	/**
+	 * `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;
 
 	export {};
 }