@sveltejs/kit 3.0.0-next.22 → 3.0.0-next.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.22",
+  "version": "3.0.0-next.24",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -72,19 +72,54 @@
     "svelte-kit.js"
   ],
   "imports": {
+    "#app/env": {
+      "types": "./src/runtime/app/env/client.js",
+      "workerd": "./src/runtime/app/env/server.js",
+      "browser": "./src/runtime/app/env/client.js",
+      "default": "./src/runtime/app/env/server.js"
+    },
+    "#app/env/public": {
+      "workerd": "./src/runtime/app/env/public/server.js",
+      "browser": "./src/runtime/app/env/public/client.js",
+      "default": "./src/runtime/app/env/public/server.js"
+    },
+    "#app/env/server": {
+      "workerd": "./src/runtime/app/env/server.js",
+      "browser": "./src/runtime/invalid-import.js",
+      "default": "./src/runtime/app/env/server.js"
+    },
+    "#app/forms": {
+      "types": "./src/runtime/app/forms/client.js",
+      "workerd": "./src/runtime/app/forms/server.js",
+      "browser": "./src/runtime/app/forms/client.js",
+      "default": "./src/runtime/app/forms/server.js"
+    },
     "#app/internal/transport": {
       "default": "./src/runtime/app/internal/transport.js"
     },
+    "#app/navigation": {
+      "types": "./src/runtime/app/navigation/client.js",
+      "workerd": "./src/runtime/app/navigation/server.js",
+      "browser": "./src/runtime/app/navigation/client.js",
+      "default": "./src/runtime/app/navigation/server.js"
+    },
     "#app/paths": {
       "types": "./src/runtime/app/paths/internal.d.ts",
       "workerd": "./src/runtime/app/paths/server.js",
       "browser": "./src/runtime/app/paths/client.js",
       "default": "./src/runtime/app/paths/server.js"
     },
-    "#app/env/public": {
-      "workerd": "./src/runtime/app/env/public/server.js",
-      "browser": "./src/runtime/app/env/public/client.js",
-      "default": "./src/runtime/app/env/public/server.js"
+    "#app/state": {
+      "types": "./src/runtime/app/state/client.svelte.js",
+      "workerd": "./src/runtime/app/state/server.js",
+      "browser": "./src/runtime/app/state/client.svelte.js",
+      "default": "./src/runtime/app/state/server.js"
+    },
+    "#app/state/client": {
+      "types": "./src/runtime/app/state/client.svelte.js",
+      "workerd": "./src/runtime/invalid-import.js",
+      "browser": "./src/runtime/app/state/client.svelte.js",
+      "default": "./src/runtime/invalid-import.js"
     },
     "#internal": {
       "workerd": "./src/exports/internal/server/index.js",
@@ -129,10 +164,6 @@
       "types": "./types/index.d.ts",
       "import": "./src/exports/params/index.js"
     },
-    "./remote": {
-      "types": "./types/index.d.ts",
-      "import": "./src/exports/remote/index.js"
-    },
     "./vite": {
       "types": "./types/index.d.ts",
       "import": "./src/exports/vite/index.js"

package/src/cli.js

@@ -2,9 +2,9 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { parseArgs, styleText } from 'node:util';
 import { extract_svelte_config, load_vite_config } from './core/config/index.js';
-import { resolve_explicit_env_entry } from './core/env.js';
 import { coalesce_to_error } from './utils/error.js';
 import { import_peer } from './utils/import.js';
+import { resolve_env_entry } from './core/env.js';
 
 /** @param {unknown} e */
 function handle_error(e) {
@@ -105,8 +105,8 @@ if (command === 'sync') {
 		const sync = await import('./core/sync/sync.js');
 		sync.all_types(sveltekit_config, vite_config.root);
 
-		const explicit_env_entry = resolve_explicit_env_entry(sveltekit_config);
-		await sync.env(vite, sveltekit_config, explicit_env_entry, vite_config.root, values.mode);
+		const entry = resolve_env_entry(sveltekit_config, vite_config.root);
+		await sync.env(sveltekit_config, entry, vite_config.root, values.mode);
 	} catch (error) {
 		handle_error(error);
 	} finally {

package/src/constants.js

@@ -6,10 +6,22 @@ export const SVELTE_KIT_ASSETS = '/_svelte_kit_assets';
 
 export const GENERATED_COMMENT = '// this file is generated — do not edit it';
 
-export const ENDPOINT_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'];
+export const ENDPOINT_METHODS = [
+	'GET',
+	'POST',
+	'PUT',
+	'PATCH',
+	'DELETE',
+	'OPTIONS',
+	'HEAD',
+	'QUERY'
+];
 
 export const MUTATIVE_METHODS = ['POST', 'PUT', 'PATCH', 'DELETE'];
 
+/** methods whose responses depend on the request body, so they can never be prerendered */
+export const BODY_DEPENDENT_METHODS = [...MUTATIVE_METHODS, 'QUERY'];
+
 export const PAGE_METHODS = ['GET', 'POST', 'HEAD'];
 
 export const SRC_ROOT = import.meta.dirname;

package/src/core/adapt/builder.js

@@ -18,13 +18,12 @@ import { extname, resolve, join, dirname, relative } from 'node:path';
 import { pipeline } from 'node:stream';
 import { promisify } from 'node:util';
 import zlib from 'node:zlib';
-import { copy } from '../../utils/filesystem.js';
+import { copy, walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { generate_manifest } from '../generate_manifest/index.js';
 import { get_route_segments } from '../../utils/routing.js';
 import generate_fallback from '../postbuild/fallback.js';
 import { write } from '../sync/utils.js';
-import { list_files } from '../utils.js';
 import { find_server_assets } from '../generate_manifest/find_server_assets.js';
 import { create_exported_declarations } from '../env.js';
 import { handle_issues, validate } from '../../exports/internal/env.js';
@@ -120,7 +119,7 @@ export function create_builder({
 				return [];
 			}
 
-			const files = list_files(directory, (file) => extensions.includes(extname(file)));
+			const files = [...walk(directory)].filter((file) => extensions.includes(extname(file)));
 
 			await Promise.all(
 				files.flatMap((file) => {

package/src/core/env.js

@@ -3,13 +3,15 @@
 /** @import { ValidatedConfig } from 'types' */
 import path from 'node:path';
 import * as devalue from 'devalue';
-import { GENERATED_COMMENT } from '../constants.js';
 import { dedent } from './sync/utils.js';
 import { runtime_directory } from './utils.js';
 import { resolve_entry } from '../utils/filesystem.js';
 import { handle_issues, validate } from '../exports/internal/env.js';
 import { get_config_aliases } from '../exports/vite/utils.js';
 import { get_runner } from '../runner.js';
+import { import_peer } from '../utils/import.js';
+import { hash } from '../utils/hash.js';
+import { posixify } from '../utils/os.js';
 
 /**
  * @typedef {'public' | 'private'} EnvType
@@ -17,37 +19,55 @@ import { get_runner } from '../runner.js';
 
 /**
  * @param {ValidatedConfig} config
+ * @param {string} root
  * @returns {string | null}
  */
-export function resolve_explicit_env_entry(config) {
-	return resolve_entry(path.join(config.files.src, 'env')) ?? null;
+export function resolve_env_entry(config, root) {
+	return resolve_entry(path.resolve(root, config.files.src, 'env'));
 }
 
 /**
- * @param {typeof import('vite')} vite
  * @param {ValidatedConfig} kit
  * @param {string | null} file
  * @param {string} root
  * @param {string} mode
- * @returns {Promise<Record<string, EnvVarConfig<any>> | null>}
+ * @returns {Promise<{ variables: Record<string, EnvVarConfig<any>> | null, deps: Set<string> }>}
  */
-export async function load_explicit_env(vite, kit, file, root, mode) {
-	if (!file) return null;
+export async function load_explicit_env(kit, file, root, mode) {
+	/** @type {Set<string>} */
+	const deps = new Set();
+
+	if (!file) {
+		return { variables: null, deps };
+	}
+
+	/** @type {typeof import('vite')} */
+	const vite = await import_peer('vite', root);
 
 	const server = await vite.createServer({
 		configFile: false,
 		logLevel: 'silent',
 		mode,
 		define: {
-			__SVELTEKIT_PAYLOAD__: 'undefined', // coming in through static import in env/internal.js but will end up unused
-			__SVELTEKIT_APP_VERSION__: JSON.stringify(kit.version.name) // needed by $app/env
+			// these are needed by $app/env
+			__SVELTEKIT_APP_VERSION__: JSON.stringify(kit.version.name),
+			__SVELTEKIT_DEV__: mode === 'development',
+			__SVELTEKIT_PAYLOAD__: 'undefined' // coming in through static import in env/internal.js but will end up unused
 		},
 		resolve: {
 			alias: [
 				{ find: '$app/env', replacement: `${runtime_directory}/app/env` },
 				...get_config_aliases(kit, root)
 			]
-		}
+		},
+		plugins: [
+			{
+				name: 'dependency-scanner',
+				load(id) {
+					deps.add(id);
+				}
+			}
+		]
 	});
 
 	/** @type {Record<string, EnvVarConfig<any>>} */
@@ -55,8 +75,8 @@ export async function load_explicit_env(vite, kit, file, root, mode) {
 
 	const runner = get_runner(vite, server);
 
-	/** @type {typeof import('../runtime/app/env/internal.js')} */ (
-		await runner.import(`${runtime_directory}/app/env/internal.js`)
+	/** @type {typeof import('../runtime/app/env/server.js')} */ (
+		await runner.import(`${runtime_directory}/app/env/server.js`)
 	).set_building();
 
 	try {
@@ -90,44 +110,68 @@ export async function load_explicit_env(vite, kit, file, root, mode) {
 		await server.close();
 	}
 
-	return variables;
+	return { variables, deps };
 }
 
 /**
- * Creates the `__sveltekit/env` module
- * @param {Record<string, EnvVarConfig<any> | undefined> | null} variables
+ * Creates the `<sveltekit:generated>/env/*` modules, keyed by path relative to `dir`. Every module
+ * derives from one pass over `variables`, so an inlined value is validated once per build.
+ * @param {ValidatedConfig} config
+ * @param {Record<string, EnvVarConfig<any>> | null} variables
  * @param {Record<string, string>} env
+ * @param {string} dir
  * @param {string | null} entry
  * @param {boolean} is_dev
+ * @returns {Record<string, string>}
  */
-export function create_sveltekit_env(variables, env, entry, is_dev) {
-	const imports = entry
-		? [
-				`import { variables } from ${JSON.stringify(entry)};`,
-				`import { validate, handle_issues } from '@sveltejs/kit/internal/env';`
-			]
-		: [`const variables = {};`, `const handle_issues = () => {};`];
+export function create_env_modules(config, variables, env, dir, entry, is_dev) {
+	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
+	const issues = {};
+
+	/** @type {Record<string, string>} */
+	const dev_env = {};
 
+	/** @type {string[]} */
 	const declarations = [];
+	/** @type {string[]} */
 	const setters = [];
+	/** @type {string[]} */
+	const public_exports = [];
+	/** @type {string[]} */
+	const private_exports = [];
+	/** @type {string[]} */
+	const sw_properties = [];
 
-	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
-	const issues = {};
+	let sw_dynamic = false;
+
+	for (const [name, { public: is_public, static: is_static }] of Object.entries(variables ?? {})) {
+		if (is_dev && name in env) dev_env[name] = env[name];
+
+		const exports = is_public ? public_exports : private_exports;
+
+		if (is_static) {
+			const value = devalue.uneval(validate(variables ?? {}, env[name], name, issues));
+			exports.push(`export const ${name} = ${value};\n`);
 
-	for (const [name, config] of Object.entries(variables ?? {})) {
-		if (config?.static) {
-			if (config.public) {
-				const value = validate(variables ?? {}, env[name], name, issues);
-				declarations.push(`explicit_public_env.${name} = ${devalue.uneval(value)};`);
+			if (is_public) {
+				declarations.push(`explicit_public_env.${name} = ${value};`);
+				sw_properties.push(`${name}: ${value}`);
 			}
 		} else {
+			exports.push(`export const ${name} = env.${name};\n`);
 			setters.push(
 				`const ${name} = validate(variables, env.${name}, ${JSON.stringify(name)}, issues);`
 			);
 
-			if (config?.public) {
+			if (is_public) {
 				setters.push(`explicit_public_env.${name} = ${name};`);
 				setters.push(`rendered_env.${name} = ${name};`);
+				sw_dynamic = true;
+				// in dev there is no prerendered env module, so the service worker inlines the value
+				if (is_dev) {
+					const value = devalue.uneval(validate(variables ?? {}, env[name], name, issues));
+					sw_properties.push(`${name}: ${value}`);
+				}
 			} else {
 				setters.push(`dynamic_private_env.${name} = ${name};`);
 			}
@@ -136,9 +180,13 @@ export function create_sveltekit_env(variables, env, entry, is_dev) {
 
 	handle_issues(issues);
 
-	const blocks = [
-		GENERATED_COMMENT,
-		imports.join('\n'),
+	const config_blocks = [
+		entry
+			? [
+					`import { variables } from ${JSON.stringify(entry)};`,
+					`import { validate, handle_issues } from '@sveltejs/kit/internal/env';`
+				].join('\n')
+			: [`const variables = {};`, `const handle_issues = () => {};`].join('\n'),
 		`const issues = {};`,
 		'export { variables }',
 		'export const dynamic_private_env = {};',
@@ -154,157 +202,67 @@ export function create_sveltekit_env(variables, env, entry, is_dev) {
 			}`
 	];
 
-	// In dev, initialise the env immediately. Tools like `vite-node` load modules
-	// through the Vite config but don't run the SvelteKit dev server, which is what
-	// normally calls `set_env`. Without this, dynamic env vars imported from
-	// `$app/env/public` and `$app/env/private` would be `undefined` in such contexts.
 	if (is_dev) {
-		/** @type {Record<string, string>} */
-		const dev_env = {};
-		for (const name of Object.keys(variables ?? {})) {
-			if (name in env) dev_env[name] = env[name];
-		}
-		blocks.push(`set_env(${devalue.uneval(dev_env)});`);
-	}
-
-	const module = blocks.join('\n\n');
-
-	return module;
-}
-
-/**
- * Creates the `__sveltekit/env/private` module
- * @param {Record<string, EnvVarConfig<any>> | null} variables
- * @param {Record<string, string>} env
- */
-export function create_sveltekit_env_private(variables, env) {
-	if (!variables) {
-		return '';
+		// In dev, initialise the env immediately. Tools like `vite-node` load modules
+		// through the Vite config but don't run the SvelteKit dev server, which is what
+		// normally calls `set_env`. Without this, dynamic env vars imported from
+		// `$app/env/public` and `$app/env/private` would be `undefined` in such contexts.
+		config_blocks.push(`set_env(${devalue.uneval(dev_env)});`);
 	}
 
-	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
-	const issues = {};
-
-	/** @type {string[]} */
-	const exports = [];
-
-	for (const [name, config] of Object.entries(variables)) {
-		if (config.public) continue;
-
-		const value = config.static
-			? devalue.uneval(validate(variables, env[name], name, issues))
-			: `env.${name}`;
-
-		exports.push(`export const ${name} = ${value};\n`);
-	}
-
-	handle_issues(issues);
-
-	return `import { dynamic_private_env as env } from '__sveltekit/env';\n\n${exports.join('')}`;
-}
-
-/**
- * Creates the `__sveltekit/env/public/*` modules
- * @param {Record<string, EnvVarConfig<any>> | null} variables
- * @param {Record<string, string>} env
- * @param {string} prelude
- */
-export function create_sveltekit_env_public(variables, env, prelude) {
-	if (!variables) {
-		return '';
-	}
-
-	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
-	const issues = {};
-
-	/** @type {string[]} */
-	const exports = [];
-
-	for (const [name, config] of Object.entries(variables)) {
-		if (!config.public) continue;
-
-		const value = config.static
-			? devalue.uneval(validate(variables, env[name], name, issues))
-			: `env.${name}`;
-
-		exports.push(`export const ${name} = ${value};\n`);
-	}
-
-	handle_issues(issues);
-
-	return `${prelude}\n\n${exports.join('')}`;
-}
-
-/**
- * Creates the `__sveltekit/env/service-worker` module used in production. When an app uses
- * dynamic public env vars, they're loaded at runtime via an import of the prerendered
- * `env.js`. If there are none, values are inlined.
- * @param {Record<string, EnvVarConfig<any>> | null} variables
- * @param {Record<string, string>} env
- * @param {string} version
- * @param {string} global
- * @param {string} base
- * @param {string} app_dir
- */
-export function create_sveltekit_env_service_worker(
-	variables,
-	env,
-	version,
-	global,
-	base,
-	app_dir
-) {
-	const has_dynamic_public_env = Object.values(variables ?? {}).some(
-		(config) => config.public && !config.static
-	);
-
-	if (!has_dynamic_public_env) {
-		return create_sveltekit_env_service_worker_dev(variables, env, version, global);
-	}
-
-	return dedent`
-		import { env } from '${base}/${app_dir}/env.js';
-
-		${global} = {
-			base: location.pathname.split('/').slice(0, -1).join('/'),
-			env,
-			version: ${JSON.stringify(version)}
-		};
-	`;
-}
-
-/**
- * Creates the `__sveltekit/env/service-worker` module used in development
- * @param {Record<string, EnvVarConfig<any>> | null} variables
- * @param {Record<string, string>} env
- * @param {string} version
- * @param {string} global
- */
-export function create_sveltekit_env_service_worker_dev(variables, env, version, global) {
-	/** @type {string[]} */
-	const properties = [];
-
-	/** @type {Record<string, StandardSchemaV1.Issue[]>} */
-	const issues = {};
-
-	for (const [name, config] of Object.entries(variables ?? {})) {
-		if (!config.public) continue;
-
-		const value = validate(variables ?? {}, env[name], name, issues);
-		properties.push(`${name}: ${devalue.uneval(value)}`);
-	}
-
-	handle_issues(issues);
-
-	return dedent`
-		${global} = {
-			base: location.pathname.split('/').slice(0, -1).join('/'),
-			env: {
-				${properties.join(',\n\t\t') || '// empty'}
-			},
-			version: ${JSON.stringify(version)}
-		};
-	`;
+	/**
+	 * @param {string} prelude
+	 * @param {string[]} exports
+	 */
+	const module = (prelude, exports) => (variables ? `${prelude}\n\n${exports.join('')}` : '');
+
+	const global = is_dev
+		? 'globalThis.__sveltekit_dev'
+		: `globalThis.__sveltekit_${hash(config.version.name)}`;
+
+	const version = JSON.stringify(config.version.name);
+
+	// a production build with dynamic public env vars loads them at runtime via an import of
+	// the prerendered `env.js`; otherwise the values are inlined
+	const service_worker =
+		!is_dev && sw_dynamic
+			? dedent`
+				import { env } from '${config.paths.base}/${config.appDir}/env.js';
+
+				${global} = {
+					base: location.pathname.split('/').slice(0, -1).join('/'),
+					env,
+					version: ${version}
+				};
+			`
+			: dedent`
+				${global} = {
+					base: location.pathname.split('/').slice(0, -1).join('/'),
+					env: {
+						${sw_properties.join(',\n\t\t') || '// empty'}
+					},
+					version: ${version}
+				};
+			`;
+
+	return {
+		'config.js': config_blocks.join('\n\n'),
+		'public/server.js': module(
+			`import { rendered_env as env } from '../config.js';`,
+			public_exports
+		),
+		'private/server.js': module(
+			`import { dynamic_private_env as env } from '../config.js';`,
+			private_exports
+		),
+		'public/client.js': module(
+			is_dev
+				? `const { env } = globalThis.__sveltekit_dev;`
+				: `import { payload } from ${JSON.stringify(posixify(path.relative(`${dir}/public`, `${runtime_directory}/client/payload.js`)))};\nconst env = payload.env;`,
+			public_exports
+		),
+		'service-worker.js': service_worker
+	};
 }
 
 /** @param {string} description */

package/src/core/postbuild/analyse.js

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { validate_server_exports } from '../../utils/exports.js';
 import { extract_svelte_config, load_vite_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
-import { ENDPOINT_METHODS } from '../../constants.js';
+import { BODY_DEPENDENT_METHODS, ENDPOINT_METHODS } from '../../constants.js';
 import { has_server_load, resolve_route } from '../../utils/routing.js';
 import { check_feature } from '../../utils/features.js';
 import { createReadableStream } from '@sveltejs/kit/node';
@@ -54,7 +54,7 @@ async function analyse({
 
 	// `set_env` lives in a separate module that imports the user's `src/env` config. We import it
 	// *after* `set_building()` so that `building`-dependent expressions resolve correctly
-	/** @type {typeof import('__sveltekit/env')} */
+	/** @type {typeof import('<sveltekit:generated>/env/config.js')} */
 	const { set_env } = await import(pathToFileURL(`${server_root}/server/env.js`).href);
 	set_env(env);
 
@@ -175,9 +175,14 @@ async function analyse({
 function analyse_endpoint(route, mod) {
 	validate_server_exports(mod, route.id);
 
-	if (mod.prerender && (mod.POST || mod.PATCH || mod.PUT || mod.DELETE)) {
+	if (
+		mod.prerender &&
+		/** @type {import('types').HttpMethod[]} */ (BODY_DEPENDENT_METHODS).some(
+			(method) => mod[method]
+		)
+	) {
 		throw new Error(
-			`Cannot prerender a +server file with POST, PATCH, PUT, or DELETE (${route.id})`
+			`Cannot prerender a +server file with ${BODY_DEPENDENT_METHODS.join(', ')} handlers (${route.id})`
 		);
 	}