@sveltejs/kit 3.0.0-next.8 → 3.0.0-next.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.8",
+  "version": "3.0.0-next.9",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -34,7 +34,7 @@
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "@types/connect": "^3.4.38",
     "@types/node": "^22.19.19",
-    "dts-buddy": "^0.8.1",
+    "dts-buddy": "^0.8.2",
     "jsdom": "^29.1.1",
     "rolldown": "^1.1.2",
     "svelte": "^5.56.3",
@@ -72,14 +72,17 @@
   ],
   "imports": {
     "#app/paths": {
+      "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"
     },
     "#internal": {
+      "workerd": "./src/exports/internal/server/index.js",
       "browser": "./src/exports/internal/client.js",
       "default": "./src/exports/internal/server/index.js"
     }

package/src/core/config/index.js

@@ -161,7 +161,7 @@ export function process_config(config, cwd) {
 			config.kit.files.hooks.client = path.resolve(cwd, config.kit.files.hooks.client);
 			config.kit.files.hooks.server = path.resolve(cwd, config.kit.files.hooks.server);
 			config.kit.files.hooks.universal = path.resolve(cwd, config.kit.files.hooks.universal);
-		} else {
+		} else if (key !== 'lib' /* TODO remove when we remove the `lib` option altogether */) {
 			// @ts-expect-error
 			config.kit.files[key] = path.resolve(cwd, config.kit.files[key]);
 		}
@@ -191,7 +191,6 @@ export function validate_config(config) {
 		files.hooks.client ??= path.join(files.src, 'hooks.client');
 		files.hooks.server ??= path.join(files.src, 'hooks.server');
 		files.hooks.universal ??= path.join(files.src, 'hooks');
-		files.lib ??= path.join(files.src, 'lib');
 		files.params ??= path.join(files.src, 'params');
 		files.routes ??= path.join(files.src, 'routes');
 		files.serviceWorker ??= path.join(files.src, 'service-worker');

package/src/core/config/options.js

@@ -140,7 +140,10 @@ export const validate_kit_options = object({
 			server: string(null),
 			universal: string(null)
 		}),
-		lib: string(null),
+		lib: removed(
+			(keypath) =>
+				`\`${keypath}\` has been removed. Use #lib instead of $lib: https://svelte.dev/docs/kit/$lib`
+		),
 		params: string(null),
 		routes: string(null),
 		serviceWorker: string(null),

package/src/core/sync/write_tsconfig.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
 import { posixify } from '../../utils/os.js';
+import { read_package_imports, normalize_import_value } from '../../utils/imports.js';
 import { write_if_changed } from './utils.js';
 
 /**
@@ -65,7 +66,7 @@ export function get_tsconfig(kit, cwd) {
 		config_relative('vite.config.js'),
 		config_relative('vite.config.ts')
 	]);
-	const src_includes = [kit.files.routes, kit.files.lib, kit.files.src].filter((dir) => {
+	const src_includes = [kit.files.routes, kit.files.src].filter((dir) => {
 		const relative = path.relative(kit.files.src, dir);
 		return !relative || relative.startsWith('..');
 	});
@@ -198,7 +199,7 @@ const alias_regex = /^(.+?)(\/\*)?$/;
 const value_regex = /^(.*?)((\/\*)|(\.\w+))?$/;
 
 /**
- * Generates tsconfig path aliases from kit's aliases.
+ * Generates tsconfig path aliases from kit's aliases and the package.json `imports` field.
  * Related to vite alias creation.
  *
  * @param {import('types').ValidatedKitConfig} config
@@ -215,8 +216,17 @@ function get_tsconfig_paths(config, cwd) {
 	};
 
 	const alias = { ...config.alias };
-	if (fs.existsSync(project_relative(cwd, config.files.lib))) {
-		alias['$lib'] = project_relative(cwd, config.files.lib);
+
+	// Add all `#`-prefixed imports from package.json as path aliases
+	const imports = read_package_imports(cwd);
+	if (imports) {
+		for (const [key, raw_value] of Object.entries(imports)) {
+			if (!key.startsWith('#')) continue;
+			const value = normalize_import_value(raw_value);
+			if (value) {
+				alias[key] = value;
+			}
+		}
 	}
 
 	/** @type {Record<string, string[]>} */

package/src/core/sync/write_tsconfig_test/package.json

@@ -0,0 +1,7 @@
+{
+	"private": true,
+	"imports": {
+		"#lib": "./src/lib",
+		"#lib/*": "./src/lib/*"
+	}
+}

package/src/exports/hooks/sequence.js

@@ -1,5 +1,4 @@
 /** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
-/** @import { MaybePromise } from 'types' */
 import {
 	merge_tracing,
 	get_request_store,
@@ -74,6 +73,8 @@ import {
  * first post-processing
  * ```
  *
+ * Calling `resolve` invokes the next handler in the sequence (or SvelteKit itself, if it is the last one). To pass data between handlers, use `event.locals`.
+ *
  * @param {...Handle} handlers The chain of `handle` functions
  * @returns {Handle}
  */
@@ -89,7 +90,7 @@ export function sequence(...handlers) {
 		 * @param {number} i
 		 * @param {RequestEvent} event
 		 * @param {ResolveOptions | undefined} parent_options
-		 * @returns {MaybePromise<Response>}
+		 * @returns {Promise<Response>}
 		 */
 		function apply_handle(i, event, parent_options) {
 			const handle = handlers[i];

package/src/exports/index.js

@@ -234,7 +234,7 @@ export function isActionFailure(e) {
  * ```ts
  * import { invalid } from '@sveltejs/kit';
  * import { form } from '$app/server';
- * import { tryLogin } from '$lib/server/auth';
+ * import { tryLogin } from '#lib/server/auth';
  * import * as v from 'valibot';
  *
  * export const login = form(

package/src/exports/public.d.ts

@@ -435,8 +435,6 @@ export interface KitConfig {
 	 *
 	 * > [!NOTE] When `mode` is `'auto'`, SvelteKit will use nonces for dynamically rendered pages and hashes for prerendered pages. Using nonces with prerendered pages is insecure and therefore forbidden.
 	 *
-	 * > [!NOTE] Note that most [Svelte transitions](https://svelte.dev/tutorial/svelte/transition) work by creating an inline `<style>` element. If you use these in your app, you must either leave the `style-src` directive unspecified or add `unsafe-inline`.
-	 *
 	 * If this level of configuration is insufficient and you have more dynamic requirements, you can use the [`handle` hook](https://svelte.dev/docs/kit/hooks#Server-hooks-handle) to roll your own CSP.
 	 */
 	csp?: {
@@ -550,12 +548,6 @@ export interface KitConfig {
 			 */
 			universal?: string;
 		};
-		/**
-		 * Your app's internal library, accessible throughout the codebase as `$lib`.
-		 * @deprecated this feature is still supported, but it's generally recommended to use [monorepos](https://levelup.video/tutorials/monorepos-with-pnpm) instead
-		 * @default "src/lib"
-		 */
-		lib?: string;
 		/**
 		 * A directory containing [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching).
 		 * @deprecated this feature is still supported, but it's generally recommended to use [monorepos](https://levelup.video/tutorials/monorepos-with-pnpm) instead
@@ -962,7 +954,7 @@ export interface KitConfig {
  */
 export type Handle = (input: {
 	event: RequestEvent;
-	resolve: (event: RequestEvent, opts?: ResolveOptions) => MaybePromise<Response>;
+	resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
 }) => MaybePromise<Response>;
 
 /**

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

@@ -407,10 +407,7 @@ export async function dev(vite, vite_config, svelte_config, get_remotes, root) {
 		dev: true,
 		etag: true,
 		maxAge: 0,
-		extensions: [],
-		setHeaders: (res) => {
-			res.setHeader('access-control-allow-origin', '*');
-		}
+		extensions: []
 	});
 
 	vite.middlewares.use((req, res, next) => {

package/src/exports/vite/index.js

@@ -43,6 +43,7 @@ import analyse from '../../core/postbuild/analyse.js';
 import { s } from '../../utils/misc.js';
 import { hash } from '../../utils/hash.js';
 import { dedent } from '../../core/sync/utils.js';
+import { get_import_aliases, get_hash_import_keys } from '../../utils/imports.js';
 import {
 	app_env_private,
 	app_server,
@@ -97,7 +98,7 @@ const enforced_config = {
 	resolve: {
 		alias: {
 			$app: true,
-			$lib: true,
+			$env: true,
 			'$service-worker': true
 		}
 	}
@@ -303,10 +304,14 @@ function kit({ svelte_config }) {
 
 	/** @type {string} */
 	let normalized_cwd;
-	/** @type {string} */
-	let normalized_lib;
+	/** @type {Array<{ alias: string, path: string }>} */
+	let normalized_aliases;
 	/** @type {string} */
 	let normalized_node_modules;
+	/** @type {string} */
+	let normalized_routes;
+	/** @type {string} */
+	let normalized_assets;
 	/**
 	 * A map showing which features (such as `$app/server:read`) are defined
 	 * in which chunks, so that we can later determine which routes use which features
@@ -352,11 +357,21 @@ function kit({ svelte_config }) {
 				vite = await import_peer('vite', root);
 
 				normalized_cwd = vite.normalizePath(root);
-				normalized_lib = vite.normalizePath(kit.files.lib);
+				normalized_aliases = get_import_aliases(root, vite.normalizePath.bind(vite));
 				normalized_node_modules = vite.normalizePath(path.resolve(root, 'node_modules'));
+				normalized_routes = vite.normalizePath(path.resolve(root, kit.files.routes));
+				normalized_assets = vite.normalizePath(path.resolve(root, kit.files.assets));
+
+				// Add `#`-prefixed import keys to the enforced config so users are warned
+				// if they try to set them in their Vite config's resolve.alias
+				const enforced_alias = /** @type {Record<string, true>} */ (
+					/** @type {any} */ (enforced_config.resolve).alias
+				);
+				for (const key of get_hash_import_keys(root)) {
+					enforced_alias[key] = true;
+				}
 
 				const allow = new Set([
-					kit.files.lib,
 					kit.files.routes,
 					kit.files.src,
 					kit.outDir,
@@ -372,6 +387,11 @@ function kit({ svelte_config }) {
 					path.resolve(vite.searchForWorkspaceRoot(process.cwd()), 'node_modules')
 				]);
 
+				// Add directories from `#`-prefixed package.json imports to the allow list
+				for (const { path: alias_path } of normalized_aliases) {
+					allow.add(alias_path);
+				}
+
 				// We can only add directories to the allow list, so we find out
 				// if there's a client hooks file and pass its directory
 				const client_hooks = resolve_entry(kit.files.hooks.client);
@@ -386,6 +406,7 @@ function kit({ svelte_config }) {
 						alias: [
 							{ find: '__SERVER__', replacement: `${generated}/server` },
 							{ find: '$app', replacement: `${runtime_directory}/app` },
+							{ find: '$env', replacement: `${runtime_directory}/env` },
 							...get_config_aliases(kit, root)
 						]
 					},
@@ -678,7 +699,7 @@ 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 `$app/env/private`
+	 * whether in `*.server.js` files, `$app/server`, any `/server/` directory, or `$app/env/private`
 	 * @type {Plugin}
 	 */
 	const plugin_guard = {
@@ -704,7 +725,7 @@ function kit({ svelte_config }) {
 					const resolved = await this.resolve(id, importer, { ...options, skipSelf: true });
 
 					if (resolved) {
-						const normalized = normalize_id(resolved.id, normalized_lib, normalized_cwd);
+						const normalized = normalize_id(resolved.id, normalized_aliases, normalized_cwd);
 
 						let importers = import_map.get(normalized);
 
@@ -713,7 +734,7 @@ function kit({ svelte_config }) {
 							import_map.set(normalized, importers);
 						}
 
-						importers.add(normalize_id(importer, normalized_lib, normalized_cwd));
+						importers.add(normalize_id(importer, normalized_aliases, normalized_cwd));
 					}
 				}
 			}
@@ -735,12 +756,19 @@ function kit({ svelte_config }) {
 				const is_internal =
 					id.startsWith(normalized_cwd) && !id.startsWith(normalized_node_modules);
 
-				const normalized = normalize_id(id, normalized_lib, normalized_cwd);
+				const normalized = normalize_id(id, normalized_aliases, normalized_cwd);
+
+				// server-only directories: any file in a `/server/` folder inside the cwd,
+				// except those inside the routes or assets directories
+				const is_in_routes = id.startsWith(normalized_routes + '/');
+				const is_in_assets = id.startsWith(normalized_assets + '/');
+				const is_server_only_directory =
+					is_internal && !is_in_routes && !is_in_assets && server_only_directory_pattern.test(id);
 
 				const is_server_only =
 					normalized === '$app/env/private' ||
 					normalized === '$app/server' ||
-					(normalized.startsWith('$lib/') && server_only_directory_pattern.test(id)) ||
+					is_server_only_directory ||
 					(is_internal && server_only_module_pattern.test(id));
 
 				if (!is_server_only) return;
@@ -863,7 +891,7 @@ function kit({ svelte_config }) {
 		},
 
 		async transform(code, id) {
-			const normalized = normalize_id(id, normalized_lib, normalized_cwd);
+			const normalized = normalize_id(id, normalized_aliases, normalized_cwd);
 			if (!svelte_config.kit.moduleExtensions.some((ext) => normalized.endsWith(`.remote${ext}`))) {
 				return;
 			}
@@ -1084,7 +1112,7 @@ function kit({ svelte_config }) {
 					throw new Error(
 						`Cannot import ${normalize_id(
 							id,
-							normalized_lib,
+							normalized_aliases,
 							normalized_cwd
 						)} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`
 					);
@@ -1178,9 +1206,12 @@ function kit({ svelte_config }) {
 					);
 				}
 
-				const normalized_cwd = vite.normalizePath(vite_config.root);
-				const normalized_lib = vite.normalizePath(kit.files.lib);
-				const relative = normalize_id(id, normalized_lib, normalized_cwd);
+				const sw_normalized_cwd = vite.normalizePath(vite_config.root);
+				const sw_normalized_aliases = get_import_aliases(
+					vite_config.root,
+					vite.normalizePath.bind(vite)
+				);
+				const relative = normalize_id(id, sw_normalized_aliases, sw_normalized_cwd);
 				const stripped = strip_virtual_prefix(relative);
 				throw new Error(
 					`Cannot import ${stripped} into service-worker code. Only the modules $service-worker and $app/env/public are available in service workers.`

package/src/exports/vite/utils.js

@@ -21,11 +21,7 @@ import {
  */
 export function get_config_aliases(config, root) {
 	/** @type {import('vite').Alias[]} */
-	const alias = [
-		// For now, we handle `$lib` specially here rather than make it a default value for
-		// `config.alias` since it has special meaning for packaging, etc.
-		{ find: '$lib', replacement: posixify(config.files.lib) }
-	];
+	const alias = [];
 
 	for (let [key, value] of Object.entries(config.alias)) {
 		value = posixify(value);
@@ -118,16 +114,20 @@ export function not_found(req, res, base) {
 const query_pattern = /\?.*$/s;
 
 /**
- * Removes cwd/lib path from the start of the id
+ * Removes cwd path from the start of the id and replaces any `#`-prefixed
+ * import alias target paths with their alias names.
  * @param {string} id
- * @param {string} lib
+ * @param {Array<{ alias: string, path: string }>} aliases — sorted by path length descending
  * @param {string} cwd
  */
-export function normalize_id(id, lib, cwd) {
+export function normalize_id(id, aliases, cwd) {
 	id = id.replace(query_pattern, '');
 
-	if (id.startsWith(lib)) {
-		id = id.replace(lib, '$lib');
+	for (const { alias, path } of aliases) {
+		if (id === path || id.startsWith(path + '/')) {
+			id = id.replace(path, alias);
+			break;
+		}
 	}
 
 	if (id.startsWith(cwd)) {

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

@@ -1,6 +1,6 @@
-import { dev } from '../env/index.js';
+import { DEV } from 'esm-env';
 export * from '../env/index.js';
 
-if (dev) {
-	console.warn('`$app/environment` is now `$app/env`');
+if (DEV) {
+	console.warn('`$app/environment` is deprecated, use `$app/env` instead');
 }

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

@@ -2,7 +2,6 @@
 /** @import { RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { json, error } from '@sveltejs/kit';
-import { DEV } from 'esm-env';
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { stringify, stringify_remote_arg } from '../../../shared.js';
 import { noop } from '../../../../utils/functions.js';
@@ -99,7 +98,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 			const id = __.id;
 			const url = `${base}/${app_dir}/remote/${id}${payload ? `/${payload}` : ''}`;
 
-			if (!state.prerendering && !DEV && !event.isRemoteRequest) {
+			if (!state.prerendering && !__SVELTEKIT_DEV__ && !event.isRemoteRequest) {
 				try {
 					// TODO adapters can provide prerendered data more efficiently than
 					// fetching from the public internet

package/src/runtime/client/client.js

@@ -429,7 +429,7 @@ async function _invalidate(reset_page_state = true) {
 	// is running because subsequent invalidations may make earlier ones outdated,
 	// but batch multiple synchronous invalidations.
 	await (pending_invalidate ||= Promise.resolve());
-	if (!pending_invalidate) return;
+	if (pending_invalidate === null) return;
 	pending_invalidate = null;
 
 	const token = (invalidation_token = {});

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

@@ -11,7 +11,6 @@ export const page = new (class Page {
 	route = $state.raw({ id: null });
 	state = $state.raw({});
 	status = $state.raw(-1);
-	// eslint-disable-next-line svelte/prefer-svelte-reactivity
 	url = $state.raw(new URL('a:'));
 })();
 

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

@@ -0,0 +1,7 @@
+import { DEV } from 'esm-env';
+import * as env from '../../app/env/private.js';
+export { env };
+
+if (DEV) {
+	console.warn('`$env/dynamic/private` is deprecated, use `$app/env/private` instead');
+}

package/src/runtime/env/dynamic/public.js

@@ -0,0 +1,7 @@
+import { DEV } from 'esm-env';
+import * as env from '../../app/env/public/index.js';
+export { env };
+
+if (DEV) {
+	console.warn('`$env/dynamic/public` is deprecated, use `$app/env/public` instead');
+}

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

@@ -0,0 +1,6 @@
+import { DEV } from 'esm-env';
+export * from '../../app/env/private.js';
+
+if (DEV) {
+	console.warn('`$env/static/private` is deprecated, use `$app/env/private` instead');
+}

package/src/runtime/env/static/public.js

@@ -0,0 +1,6 @@
+import { DEV } from 'esm-env';
+export * from '../../app/env/public/index.js';
+
+if (DEV) {
+	console.warn('`$env/static/public` is deprecated, use `$app/env/public` instead');
+}

package/src/runtime/server/cookie.js

@@ -43,6 +43,25 @@ export function get_cookies(request, url) {
 		parseCookie(header, { decode: (value) => value })
 	);
 
+	/** @type {ReturnType<typeof parseCookie> | undefined} */
+	let default_cookies;
+
+	/**
+	 * The header never changes during the request, so the default-decode parse is cached
+	 * @param {import('cookie').ParseOptions} [opts]
+	 */
+	function parse_header(opts) {
+		return opts?.decode ? parseCookie(header, opts) : (default_cookies ??= parseCookie(header));
+	}
+
+	/** @param {import('./page/types.js').Cookie} cookie */
+	function matches_url(cookie) {
+		return (
+			domain_matches(url.hostname, cookie.options.domain) &&
+			path_matches(url.pathname, cookie.options.path)
+		);
+	}
+
 	/** @type {string | undefined} */
 	let normalized_url;
 
@@ -66,22 +85,23 @@ export function get_cookies(request, url) {
 
 		get(name, opts) {
 			// Look for the most specific matching cookie from new_cookies
-			const best_match = Array.from(new_cookies.values())
-				.filter((c) => {
-					return (
-						c.name === name &&
-						domain_matches(url.hostname, c.options.domain) &&
-						path_matches(url.pathname, c.options.path)
-					);
-				})
-				.sort((a, b) => b.options.path.length - a.options.path.length)[0];
+			/** @type {import('./page/types.js').Cookie | undefined} */
+			let best_match;
+			for (const c of new_cookies.values()) {
+				if (
+					c.name === name &&
+					matches_url(c) &&
+					(!best_match || c.options.path.length > best_match.options.path.length)
+				) {
+					best_match = c;
+				}
+			}
 
 			if (best_match) {
 				return best_match.options.maxAge === 0 ? undefined : best_match.value;
 			}
 
-			const req_cookies = parseCookie(header, { decode: opts?.decode });
-			const cookie = req_cookies[name]; // the decoded string or undefined
+			const cookie = parse_header(opts)[name]; // the decoded string or undefined
 
 			// in development, if the cookie was set during this session with `cookies.set`,
 			// but at a different path, warn the user. (ignore cookies from request headers,
@@ -104,16 +124,14 @@ export function get_cookies(request, url) {
 		},
 
 		getAll(opts) {
-			const cookies = parseCookie(header, { decode: opts?.decode });
+			// copy, so the cached parse isn't mutated below
+			const cookies = { ...parse_header(opts) };
 
 			// Group cookies by name and find the most specific one for each name
 			const lookup = new Map();
 
 			for (const c of new_cookies.values()) {
-				if (
-					domain_matches(url.hostname, c.options.domain) &&
-					path_matches(url.pathname, c.options.path)
-				) {
+				if (matches_url(c)) {
 					const existing = lookup.get(c.name);
 
 					// If no existing cookie or this one has a more specific (longer) path, use this one

package/src/runtime/server/csrf.js

@@ -36,7 +36,7 @@ export function get_self_origin(paths_origin, url_origin) {
  */
 export function is_csrf_forbidden({ request, request_origin, self_origin, trusted_origins }) {
 	return (
-		is_form_content_type(request) &&
+		(!request.headers.get('content-type') || is_form_content_type(request)) &&
 		mutating_form_methods.has(request.method) &&
 		request_origin !== self_origin &&
 		(!request_origin || !trusted_origins.includes(request_origin))

package/src/runtime/server/data/index.js

@@ -96,29 +96,25 @@ export async function render_data(
 			return fn();
 		});
 
-		let length = promises.length;
-		const nodes = await Promise.all(
-			promises.map((p, i) =>
-				p.catch(async (error) => {
+		const data_serializer = server_data_serializer_json(event, event_state, options);
+		await Promise.all(
+			promises.map(async (p, i) => {
+				const node = await p.catch(async (error) => {
 					if (error instanceof Redirect) {
 						throw error;
 					}
 
-					// Math.min because array isn't guaranteed to resolve in order
-					length = Math.min(length, i + 1);
-
 					const transformed = await handle_error_and_jsonify(event, event_state, options, error);
 
 					return /** @type {import('types').ServerErrorNode} */ ({
 						type: 'error',
 						error: transformed
 					});
-				})
-			)
-		);
+				});
 
-		const data_serializer = server_data_serializer_json(event, event_state, options);
-		for (let i = 0; i < nodes.length; i++) data_serializer.add_node(i, nodes[i]);
+				data_serializer.add_node(i, node);
+			})
+		);
 		const { data, chunks } = data_serializer.get_data();
 
 		if (!chunks) {

package/src/runtime/server/respond.js

@@ -70,7 +70,7 @@ export async function internal_respond(request, options, manifest, state) {
 	const is_data_request = has_data_suffix(url.pathname);
 	const remote_id = get_remote_id(url);
 
-	if (!DEV) {
+	if (!__SVELTEKIT_DEV__) {
 		const request_origin = request.headers.get('origin');
 		const self_origin = get_self_origin(options.paths_origin, url.origin);
 

package/src/types/internal.d.ts

@@ -456,7 +456,10 @@ export interface SSRNode {
 
 	/**
 	 * During development, all styles are inlined for the page to avoid FOUC.
-	 * But in production, this stores styles that are below the inline threshold
+	 * But in production, this stores styles that are below the inline threshold.
+	 * It returns a Promise during development because Vite needs to load the
+	 * modules on demand. But in production, the contents have been precomputed
+	 * during the build, so it can return synchronously.
 	 */
 	inline_styles?(): MaybePromise<
 		Record<string, string | ((assets: string, base: string) => string)>

package/src/utils/imports.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Reads the `imports` field from the package.json at the given directory.
+ * @param {string} cwd
+ * @returns {Record<string, string | Record<string, string>> | undefined}
+ */
+export function read_package_imports(cwd) {
+	const pkg_path = path.resolve(cwd, 'package.json');
+	if (fs.existsSync(pkg_path)) {
+		try {
+			return JSON.parse(fs.readFileSync(pkg_path, 'utf-8')).imports;
+		} catch {
+			// malformed package.json — ignore, the user will see other errors
+		}
+	}
+}
+
+/**
+ * Normalizes an import value to a string path, handling both string values
+ * and conditional export objects (using the `default` key).
+ * @param {string | Record<string, string>} value
+ * @returns {string | null}
+ */
+export function normalize_import_value(value) {
+	if (typeof value === 'string') {
+		return value.replace(/^\.\//, '');
+	}
+	if (value && typeof value === 'object' && typeof value.default === 'string') {
+		return value.default.replace(/^\.\//, '');
+	}
+	return null;
+}
+
+/**
+ * Returns the `#`-prefixed import keys from the package.json `imports` field.
+ * @param {string} cwd
+ * @returns {string[]}
+ */
+export function get_hash_import_keys(cwd) {
+	const imports = read_package_imports(cwd);
+	if (!imports) return [];
+	return Object.keys(imports).filter((key) => key.startsWith('#'));
+}
+
+/**
+ * Computes alias entries for `normalize_id` from the package.json `imports` field.
+ * Each entry maps a `#xx` alias to its absolute target path. Entries are sorted
+ * by path length descending so that longer/more-specific paths are matched first.
+ *
+ * @param {string} root
+ * @param {(p: string) => string} [normalize] - optional path normalizer (e.g. `vite.normalizePath`)
+ * @returns {Array<{ alias: string, path: string }>}
+ */
+export function get_import_aliases(root, normalize) {
+	const imports = read_package_imports(root);
+	if (!imports) return [];
+
+	/** @type {Array<{ alias: string, path: string }>} */
+	const aliases = [];
+
+	for (const [key, raw_value] of Object.entries(imports)) {
+		if (!key.startsWith('#')) continue;
+
+		const value = normalize_import_value(raw_value);
+		if (!value) continue;
+
+		// For `#xx/*` imports, the target directory is the value without `/*`
+		// For `#xx` imports, the target is the file itself
+		const target = value.endsWith('/*') ? value.slice(0, -2) : value;
+		if (target.includes('*')) continue; // not sure if this is even allowed in Node, anyway it's too niche/complex to support here
+		const abs = path.resolve(root, target);
+		const alias = key.endsWith('/*') ? key.slice(0, -2) : key;
+
+		aliases.push({ alias, path: normalize ? normalize(abs) : abs });
+	}
+
+	// Sort by path length descending so longer/more-specific paths match first
+	aliases.sort((a, b) => b.path.length - a.path.length);
+
+	return aliases;
+}

package/src/version.js

@@ -1,4 +1,4 @@
 // generated during release, do not modify
 
 /** @type {string} */
-export const VERSION = '3.0.0-next.8';
+export const VERSION = '3.0.0-next.9';

package/types/index.d.ts

@@ -6,7 +6,6 @@ declare module '@sveltejs/kit' {
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
 	import type { Plugin } from 'vite';
 	import type { RouteId as AppRouteId, LayoutParams as AppLayoutParams, ResolvedPathname } from '$app/types';
-	import type { Component } from 'svelte';
 	// @ts-ignore this is an optional peer dependency so could be missing. Written like this so dts-buddy preserves the ts-ignore
 	type Span = import('@opentelemetry/api').Span;
 
@@ -408,8 +407,6 @@ declare module '@sveltejs/kit' {
 		 *
 		 * > [!NOTE] When `mode` is `'auto'`, SvelteKit will use nonces for dynamically rendered pages and hashes for prerendered pages. Using nonces with prerendered pages is insecure and therefore forbidden.
 		 *
-		 * > [!NOTE] Note that most [Svelte transitions](https://svelte.dev/tutorial/svelte/transition) work by creating an inline `<style>` element. If you use these in your app, you must either leave the `style-src` directive unspecified or add `unsafe-inline`.
-		 *
 		 * If this level of configuration is insufficient and you have more dynamic requirements, you can use the [`handle` hook](https://svelte.dev/docs/kit/hooks#Server-hooks-handle) to roll your own CSP.
 		 */
 		csp?: {
@@ -523,12 +520,6 @@ declare module '@sveltejs/kit' {
 				 */
 				universal?: string;
 			};
-			/**
-			 * Your app's internal library, accessible throughout the codebase as `$lib`.
-			 * @deprecated this feature is still supported, but it's generally recommended to use [monorepos](https://levelup.video/tutorials/monorepos-with-pnpm) instead
-			 * @default "src/lib"
-			 */
-			lib?: string;
 			/**
 			 * A directory containing [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching).
 			 * @deprecated this feature is still supported, but it's generally recommended to use [monorepos](https://levelup.video/tutorials/monorepos-with-pnpm) instead
@@ -935,7 +926,7 @@ declare module '@sveltejs/kit' {
 	 */
 	export type Handle = (input: {
 		event: RequestEvent;
-		resolve: (event: RequestEvent, opts?: ResolveOptions) => MaybePromise<Response>;
+		resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
 	}) => MaybePromise<Response>;
 
 	/**
@@ -1753,19 +1744,6 @@ declare module '@sveltejs/kit' {
 		/** Static files from `config.files.assets` and the service worker (if any). */
 		assets: Set<string>;
 		mimeTypes: Record<string, string>;
-
-		/** @internal private fields */
-		_: {
-			client: BuildData['client'];
-			nodes: SSRNodeLoader[];
-			/** hashed filename -> import to that file */
-			remotes: Record<string, () => Promise<{ default: Record<string, any> }>>;
-			routes: SSRRoute[];
-			prerendered_routes: Set<string>;
-			matchers: () => Promise<Record<string, ParamMatcher>>;
-			/** A `[file]: size` map of all assets imported by server code. */
-			server_assets: Record<string, number>;
-		};
 	}
 
 	/**
@@ -2699,9 +2677,6 @@ declare module '@sveltejs/kit' {
 		rest: boolean;
 	}
 
-	/** @default 'never' */
-	type TrailingSlash = 'never' | 'always' | 'ignore';
-
 	type DeepPartial<T> = T extends Record<PropertyKey, unknown> | unknown[]
 		? {
 				[K in keyof T]?: T[K] extends Record<PropertyKey, unknown> | unknown[]
@@ -2711,87 +2686,6 @@ declare module '@sveltejs/kit' {
 		: T | undefined;
 
 	type IsAny<T> = 0 extends 1 & T ? true : false;
-	interface Asset {
-		file: string;
-		size: number;
-		type: string | null;
-	}
-
-	interface BuildData {
-		app_dir: string;
-		app_path: string;
-		manifest_data: ManifestData;
-		out_dir: string;
-		service_worker: string | null;
-		client: {
-			/** Path to the client entry point. */
-			start: string;
-			/** Path to the generated `app.js` file that contains the client manifest. Only set in case of `bundleStrategy === 'split'`. */
-			app?: string;
-			/** JS files that the client entry point relies on. */
-			imports: string[];
-			/**
-			 * JS files that represent the entry points of the layouts/pages.
-			 * An entry is undefined if the layout/page has no component or universal file (i.e. only has a `.server.js` file).
-			 * Only set in case of `router.resolution === 'server'`.
-			 */
-			nodes?: Array<string | undefined>;
-			/**
-			 * CSS files referenced in the entry points of the layouts/pages.
-			 * An entry is undefined if the layout/page has no component or universal file (i.e. only has a `.server.js` file) or if has no CSS.
-			 * Only set in case of `router.resolution === 'server'`.
-			 */
-			css?: Array<string[] | undefined>;
-			/**
-			 * Contains the client route manifest in a form suitable for the server which is used for server-side route resolution.
-			 * Notably, it contains all routes, regardless of whether they are prerendered or not (those are missing in the optimized server route manifest).
-			 * Only set in case of `router.resolution === 'server'`.
-			 */
-			routes?: SSRClientRoute[];
-			stylesheets: string[];
-			fonts: string[];
-			/**
-			 * Whether the client uses public dynamic env vars — `$env/dynamic/public` or `$app/env/public`.
-			 */
-			uses_env_dynamic_public: boolean;
-			/** Only set in case of `bundleStrategy === 'inline'`. */
-			inline?: {
-				script: string;
-				style: string | undefined;
-			};
-		} | null;
-		server_manifest: import('vite').Manifest;
-	}
-
-	interface ManifestData {
-		/** Static files from `config.files.assets`. */
-		assets: Asset[];
-		hooks: {
-			client: string | null;
-			server: string | null;
-			universal: string | null;
-		};
-		nodes: PageNode[];
-		routes: RouteData[];
-		params: string | null;
-	}
-
-	interface PageNode {
-		depth: number;
-		/** The `+page/layout.svelte`. */
-		component?: string; // TODO supply default component if it's missing (bit of an edge case)
-		/** The `+page/layout.js/.ts`. */
-		universal?: string;
-		/** The `+page/layout.server.js/ts`. */
-		server?: string;
-		parent_id?: string;
-		parent?: PageNode;
-		/** Filled with the pages that reference this layout (if this is a layout). */
-		child_pages?: PageNode[];
-		/** The final page options for a node if it was statically analysable */
-		page_options?: PageOptions | null;
-	}
-
 	type RecursiveRequired<T> = {
 		// Recursive implementation of TypeScript's Required utility type.
 		// Will recursively continue until it reaches a primitive or Function
@@ -2801,132 +2695,6 @@ declare module '@sveltejs/kit' {
 			: T[K]; // Use the exact type for everything else
 	};
 
-	interface RouteParam {
-		name: string;
-		matcher: string;
-		optional: boolean;
-		rest: boolean;
-		chained: boolean;
-	}
-
-	/**
-	 * Represents a route segment in the app. It can either be an intermediate node
-	 * with only layout/error pages, or a leaf, at which point either `page` and `leaf`
-	 * or `endpoint` is set.
-	 */
-	interface RouteData {
-		id: string;
-		parent: RouteData | null;
-
-		segment: string;
-		pattern: RegExp;
-		params: RouteParam[];
-
-		layout: PageNode | null;
-		error: PageNode | null;
-		leaf: PageNode | null;
-
-		page: {
-			layouts: Array<number | undefined>;
-			errors: Array<number | undefined>;
-			leaf: number;
-		} | null;
-
-		endpoint: {
-			file: string;
-			/** The final page options for the endpoint if it was statically analysable */
-			page_options: PageOptions | null;
-		} | null;
-	}
-
-	type SSRComponentLoader = () => Promise<Component>;
-
-	interface UniversalNode {
-		/** Is `null` in case static analysis succeeds but the node is ssr=false */
-		load?: Load;
-		prerender?: PrerenderOption;
-		ssr?: boolean;
-		csr?: boolean;
-		trailingSlash?: TrailingSlash;
-		config?: any;
-		entries?: PrerenderEntryGenerator;
-	}
-
-	interface ServerNode {
-		load?: ServerLoad;
-		prerender?: PrerenderOption;
-		ssr?: boolean;
-		csr?: boolean;
-		trailingSlash?: TrailingSlash;
-		actions?: Actions;
-		config?: any;
-		entries?: PrerenderEntryGenerator;
-	}
-
-	interface SSRNode {
-		/** index into the `nodes` array in the generated `client/app.js`. */
-		index: number;
-		/** external JS files that are loaded on the client. `imports[0]` is the entry point (e.g. `client/nodes/0.js`) */
-		imports: string[];
-		/** external CSS files that are loaded on the client */
-		stylesheets: string[];
-		/** external font files that are loaded on the client */
-		fonts: string[];
-
-		universal_id?: string;
-		server_id?: string;
-
-		/**
-		 * During development, all styles are inlined for the page to avoid FOUC.
-		 * But in production, this stores styles that are below the inline threshold
-		 */
-		inline_styles?(): MaybePromise<
-			Record<string, string | ((assets: string, base: string) => string)>
-		>;
-		/** Svelte component */
-		component?: SSRComponentLoader;
-		/** +page.js or +layout.js */
-		universal?: UniversalNode;
-		/** +page.server.js, +layout.server.js, or +server.js */
-		server?: ServerNode;
-	}
-
-	type SSRNodeLoader = () => Promise<SSRNode>;
-
-	interface PageNodeIndexes {
-		errors: Array<number | undefined>;
-		layouts: Array<number | undefined>;
-		leaf: number;
-	}
-
-	type PrerenderEntryGenerator = () => MaybePromise<Array<Record<string, string>>>;
-
-	type SSREndpoint = Partial<Record<HttpMethod, RequestHandler>> & {
-		prerender?: PrerenderOption;
-		trailingSlash?: TrailingSlash;
-		config?: any;
-		entries?: PrerenderEntryGenerator;
-		fallback?: RequestHandler;
-	};
-
-	interface SSRRoute {
-		id: string;
-		pattern: RegExp;
-		params: RouteParam[];
-		page: PageNodeIndexes | null;
-		endpoint: (() => Promise<SSREndpoint>) | null;
-		endpoint_id?: string;
-	}
-
-	interface SSRClientRoute {
-		id: string;
-		pattern: RegExp;
-		params: RouteParam[];
-		errors: Array<number | undefined>;
-		layouts: Array<[has_server_load: boolean, node_id: number] | undefined>;
-		leaf: [has_server_load: boolean, node_id: number];
-	}
-
 	type ValidatedConfig = Omit<Config, 'kit'> & {
 		kit: ValidatedKitConfig;
 		extensions: string[];
@@ -3045,7 +2813,7 @@ declare module '@sveltejs/kit' {
 	 * ```ts
 	 * import { invalid } from '@sveltejs/kit';
 	 * import { form } from '$app/server';
-	 * import { tryLogin } from '$lib/server/auth';
+	 * import { tryLogin } from '#lib/server/auth';
 	 * import * as v from 'valibot';
 	 *
 	 * export const login = form(
@@ -3087,19 +2855,7 @@ declare module '@sveltejs/kit' {
 		wasNormalized: boolean;
 		denormalize: (url?: string | URL) => URL;
 	};
-	type ValidPageOption = (typeof valid_page_options_array)[number];
-
-	type PageOptions = Partial<{
-		[K in ValidPageOption]: K extends 'ssr' | 'csr'
-			? boolean
-			: K extends 'prerender'
-				? PrerenderOption
-				: K extends 'trailingSlash'
-					? TrailingSlash
-					: any;
-	}>;
 	export const VERSION: string;
-	const valid_page_options_array: readonly ["ssr", "prerender", "csr", "trailingSlash", "config", "entries", "load"];
 
 	export {};
 }
@@ -3179,6 +2935,8 @@ declare module '@sveltejs/kit/hooks' {
 	 * first post-processing
 	 * ```
 	 *
+	 * Calling `resolve` invokes the next handler in the sequence (or SvelteKit itself, if it is the last one). To pass data between handlers, use `event.locals`.
+	 *
 	 * @param handlers The chain of `handle` functions
 	 * */
 	export function sequence(...handlers: Handle[]): Handle;

package/types/index.d.ts.map

@@ -128,26 +128,9 @@
 		"PrerenderOption",
 		"RequestOptions",
 		"RouteSegment",
-		"TrailingSlash",
 		"DeepPartial",
 		"IsAny",
-		"Asset",
-		"BuildData",
-		"ManifestData",
-		"PageNode",
 		"RecursiveRequired",
-		"RouteParam",
-		"RouteData",
-		"SSRComponentLoader",
-		"UniversalNode",
-		"ServerNode",
-		"SSRNode",
-		"SSRNodeLoader",
-		"PageNodeIndexes",
-		"PrerenderEntryGenerator",
-		"SSREndpoint",
-		"SSRRoute",
-		"SSRClientRoute",
 		"ValidatedConfig",
 		"ValidatedKitConfig",
 		"isHttpError",
@@ -159,10 +142,7 @@
 		"invalid",
 		"isValidationError",
 		"normalizeUrl",
-		"ValidPageOption",
-		"PageOptions",
 		"VERSION",
-		"valid_page_options_array",
 		"defineEnvVars",
 		"sequence",
 		"getRequest",
@@ -207,9 +187,7 @@
 		"../src/types/private.d.ts",
 		"../src/types/internal.d.ts",
 		"../src/exports/index.js",
-		"../src/exports/vite/static_analysis/types.d.ts",
 		"../src/version.js",
-		"../src/exports/vite/static_analysis/index.js",
 		"../src/exports/hooks/index.js",
 		"../src/exports/hooks/sequence.js",
 		"../src/exports/node/index.js",
@@ -240,10 +218,8 @@
 		null,
 		null,
 		null,
-		null,
-		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }

package/src/types/synthetic/$lib.md

@@ -1,5 +0,0 @@
-This is a simple alias to `src/lib`, or whatever directory is specified as [`config.files.lib`](https://svelte.dev/docs/kit/configuration#files). It allows you to access common components and utility modules without `../../../../` nonsense.
-
-### `$lib/server`
-
-A subdirectory of `$lib`. SvelteKit will prevent you from importing any modules in `$lib/server` into client-side code. See [server-only modules](https://svelte.dev/docs/kit/server-only-modules).