@sveltejs/kit 1.0.0-next.394 → 1.0.0-next.397

package/assets/client/start.js

@@ -4,6 +4,7 @@ import { assets, set_paths } from '../paths.js';
 import Root from '__GENERATED__/root.svelte';
 import { components, dictionary, matchers } from '__GENERATED__/client-manifest.js';
 import { init } from './singletons.js';
+export { set_public_env } from '../env-public.js';
 
 /**
  * @param {unknown} err

package/assets/env/dynamic/private.js

@@ -0,0 +1 @@
+export { env } from '../../env-private.js';

package/assets/env/dynamic/public.js

@@ -0,0 +1 @@
+export { env } from '../../env-public.js';

package/assets/env-private.js

@@ -0,0 +1,9 @@
+/** @type {App.PrivateEnv} */
+let env = {};
+
+/** @type {(environment: Record<string, string>) => void} */
+function set_private_env(environment) {
+	env = environment;
+}
+
+export { env, set_private_env };

package/assets/env-public.js

@@ -0,0 +1,9 @@
+/** @type {App.PublicEnv} */
+let env = {};
+
+/** @type {(environment: Record<string, string>) => void} */
+function set_public_env(environment) {
+	env = environment;
+}
+
+export { env, set_public_env };

package/assets/server/index.js

@@ -1474,7 +1474,10 @@ async function render_response({
 
 	// prettier-ignore
 	const init_app = `
-		import { start } from ${s(options.prefix + entry.file)};
+		import { set_public_env, start } from ${s(options.prefix + entry.file)};
+
+		set_public_env(${s(options.public_env)});
+
 		start({
 			target: document.querySelector('[data-sveltekit-hydrate="${target}"]').parentNode,
 			paths: ${s(options.paths)},

package/dist/chunks/filesystem.js

@@ -58,7 +58,7 @@ function copy(source, target, opts = {}) {
 					to,
 					data.replace(
 						/** @type {RegExp} */ (regex),
-						(match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
+						(_match, key) => /** @type {Record<string, string>} */ (opts.replace)[key]
 					)
 				);
 			} else {

package/dist/chunks/index.js

@@ -232,6 +232,10 @@ const options = object(
 				(keypath) => `${keypath} has been renamed to config.kit.moduleExtensions`
 			),
 
+			env: object({
+				publicPrefix: string('PUBLIC_')
+			}),
+
 			files: object({
 				assets: string('static'),
 				hooks: string(join('src', 'hooks')),

package/dist/chunks/sync.js

@@ -3,7 +3,9 @@ import fs__default from 'fs';
 import { g as get_runtime_directory } from './utils.js';
 import { p as posixify, c as copy, r as rimraf } from './filesystem.js';
 import { fileURLToPath } from 'url';
-import { w as write_if_changed, t as trim, a as write, b as write_tsconfig } from './write_tsconfig.js';
+import { w as write_if_changed, t as trim, a as write, v as valid_identifier, r as reserved, b as write_tsconfig } from './write_tsconfig.js';
+import { $ } from './index.js';
+import { loadEnv, loadConfigFromFile } from 'vite';
 
 /**
  * @param typeMap [Object] Map of MIME type -> Array[extensions]
@@ -910,13 +912,374 @@ function write_types(config, manifest_data) {
 	});
 }
 
-/** @param {import('types').ValidatedConfig} config */
-function init(config) {
+/**
+ * @param {import('vite').ResolvedConfig} config
+ * @param {import('vite').ConfigEnv} config_env
+ * @return {Promise<import('vite').UserConfig>}
+ */
+async function get_vite_config(config, config_env) {
+	const loaded = await loadConfigFromFile(
+		config_env,
+		config.configFile,
+		undefined,
+		config.logLevel
+	);
+
+	if (!loaded) {
+		throw new Error('Could not load Vite config');
+	}
+	return { ...loaded.config, mode: config_env.mode };
+}
+
+/**
+ * @param {...import('vite').UserConfig} configs
+ * @returns {import('vite').UserConfig}
+ */
+function merge_vite_configs(...configs) {
+	return deep_merge(
+		...configs.map((config) => ({
+			...config,
+			resolve: {
+				...config.resolve,
+				alias: normalize_alias(config.resolve?.alias || {})
+			}
+		}))
+	);
+}
+
+/**
+ * Takes zero or more objects and returns a new object that has all the values
+ * deeply merged together. None of the original objects will be mutated at any
+ * level, and the returned object will have no references to the original
+ * objects at any depth. If there's a conflict the last one wins, except for
+ * arrays which will be combined.
+ * @param {...Object} objects
+ * @returns {Record<string, any>} the merged object
+ */
+function deep_merge(...objects) {
+	const result = {};
+	/** @type {string[]} */
+	objects.forEach((o) => merge_into(result, o));
+	return result;
+}
+
+/**
+ * normalize kit.vite.resolve.alias as an array
+ * @param {import('vite').AliasOptions} o
+ * @returns {import('vite').Alias[]}
+ */
+function normalize_alias(o) {
+	if (Array.isArray(o)) return o;
+	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
+}
+
+/**
+ * Merges b into a, recursively, mutating a.
+ * @param {Record<string, any>} a
+ * @param {Record<string, any>} b
+ */
+function merge_into(a, b) {
+	/**
+	 * Checks for "plain old Javascript object", typically made as an object
+	 * literal. Excludes Arrays and built-in types like Buffer.
+	 * @param {any} x
+	 */
+	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
+
+	for (const prop in b) {
+		if (is_plain_object(b[prop])) {
+			if (!is_plain_object(a[prop])) {
+				a[prop] = {};
+			}
+			merge_into(a[prop], b[prop]);
+		} else if (Array.isArray(b[prop])) {
+			if (!Array.isArray(a[prop])) {
+				a[prop] = [];
+			}
+			a[prop].push(...b[prop]);
+		} else {
+			a[prop] = b[prop];
+		}
+	}
+}
+
+/** @param {import('types').ValidatedKitConfig} config */
+function get_aliases(config) {
+	/** @type {Record<string, string>} */
+	const alias = {
+		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
+
+		$app: `${get_runtime_directory(config)}/app`,
+
+		// For now, we handle `$lib` specially here rather than make it a default value for
+		// `config.kit.alias` since it has special meaning for packaging, etc.
+		$lib: config.files.lib
+	};
+
+	alias['$env'] = `${get_runtime_directory(config)}/env`;
+
+	for (const [key, value] of Object.entries(config.alias)) {
+		alias[key] = path__default.resolve(value);
+	}
+
+	return alias;
+}
+
+/**
+ * Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
+ * @param {string} entry
+ * @returns {string|null}
+ */
+function resolve_entry(entry) {
+	if (fs__default.existsSync(entry)) {
+		const stats = fs__default.statSync(entry);
+		if (stats.isDirectory()) {
+			return resolve_entry(path__default.join(entry, 'index'));
+		}
+
+		return entry;
+	} else {
+		const dir = path__default.dirname(entry);
+
+		if (fs__default.existsSync(dir)) {
+			const base = path__default.basename(entry);
+			const files = fs__default.readdirSync(dir);
+
+			const found = files.find((file) => file.replace(/\.[^.]+$/, '') === base);
+
+			if (found) return path__default.join(dir, found);
+		}
+	}
+
+	return null;
+}
+
+/**
+ * @param {string} str
+ * @param {number} times
+ */
+function repeat(str, times) {
+	return new Array(times + 1).join(str);
+}
+
+/**
+ * Create a formatted error for an illegal import.
+ * @param {Array<{name: string, dynamic: boolean}>} stack
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function format_illegal_import_chain(stack, out_dir) {
+	const app = path__default.join(out_dir, 'runtime/env');
+
+	stack = stack.map((file) => {
+		if (file.name.startsWith(app)) return { ...file, name: file.name.replace(app, '$env') };
+		return { ...file, name: path__default.relative(process.cwd(), file.name) };
+	});
+
+	const pyramid = stack
+		.map(
+			(file, i) =>
+				`${repeat(' ', i * 2)}- ${file.name} ${
+					file.dynamic ? '(imported by parent dynamically)' : ''
+				}`
+		)
+		.join('\n');
+
+	return `Cannot import ${stack.at(-1)?.name} into client-side code:\n${pyramid}`;
+}
+
+/**
+ * Load environment variables from process.env and .env files
+ * @param {string} mode
+ * @param {string} prefix
+ */
+function get_env(mode, prefix) {
+	const entries = Object.entries(loadEnv(mode, process.cwd(), ''));
+
+	return {
+		public: Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))),
+		private: Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix)))
+	};
+}
+
+/**
+ * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
+ * @param {import('rollup').ModuleInfo} node
+ * @param {Set<string>} illegal_imports
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function prevent_illegal_rollup_imports(node_getter, node, illegal_imports, out_dir) {
+	const chain = find_illegal_rollup_imports(node_getter, node, false, illegal_imports);
+	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+}
+
+/**
+ * @param {(id: string) => import('rollup').ModuleInfo | null} node_getter
+ * @param {import('rollup').ModuleInfo} node
+ * @param {boolean} dynamic
+ * @param {Set<string>} illegal_imports
+ * @param {Set<string>} seen
+ * @returns {Array<import('types').ImportNode> | undefined}
+ */
+const find_illegal_rollup_imports = (
+	node_getter,
+	node,
+	dynamic,
+	illegal_imports,
+	seen = new Set()
+) => {
+	if (seen.has(node.id)) return;
+	seen.add(node.id);
+
+	if (illegal_imports.has(node.id)) {
+		return [{ name: node.id, dynamic }];
+	}
+
+	for (const id of node.importedIds) {
+		const child = node_getter(id);
+		const chain =
+			child && find_illegal_rollup_imports(node_getter, child, false, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic }, ...chain];
+	}
+
+	for (const id of node.dynamicallyImportedIds) {
+		const child = node_getter(id);
+		const chain =
+			child && find_illegal_rollup_imports(node_getter, child, true, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic }, ...chain];
+	}
+};
+
+/**
+ * Throw an error if a private module is imported from a client-side node.
+ * @param {import('vite').ModuleNode} node
+ * @param {Set<string>} illegal_imports
+ * @param {string} out_dir The directory specified by config.kit.outDir
+ */
+function prevent_illegal_vite_imports(node, illegal_imports, out_dir) {
+	const chain = find_illegal_vite_imports(node, illegal_imports);
+	if (chain) throw new Error(format_illegal_import_chain(chain, out_dir));
+}
+
+/**
+ * @param {import('vite').ModuleNode} node
+ * @param {Set<string>} illegal_imports
+ * @param {Set<string>} seen
+ * @returns {Array<import('types').ImportNode> | null}
+ */
+function find_illegal_vite_imports(node, illegal_imports, seen = new Set()) {
+	if (!node.id) return null; // TODO when does this happen?
+
+	if (seen.has(node.id)) return null;
+	seen.add(node.id);
+
+	if (node.id && illegal_imports.has(node.id)) {
+		return [{ name: node.id, dynamic: false }];
+	}
+
+	for (const child of node.importedModules) {
+		const chain = child && find_illegal_vite_imports(child, illegal_imports, seen);
+		if (chain) return [{ name: node.id, dynamic: false }, ...chain];
+	}
+
+	return null;
+}
+
+const autogen_comment = '// this file is generated — do not edit it\n';
+
+/**
+ * Writes the existing environment variables in process.env to
+ * $env/static/private and $env/static/public
+ * @param {import('types').ValidatedKitConfig} config
+ * @param {string} mode The Vite mode
+ */
+function write_env(config, mode) {
+	const env = get_env(mode, config.env.publicPrefix);
+
+	// TODO when testing src, `$app` points at `src/runtime/app`... will
+	// probably need to fiddle with aliases
+	write_if_changed(
+		path__default.join(config.outDir, 'runtime/env/static/public.js'),
+		create_module('$env/static/public', env.public)
+	);
+
+	write_if_changed(
+		path__default.join(config.outDir, 'runtime/env/static/private.js'),
+		create_module('$env/static/private', env.private)
+	);
+
+	write_if_changed(
+		path__default.join(config.outDir, 'ambient.d.ts'),
+		autogen_comment +
+			create_types('$env/static/public', env.public) +
+			'\n\n' +
+			create_types('$env/static/private', env.private)
+	);
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+function create_module(id, env) {
+	/** @type {string[]} */
+	const declarations = [];
+
+	for (const key in env) {
+		const warning = !valid_identifier.test(key)
+			? 'not a valid identifier'
+			: reserved.has(key)
+			? 'a reserved word'
+			: null;
+
+		if (warning) {
+			console.error(
+				$
+					.bold()
+					.yellow(`Omitting environment variable "${key}" from ${id} as it is ${warning}`)
+			);
+			continue;
+		}
+
+		const comment = `/** @type {import('${id}').${key}} */`;
+		const declaration = `export const ${key} = ${JSON.stringify(env[key])};`;
+
+		declarations.push(`${comment}\n${declaration}`);
+	}
+
+	return autogen_comment + declarations.join('\n\n');
+}
+
+/**
+ * @param {string} id
+ * @param {Record<string, string>} env
+ * @returns {string}
+ */
+function create_types(id, env) {
+	const declarations = Object.keys(env)
+		.filter((k) => valid_identifier.test(k))
+		.map((k) => `\texport const ${k}: string;`)
+		.join('\n');
+
+	return `declare module '${id}' {\n${declarations}\n}`;
+}
+
+/**
+ * Initialize SvelteKit's generated files.
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} mode
+ */
+function init(config, mode) {
 	copy_assets(path__default.join(config.kit.outDir, 'runtime'));
+
 	write_tsconfig(config.kit);
+	write_env(config.kit, mode);
 }
 
-/** @param {import('types').ValidatedConfig} config */
+/**
+ * Update SvelteKit's generated files.
+ * @param {import('types').ValidatedConfig} config
+ */
 function update(config) {
 	const manifest_data = create_manifest_data({ config });
 
@@ -931,9 +1294,13 @@ function update(config) {
 	return { manifest_data };
 }
 
-/** @param {import('types').ValidatedConfig} config */
-function all(config) {
-	init(config);
+/**
+ * Run sync.init and sync.update in series, returning the result from sync.update.
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} mode The Vite mode
+ */
+function all(config, mode) {
+	init(config, mode);
 	return update(config);
 }
 
@@ -944,4 +1311,4 @@ var sync = /*#__PURE__*/Object.freeze({
   all: all
 });
 
-export { all as a, sync as b, init as i, parse_route_id as p, s, update as u };
+export { get_vite_config as a, get_env as b, parse_route_id as c, all as d, prevent_illegal_rollup_imports as e, sync as f, get_aliases as g, init as i, merge_vite_configs as m, prevent_illegal_vite_imports as p, resolve_entry as r, s, update as u };

package/dist/chunks/write_tsconfig.js

@@ -33,6 +33,59 @@ function trim(str) {
 	return str.replace(pattern, '').trim();
 }
 
+const reserved = new Set([
+	'do',
+	'if',
+	'in',
+	'for',
+	'let',
+	'new',
+	'try',
+	'var',
+	'case',
+	'else',
+	'enum',
+	'eval',
+	'null',
+	'this',
+	'true',
+	'void',
+	'with',
+	'await',
+	'break',
+	'catch',
+	'class',
+	'const',
+	'false',
+	'super',
+	'throw',
+	'while',
+	'yield',
+	'delete',
+	'export',
+	'import',
+	'public',
+	'return',
+	'static',
+	'switch',
+	'typeof',
+	'default',
+	'extends',
+	'finally',
+	'package',
+	'private',
+	'continue',
+	'debugger',
+	'function',
+	'arguments',
+	'interface',
+	'protected',
+	'implements',
+	'instanceof'
+]);
+
+const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
 /** @param {string} file */
 const exists = (file) => fs__default.existsSync(file) && file;
 
@@ -53,18 +106,13 @@ function write_tsconfig(config, cwd = process.cwd()) {
 	/** @param {string} file */
 	const config_relative = (file) => posixify(path__default.relative(config.outDir, file));
 
-	const dirs = new Set([
-		project_relative(path__default.dirname(config.files.routes)),
-		project_relative(path__default.dirname(config.files.lib))
-	]);
-
-	/** @type {string[]} */
-	const include = [];
-	dirs.forEach((dir) => {
-		include.push(config_relative(`${dir}/**/*.js`));
-		include.push(config_relative(`${dir}/**/*.ts`));
-		include.push(config_relative(`${dir}/**/*.svelte`));
-	});
+	const include = ['ambient.d.ts'];
+	for (const dir of [config.files.routes, config.files.lib]) {
+		const relative = project_relative(path__default.dirname(dir));
+		include.push(config_relative(`${relative}/**/*.js`));
+		include.push(config_relative(`${relative}/**/*.ts`));
+		include.push(config_relative(`${relative}/**/*.svelte`));
+	}
 
 	/** @type {Record<string, string[]>} */
 	const paths = {};
@@ -101,13 +149,13 @@ function write_tsconfig(config, cwd = process.cwd()) {
 
 					// This is required for svelte-kit package to work as expected
 					// Can be overwritten
-					lib: ['esnext', 'DOM'],
+					lib: ['esnext', 'DOM', 'DOM.Iterable'],
 					moduleResolution: 'node',
 					module: 'esnext',
 					target: 'esnext'
 				},
 				include,
-				exclude: [config_relative('node_modules/**'), './**']
+				exclude: [config_relative('node_modules/**'), './[!ambient.d.ts]**']
 			},
 			null,
 			'\t'
@@ -166,4 +214,4 @@ function validate(config, cwd, out, user_file) {
 	}
 }
 
-export { write as a, write_tsconfig as b, trim as t, write_if_changed as w };
+export { write as a, write_tsconfig as b, reserved as r, trim as t, valid_identifier as v, write_if_changed as w };

package/dist/cli.js

@@ -19,7 +19,7 @@ function handle_error(e) {
 	process.exit(1);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.394');
+const prog = sade('svelte-kit').version('1.0.0-next.397');
 
 prog
 	.command('package')
@@ -39,7 +39,8 @@ prog
 prog
 	.command('sync')
 	.describe('Synchronise generated files')
-	.action(async () => {
+	.option('--mode', 'Specify a mode for loading environment variables', 'development')
+	.action(async ({ mode }) => {
 		if (!fs__default.existsSync('svelte.config.js')) {
 			console.warn('Missing svelte.config.js — skipping');
 			return;
@@ -47,8 +48,8 @@ prog
 
 		try {
 			const config = await load_config();
-			const sync = await import('./chunks/sync.js').then(function (n) { return n.b; });
-			sync.all(config);
+			const sync = await import('./chunks/sync.js').then(function (n) { return n.f; });
+			sync.all(config, mode);
 		} catch (error) {
 			handle_error(error);
 		}

package/dist/vite.js

@@ -4,9 +4,9 @@ import path from 'node:path';
 import { a as load_template, $, l as load_config } from './chunks/index.js';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import * as vite from 'vite';
-import { loadConfigFromFile } from 'vite';
+import { loadEnv } from 'vite';
 import { p as posixify, m as mkdirp, r as rimraf } from './chunks/filesystem.js';
-import { s, i as init, u as update, p as parse_route_id, a as all } from './chunks/sync.js';
+import { g as get_aliases, r as resolve_entry, s, m as merge_vite_configs, a as get_vite_config, i as init, b as get_env, u as update, p as prevent_illegal_vite_imports, c as parse_route_id, d as all, e as prevent_illegal_rollup_imports } from './chunks/sync.js';
 import * as fs from 'fs';
 import fs__default, { readdirSync, statSync } from 'fs';
 import path__default, { resolve, join, normalize } from 'path';
@@ -41,145 +41,6 @@ import 'node:util';
 import 'node:net';
 import 'crypto';
 
-/**
- * @param {import('vite').ResolvedConfig} config
- * @param {import('vite').ConfigEnv} config_env
- * @return {Promise<import('vite').UserConfig>}
- */
-async function get_vite_config(config, config_env) {
-	const loaded = await loadConfigFromFile(
-		config_env,
-		config.configFile,
-		undefined,
-		config.logLevel
-	);
-
-	if (!loaded) {
-		throw new Error('Could not load Vite config');
-	}
-	return { ...loaded.config, mode: config_env.mode };
-}
-
-/**
- * @param {...import('vite').UserConfig} configs
- * @returns {import('vite').UserConfig}
- */
-function merge_vite_configs(...configs) {
-	return deep_merge(
-		...configs.map((config) => ({
-			...config,
-			resolve: {
-				...config.resolve,
-				alias: normalize_alias(config.resolve?.alias || {})
-			}
-		}))
-	);
-}
-
-/**
- * Takes zero or more objects and returns a new object that has all the values
- * deeply merged together. None of the original objects will be mutated at any
- * level, and the returned object will have no references to the original
- * objects at any depth. If there's a conflict the last one wins, except for
- * arrays which will be combined.
- * @param {...Object} objects
- * @returns {Record<string, any>} the merged object
- */
-function deep_merge(...objects) {
-	const result = {};
-	/** @type {string[]} */
-	objects.forEach((o) => merge_into(result, o));
-	return result;
-}
-
-/**
- * normalize kit.vite.resolve.alias as an array
- * @param {import('vite').AliasOptions} o
- * @returns {import('vite').Alias[]}
- */
-function normalize_alias(o) {
-	if (Array.isArray(o)) return o;
-	return Object.entries(o).map(([find, replacement]) => ({ find, replacement }));
-}
-
-/**
- * Merges b into a, recursively, mutating a.
- * @param {Record<string, any>} a
- * @param {Record<string, any>} b
- */
-function merge_into(a, b) {
-	/**
-	 * Checks for "plain old Javascript object", typically made as an object
-	 * literal. Excludes Arrays and built-in types like Buffer.
-	 * @param {any} x
-	 */
-	const is_plain_object = (x) => typeof x === 'object' && x.constructor === Object;
-
-	for (const prop in b) {
-		if (is_plain_object(b[prop])) {
-			if (!is_plain_object(a[prop])) {
-				a[prop] = {};
-			}
-			merge_into(a[prop], b[prop]);
-		} else if (Array.isArray(b[prop])) {
-			if (!Array.isArray(a[prop])) {
-				a[prop] = [];
-			}
-			a[prop].push(...b[prop]);
-		} else {
-			a[prop] = b[prop];
-		}
-	}
-}
-
-/** @param {import('types').ValidatedKitConfig} config */
-function get_aliases(config) {
-	/** @type {Record<string, string>} */
-	const alias = {
-		__GENERATED__: path__default.posix.join(config.outDir, 'generated'),
-		$app: `${get_runtime_directory(config)}/app`,
-
-		// For now, we handle `$lib` specially here rather than make it a default value for
-		// `config.kit.alias` since it has special meaning for packaging, etc.
-		$lib: config.files.lib
-	};
-
-	for (const [key, value] of Object.entries(config.alias)) {
-		alias[key] = path__default.resolve(value);
-	}
-
-	return alias;
-}
-
-/**
- * Given an entry point like [cwd]/src/hooks, returns a filename like [cwd]/src/hooks.js or [cwd]/src/hooks/index.js
- * @param {string} entry
- * @returns {string|null}
- */
-function resolve_entry(entry) {
-	if (fs__default.existsSync(entry)) {
-		const stats = fs__default.statSync(entry);
-		if (stats.isDirectory()) {
-			return resolve_entry(path__default.join(entry, 'index'));
-		}
-
-		return entry;
-	} else {
-		const dir = path__default.dirname(entry);
-
-		if (fs__default.existsSync(dir)) {
-			const base = path__default.basename(entry);
-			const files = fs__default.readdirSync(dir);
-
-			const found = files.find((file) => file.replace(/\.[^.]+$/, '') === base);
-
-			if (found) return path__default.join(dir, found);
-		}
-	}
-
-	return null;
-}
-
 /**
  * @typedef {import('rollup').RollupOutput} RollupOutput
  * @typedef {import('rollup').OutputChunk} OutputChunk
@@ -360,6 +221,8 @@ import root from '__GENERATED__/root.svelte';
 import { respond } from '${runtime}/server/index.js';
 import { set_paths, assets, base } from '${runtime}/paths.js';
 import { set_prerendering } from '${runtime}/env.js';
+import { set_private_env } from '${runtime}/env-private.js';
+import { set_public_env } from '${runtime}/env-public.js';
 
 const template = ({ head, body, assets, nonce }) => ${s(template)
 	.replace('%sveltekit.head%', '" + head + "')
@@ -411,6 +274,7 @@ export class Server {
 				default: ${config.kit.prerender.default},
 				enabled: ${config.kit.prerender.enabled}
 			},
+			public_env: {},
 			read,
 			root,
 			service_worker: ${has_service_worker ? "base + '/service-worker.js'" : 'null'},
@@ -421,6 +285,23 @@ export class Server {
 		};
 	}
 
+	init({ env }) {
+		const entries = Object.entries(env);
+
+		const prv = Object.fromEntries(Object.entries(env).filter(([k]) => !k.startsWith('${
+			config.kit.env.publicPrefix
+		}')));
+
+		const pub = Object.fromEntries(Object.entries(env).filter(([k]) => k.startsWith('${
+			config.kit.env.publicPrefix
+		}')));
+
+		set_private_env(prv);
+		set_public_env(pub);
+
+		this.options.public_env = pub;
+	}
+
 	async respond(request, options = {}) {
 		if (!(request instanceof Request)) {
 			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
@@ -1376,12 +1257,13 @@ const cwd$1 = process.cwd();
  * @param {import('vite').ViteDevServer} vite
  * @param {import('vite').ResolvedConfig} vite_config
  * @param {import('types').ValidatedConfig} svelte_config
+ * @param {Set<string>} illegal_imports
  * @return {Promise<Promise<() => void>>}
  */
-async function dev(vite, vite_config, svelte_config) {
+async function dev(vite, vite_config, svelte_config, illegal_imports) {
 	installPolyfills();
 
-	init(svelte_config);
+	init(svelte_config, vite_config.mode);
 
 	const runtime = get_runtime_prefix(svelte_config.kit);
 
@@ -1412,6 +1294,11 @@ async function dev(vite, vite_config, svelte_config) {
 							await vite.ssrLoadModule(url)
 						);
 
+						const node = await vite.moduleGraph.getModuleByUrl(url);
+						if (!node) throw new Error(`Could not find node for ${url}`);
+
+						prevent_illegal_vite_imports(node, illegal_imports, svelte_config.kit.outDir);
+
 						return {
 							module,
 							index,
@@ -1420,10 +1307,6 @@ async function dev(vite, vite_config, svelte_config) {
 							stylesheets: [],
 							// in dev we inline all styles to avoid FOUC
 							inline_styles: async () => {
-								const node = await vite.moduleGraph.getModuleByUrl(url);
-
-								if (!node) throw new Error(`Could not find node for ${url}`);
-
 								const deps = new Set();
 								await find_deps(vite, node, deps);
 
@@ -1595,6 +1478,17 @@ async function dev(vite, vite_config, svelte_config) {
 					);
 				}
 
+				const runtime_base = true
+					? `/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/runtime`))}`
+					: `/@fs${runtime}`;
+
+				const { set_private_env } = await vite.ssrLoadModule(`${runtime_base}/env-private.js`);
+				const { set_public_env } = await vite.ssrLoadModule(`${runtime_base}/env-public.js`);
+
+				const env = get_env(vite_config.mode, svelte_config.kit.env.publicPrefix);
+				set_private_env(env.private);
+				set_public_env(env.public);
+
 				/** @type {Partial<import('types').Hooks>} */
 				const user_hooks = resolve_entry(svelte_config.kit.files.hooks)
 					? await vite.ssrLoadModule(`/${svelte_config.kit.files.hooks}`)
@@ -1640,11 +1534,7 @@ async function dev(vite, vite_config, svelte_config) {
 					`/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/generated/root.svelte`))}`
 				);
 
-				const paths = await vite.ssrLoadModule(
-					true
-						? `/${posixify(path__default.relative(cwd$1, `${svelte_config.kit.outDir}/runtime/paths.js`))}`
-						: `/@fs${runtime}/paths.js`
-				);
+				const paths = await vite.ssrLoadModule(`${runtime_base}/paths.js`);
 
 				paths.set_paths({
 					base: svelte_config.kit.paths.base,
@@ -1703,6 +1593,7 @@ async function dev(vite, vite_config, svelte_config) {
 							default: svelte_config.kit.prerender.default,
 							enabled: svelte_config.kit.prerender.enabled
 						},
+						public_env: env.public,
 						read: (file) => fs__default.readFileSync(path__default.join(svelte_config.kit.files.assets, file)),
 						root,
 						router: svelte_config.kit.browser.router,
@@ -1957,20 +1848,22 @@ function generate_manifest({ build_data, relative_path, routes, format = 'esm' }
  *   middlewares: import('connect').Server;
  *   httpServer: import('http').Server;
  * }} vite
- * @param {import('types').ValidatedConfig} config
- * @param {'http' | 'https'} protocol
+ * @param {import('vite').ResolvedConfig} vite_config
+ * @param {import('types').ValidatedConfig} svelte_config
  */
-async function preview(vite, config, protocol) {
+async function preview(vite, vite_config, svelte_config) {
 	installPolyfills();
 
-	const { paths } = config.kit;
+	const { paths } = svelte_config.kit;
 	const base = paths.base;
 	const assets = paths.assets ? SVELTE_KIT_ASSETS : paths.base;
 
+	const protocol = vite_config.preview.https ? 'https' : 'http';
+
 	const etag = `"${Date.now()}"`;
 
-	const index_file = join(config.kit.outDir, 'output/server/index.js');
-	const manifest_file = join(config.kit.outDir, 'output/server/manifest.js');
+	const index_file = join(svelte_config.kit.outDir, 'output/server/index.js');
+	const manifest_file = join(svelte_config.kit.outDir, 'output/server/manifest.js');
 
 	/** @type {import('types').ServerModule} */
 	const { Server, override } = await import(pathToFileURL(index_file).href);
@@ -1980,20 +1873,23 @@ async function preview(vite, config, protocol) {
 		paths: { base, assets },
 		prerendering: false,
 		protocol,
-		read: (file) => fs__default.readFileSync(join(config.kit.files.assets, file))
+		read: (file) => fs__default.readFileSync(join(svelte_config.kit.files.assets, file))
 	});
 
 	const server = new Server(manifest);
+	server.init({
+		env: loadEnv(vite_config.mode, process.cwd(), '')
+	});
 
 	return () => {
 		// generated client assets and the contents of `static`
 		vite.middlewares.use(
 			scoped(
 				assets,
-				sirv(join(config.kit.outDir, 'output/client'), {
+				sirv(join(svelte_config.kit.outDir, 'output/client'), {
 					setHeaders: (res, pathname) => {
 						// only apply to immutable directory, not e.g. version.json
-						if (pathname.startsWith(`/${config.kit.appDir}/immutable`)) {
+						if (pathname.startsWith(`/${svelte_config.kit.appDir}/immutable`)) {
 							res.setHeader('cache-control', 'public,max-age=31536000,immutable');
 						}
 					}
@@ -2015,7 +1911,7 @@ async function preview(vite, config, protocol) {
 
 		// prerendered dependencies
 		vite.middlewares.use(
-			scoped(base, mutable(join(config.kit.outDir, 'output/prerendered/dependencies')))
+			scoped(base, mutable(join(svelte_config.kit.outDir, 'output/prerendered/dependencies')))
 		);
 
 		// prerendered pages (we can't just use sirv because we need to
@@ -2039,7 +1935,7 @@ async function preview(vite, config, protocol) {
 				// only treat this as a page if it doesn't include an extension
 				if (pathname === '/' || /\/[^./]+\/?$/.test(pathname)) {
 					const file = join(
-						config.kit.outDir,
+						svelte_config.kit.outDir,
 						'output/prerendered/pages' +
 							pathname +
 							(pathname.endsWith('/') ? 'index.html' : '.html')
@@ -2097,7 +1993,7 @@ const mutable = (dir) =>
 				etag: true,
 				maxAge: 0
 		  })
-		: (req, res, next) => next();
+		: (_req, _res, next) => next();
 
 /**
  * @param {string} scope
@@ -2205,6 +2101,9 @@ function kit() {
 	/** @type {import('types').BuildData} */
 	let build_data;
 
+	/** @type {Set<string>} */
+	let illegal_imports;
+
 	/** @type {string | undefined} */
 	let deferred_warning;
 
@@ -2291,8 +2190,13 @@ function kit() {
 				client_out_dir: `${svelte_config.kit.outDir}/output/client/`
 			};
 
+			illegal_imports = new Set([
+				`${svelte_config.kit.outDir}/runtime/env/dynamic/private.js`,
+				`${svelte_config.kit.outDir}/runtime/env/static/private.js`
+			]);
+
 			if (is_build) {
-				manifest_data = all(svelte_config).manifest_data;
+				manifest_data = all(svelte_config, config_env.mode).manifest_data;
 
 				const new_config = vite_client_build_config();
 
@@ -2378,8 +2282,24 @@ function kit() {
 		 * then use this hook to kick off builds for the server and service worker.
 		 */
 		async writeBundle(_options, bundle) {
+			for (const file of manifest_data.components) {
+				const id = path.resolve(file);
+				const node = this.getModuleInfo(id);
+
+				if (node) {
+					prevent_illegal_rollup_imports(
+						this.getModuleInfo.bind(this),
+						node,
+						illegal_imports,
+						svelte_config.kit.outDir
+					);
+				}
+			}
+
 			const verbose = vite_config.logLevel === 'info';
-			log = logger({ verbose });
+			log = logger({
+				verbose
+			});
 
 			fs$1.writeFileSync(
 				`${paths.client_out_dir}/${svelte_config.kit.appDir}/version.json`,
@@ -2509,7 +2429,7 @@ function kit() {
 				if (deferred_warning) console.error('\n' + deferred_warning);
 			};
 
-			return await dev(vite, vite_config, svelte_config);
+			return await dev(vite, vite_config, svelte_config, illegal_imports);
 		},
 
 		/**
@@ -2517,7 +2437,7 @@ function kit() {
 		 * @see https://vitejs.dev/guide/api-plugin.html#configurepreviewserver
 		 */
 		configurePreviewServer(vite) {
-			return preview(vite, svelte_config, vite_config.preview.https ? 'https' : 'http');
+			return preview(vite, vite_config, svelte_config);
 		}
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.394",
+  "version": "1.0.0-next.397",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/ambient.d.ts

@@ -9,13 +9,17 @@
  *
  * 	interface Platform {}
  *
+ * 	interface PrivateEnv {}
+ *
+ * 	interface PublicEnv {}
+ *
  * 	interface Session {}
  *
  * 	interface Stuff {}
  * }
  * ```
  *
- * By populating these interfaces, you will gain type safety when using `event.locals`, `event.platform`, `session` and `stuff`.
+ * By populating these interfaces, you will gain type safety when using `env`, `event.locals`, `event.platform`, `session` and `stuff`.
  *
  * Note that since it's an ambient declaration file, you have to be careful when using `import` statements. Once you add an `import`
  * at the top level, the declaration file is no longer considered ambient and you lose access to these typings in other files.
@@ -43,22 +47,32 @@
  */
 declare namespace App {
 	/**
-	 * The interface that defines `event.locals`, which can be accessed in [hooks](/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](/docs/routing#endpoints).
+	 * The interface that defines `event.locals`, which can be accessed in [hooks](https://kit.svelte.dev/docs/hooks) (`handle`, `handleError` and `getSession`) and [endpoints](https://kit.svelte.dev/docs/routing#endpoints).
 	 */
 	export interface Locals {}
 
 	/**
-	 * If your adapter provides [platform-specific context](/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
+	 * If your adapter provides [platform-specific context](https://kit.svelte.dev/docs/adapters#supported-environments-platform-specific-context) via `event.platform`, you can specify it here.
 	 */
 	export interface Platform {}
 
 	/**
-	 * The interface that defines `session`, both as an argument to [`load`](/docs/loading) functions and the value of the [session store](/docs/modules#$app-stores).
+	 * The interface that defines the dynamic environment variables exported from '$env/dynamic/private'.
+	 */
+	export interface PrivateEnv extends Record<string, string> {}
+
+	/**
+	 * The interface that defines the dynamic environment variables exported from '$env/dynamic/public'.
+	 */
+	export interface PublicEnv extends Record<string, string> {}
+
+	/**
+	 * The interface that defines `session`, both as an argument to [`load`](https://kit.svelte.dev/docs/loading) functions and the value of the [session store](https://kit.svelte.dev/docs/modules#$app-stores).
 	 */
 	export interface Session {}
 
 	/**
-	 * The interface that defines `stuff`, as input or output to [`load`](/docs/loading) or as the value of the `stuff` property of the [page store](/docs/modules#$app-stores).
+	 * The interface that defines `stuff`, as input or output to [`load`](https://kit.svelte.dev/docs/loading) or as the value of the `stuff` property of the [page store](https://kit.svelte.dev/docs/modules#$app-stores).
 	 */
 	export interface Stuff {}
 }
@@ -85,6 +99,39 @@ declare module '$app/env' {
 	export const prerendering: boolean;
 }
 
+/**
+ * This module provides access to runtime environment variables, as defined by the platform you're running on. For example
+ * if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/master/packages/adapter-node) (or running
+ * [`vite preview`](https://kit.svelte.dev/docs/cli)), this is equivalent to `process.env`. This module only includes
+ * variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#kit-env-publicprefix).
+ *
+ * This module cannot be imported into client-side code.
+ *
+ * ```ts
+ * import { env } from '$env/dynamic/private';
+ * console.log(env.DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ */
+declare module '$env/dynamic/private' {
+	export let env: App.PrivateEnv;
+}
+
+/**
+ * Similar to [`$env/dynamic/private`](https://kit.svelte.dev/docs/modules#$env-dynamic-private), but only includes
+ * variables that begin with [`config.kit.env.publicPrefix`](https://kit.svelte.dev/docs/configuration#kit-env-publicprefix)
+ * (which defaults to `PUBLIC_`), and can therefore safely be exposed to client-side code
+ *
+ * Note that public dynamic environment variables must all be sent from the server to the client, causing larger network requests — when possible, use `$env/static/public` instead.
+ *
+ * ```ts
+ * import { env } from '$env/dynamic/public';
+ * console.log(env.PUBLIC_DEPLOYMENT_SPECIFIC_VARIABLE);
+ * ```
+ */
+declare module '$env/dynamic/public' {
+	export let env: App.PublicEnv;
+}
+
 /**
  * ```ts
  * import {
@@ -167,11 +214,11 @@ declare module '$app/navigation' {
  */
 declare module '$app/paths' {
 	/**
-	 * A string that matches [`config.kit.paths.base`](/docs/configuration#paths). It must start, but not end with `/` (e.g. `/base-path`), unless it is the empty string.
+	 * A string that matches [`config.kit.paths.base`](https://kit.svelte.dev/docs/configuration#paths). It must start, but not end with `/` (e.g. `/base-path`), unless it is the empty string.
 	 */
 	export const base: `/${string}`;
 	/**
-	 * An absolute path that matches [`config.kit.paths.assets`](/docs/configuration#paths).
+	 * An absolute path that matches [`config.kit.paths.assets`](https://kit.svelte.dev/docs/configuration#paths).
 	 *
 	 * > If a value for `config.kit.paths.assets` is specified, it will be replaced with `'/_svelte_kit_assets'` during `vite dev` or `vite preview`, since the assets don't yet live at their eventual URL.
 	 */
@@ -213,12 +260,12 @@ declare module '$app/stores' {
 	 */
 	export const navigating: Readable<Navigation | null>;
 	/**
-	 * A writable store whose initial value is whatever was returned from [`getSession`](/docs/hooks#getsession).
+	 * A writable store whose initial value is whatever was returned from [`getSession`](https://kit.svelte.dev/docs/hooks#getsession).
 	 * It can be written to, but this will not cause changes to persist on the server — this is something you must implement yourself.
 	 */
 	export const session: Writable<App.Session>;
 	/**
-	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
+	 *  A readable store whose initial value is `false`. If [`version.pollInterval`](https://kit.svelte.dev/docs/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
 	 */
 	export const updated: Readable<boolean> & { check: () => boolean };
 }
@@ -228,7 +275,7 @@ declare module '$app/stores' {
  * import { build, files, prerendered, version } from '$service-worker';
  * ```
  *
- * This module is only available to [service workers](/docs/service-workers).
+ * This module is only available to [service workers](https://kit.svelte.dev/docs/service-workers).
  */
 declare module '$service-worker' {
 	/**
@@ -236,7 +283,7 @@ declare module '$service-worker' {
 	 */
 	export const build: string[];
 	/**
-	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.kit.files.assets`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](/docs/configuration)
+	 * An array of URL strings representing the files in your static directory, or whatever directory is specified by `config.kit.files.assets`. You can customize which files are included from `static` directory using [`config.kit.serviceWorker.files`](https://kit.svelte.dev/docs/configuration)
 	 */
 	export const files: string[];
 	/**
@@ -244,7 +291,7 @@ declare module '$service-worker' {
 	 */
 	export const prerendered: string[];
 	/**
-	 * See [`config.kit.version`](/docs/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
+	 * See [`config.kit.version`](https://kit.svelte.dev/docs/configuration#version). It's useful for generating unique cache names inside your service worker, so that a later deployment of your app can invalidate old caches.
 	 */
 	export const version: string;
 }

package/types/index.d.ts

@@ -102,6 +102,9 @@ export interface KitConfig {
 		directives?: CspDirectives;
 		reportOnly?: CspDirectives;
 	};
+	env?: {
+		publicPrefix: string;
+	};
 	moduleExtensions?: string[];
 	files?: {
 		assets?: string;
@@ -268,9 +271,14 @@ export type ResponseBody = JSONValue | Uint8Array | ReadableStream | Error;
 
 export class Server {
 	constructor(manifest: SSRManifest);
+	init(options: ServerInitOptions): void;
 	respond(request: Request, options: RequestOptions): Promise<Response>;
 }
 
+export interface ServerInitOptions {
+	env: Record<string, string>;
+}
+
 export interface SSRManifest {
 	appDir: string;
 	assets: Set<string>;

package/types/internal.d.ts

@@ -11,6 +11,7 @@ import {
 	RequestHandler,
 	ResolveOptions,
 	Server,
+	ServerInitOptions,
 	SSRManifest
 } from './index.js';
 import {
@@ -91,7 +92,13 @@ export interface Hooks {
 	handleError: HandleError;
 }
 
+export interface ImportNode {
+	name: string;
+	dynamic: boolean;
+}
+
 export class InternalServer extends Server {
+	init(options: ServerInitOptions): void;
 	respond(
 		request: Request,
 		options: RequestOptions & {
@@ -249,6 +256,7 @@ export interface SSROptions {
 		default: boolean;
 		enabled: boolean;
 	};
+	public_env: Record<string, string>;
 	read(file: string): Buffer;
 	root: SSRComponent['default'];
 	router: boolean;