@sveltejs/kit 2.50.0 → 2.50.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "2.50.0",
+  "version": "2.50.2",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -29,7 +29,7 @@
     "magic-string": "^0.30.5",
     "mrmime": "^2.0.0",
     "sade": "^1.8.1",
-    "set-cookie-parser": "^2.6.0",
+    "set-cookie-parser": "^3.0.0",
     "sirv": "^3.0.0"
   },
   "devDependencies": {
@@ -41,7 +41,7 @@
     "@types/set-cookie-parser": "^2.4.7",
     "dts-buddy": "^0.6.2",
     "rollup": "^4.14.2",
-    "svelte": "^5.46.4",
+    "svelte": "^5.48.4",
     "svelte-preprocess": "^6.0.0",
     "typescript": "^5.3.3",
     "vite": "^6.3.5",

package/src/core/generate_manifest/find_server_assets.js

@@ -13,7 +13,6 @@ export function find_server_assets(build_data, routes) {
 	 */
 	const used_nodes = new Set([0, 1]);
 
-	// TODO add hooks.server.js asset imports
 	/** @type {Set<string>} */
 	const server_assets = new Set();
 
@@ -49,5 +48,9 @@ export function find_server_assets(build_data, routes) {
 		add_assets(build_data.manifest_data.hooks.server);
 	}
 
+	if (build_data.manifest_data.hooks.universal) {
+		add_assets(build_data.manifest_data.hooks.universal);
+	}
+
 	return Array.from(server_assets);
 }

package/src/core/postbuild/crawl.js

@@ -1,4 +1,4 @@
-import { resolve } from '../../utils/url.js';
+import { resolve, decode_uri } from '../../utils/url.js';
 import { decode } from './entities.js';
 
 const DOCTYPE = 'DOCTYPE';
@@ -193,11 +193,11 @@ export function crawl(html, base) {
 				}
 
 				if (id) {
-					ids.push(id);
+					ids.push(decode_uri(id));
 				}
 
 				if (name && tag === 'A') {
-					ids.push(name);
+					ids.push(decode_uri(name));
 				}
 
 				if (src) {

package/src/exports/public.d.ts

@@ -15,7 +15,8 @@ import {
 	PrerenderUnseenRoutesHandlerValue,
 	PrerenderOption,
 	RequestOptions,
-	RouteSegment
+	RouteSegment,
+	IsAny
 } from '../types/private.js';
 import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
 import { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
@@ -1953,6 +1954,18 @@ type UnknownField<Value> = RemoteFormFieldMethods<Value> & {
 	[key: string | number]: UnknownField<any>;
 };
 
+type RemoteFormFieldsRoot<Input extends RemoteFormInput | void> =
+	IsAny<Input> extends true
+		? RecursiveFormFields
+		: Input extends void
+			? {
+					/** Validation issues, if any */
+					issues(): RemoteFormIssue[] | undefined;
+					/** Validation issues belonging to this or any of the fields that belong to it, if any */
+					allIssues(): RemoteFormIssue[] | undefined;
+				}
+			: RemoteFormFields<Input>;
+
 /**
  * Recursive type to build form fields structure with proxy access
  */
@@ -2077,7 +2090,7 @@ export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
 	/** The number of pending submissions */
 	get pending(): number;
 	/** Access form fields using object notation */
-	fields: RemoteFormFields<Input>;
+	fields: RemoteFormFieldsRoot<Input>;
 };
 
 /**

package/src/exports/vite/build/build_server.js

@@ -5,14 +5,43 @@ import { s } from '../../../utils/misc.js';
 import { normalizePath } from 'vite';
 import { basename, join } from 'node:path';
 import { create_node_analyser } from '../static_analysis/index.js';
+import { fix_css_urls } from '../../../utils/css.js';
 
+/**
+ * Regenerate server nodes after acquiring client manifest
+ * @overload
+ * @param {string} out
+ * @param {import('types').ValidatedKitConfig} kit
+ * @param {import('types').ManifestData} manifest_data
+ * @param {import('vite').Manifest} server_manifest
+ * @param {import('vite').Manifest} client_manifest
+ * @param {string} assets_path
+ * @param {import('vite').Rollup.RollupOutput['output']} client_chunks
+ * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
+ * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
+ * @returns {Promise<void>}
+ */
+/**
+ * Build server nodes without client manifest for analysis phase
+ * @overload
+ * @param {string} out
+ * @param {import('types').ValidatedKitConfig} kit
+ * @param {import('types').ManifestData} manifest_data
+ * @param {import('vite').Manifest} server_manifest
+ * @param {null} client_manifest
+ * @param {null} assets_path
+ * @param {null} client_chunks
+ * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
+ * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
+ * @returns {Promise<void>}
+ */
 /**
  * @param {string} out
  * @param {import('types').ValidatedKitConfig} kit
  * @param {import('types').ManifestData} manifest_data
  * @param {import('vite').Manifest} server_manifest
  * @param {import('vite').Manifest | null} client_manifest
- * @param {import('vite').Rollup.OutputBundle | null} server_bundle
+ * @param {string | null} assets_path
  * @param {import('vite').Rollup.RollupOutput['output'] | null} client_chunks
  * @param {import('types').RecursiveRequired<import('types').ValidatedConfig['kit']['output']>} output_config
  * @param {Map<string, { page_options: Record<string, any> | null, children: string[] }>} static_exports
@@ -23,7 +52,7 @@ export async function build_server_nodes(
 	manifest_data,
 	server_manifest,
 	client_manifest,
-	server_bundle,
+	assets_path,
 	client_chunks,
 	output_config,
 	static_exports
@@ -31,38 +60,59 @@ export async function build_server_nodes(
 	mkdirp(`${out}/server/nodes`);
 	mkdirp(`${out}/server/stylesheets`);
 
-	/** @type {Map<string, string>} */
+	/**
+	 * Stylesheet names and their contents which are below the inline threshold
+	 * @type {Map<string, string>}
+	 */
 	const stylesheets_to_inline = new Map();
 
-	if (server_bundle && client_chunks && kit.inlineStyleThreshold > 0) {
-		const client = get_stylesheets(client_chunks);
-		const server = get_stylesheets(Object.values(server_bundle));
+	/**
+	 * For CSS inlining, we either store a string or a function that returns the
+	 * styles with the correct relative URLs
+	 * @type {(css: string, eager_assets: Set<string>) => string}
+	 */
+	let prepare_css_for_inlining = (css) => s(css);
 
-		// map server stylesheet name to the client stylesheet name
-		for (const [id, client_stylesheet] of client.stylesheets_used) {
-			const server_stylesheet = server.stylesheets_used.get(id);
-			if (!server_stylesheet) {
+	if (client_chunks && kit.inlineStyleThreshold > 0 && output_config.bundleStrategy === 'split') {
+		for (const chunk of client_chunks) {
+			if (chunk.type !== 'asset' || !chunk.fileName.endsWith('.css')) {
 				continue;
 			}
-			client_stylesheet.forEach((file, i) => {
-				stylesheets_to_inline.set(file, server_stylesheet[i]);
-			});
-		}
 
-		// filter out stylesheets that should not be inlined
-		for (const [fileName, content] of client.stylesheet_content) {
-			if (content.length >= kit.inlineStyleThreshold) {
-				stylesheets_to_inline.delete(fileName);
+			const source = chunk.source.toString();
+			if (source.length < kit.inlineStyleThreshold) {
+				stylesheets_to_inline.set(chunk.fileName, source);
 			}
 		}
 
-		// map server stylesheet source to the client stylesheet name
-		for (const [client_file, server_file] of stylesheets_to_inline) {
-			const source = server.stylesheet_content.get(server_file);
-			if (!source) {
-				throw new Error(`Server stylesheet source not found for client stylesheet ${client_file}`);
-			}
-			stylesheets_to_inline.set(client_file, source);
+		// If the client CSS has URL references to assets, we need to adjust the
+		// relative path so that they are correct when inlined into the document.
+		// Although `paths.assets` is static, we need to pass in a fake path
+		// `/_svelte_kit_assets` at runtime when running `vite preview`
+		if (kit.paths.assets || kit.paths.relative) {
+			const static_assets = new Set(
+				manifest_data.assets.map((asset) => decodeURIComponent(asset.file))
+			);
+
+			const segments = /** @type {string} */ (assets_path).split('/');
+			const static_asset_prefix = segments.map(() => '..').join('/') + '/';
+
+			prepare_css_for_inlining = (css, eager_assets) => {
+				const transformed_css = fix_css_urls({
+					css,
+					vite_assets: eager_assets,
+					static_assets,
+					paths_assets: '${assets}',
+					base: '${base}',
+					static_asset_prefix
+				});
+
+				// only convert to a function if we have adjusted any URLs
+				if (css !== transformed_css) {
+					return `function css(assets, base) { return \`${s(transformed_css).slice(1, -1)}\`; }`;
+				}
+				return s(css);
+			};
 		}
 	}
 
@@ -96,6 +146,9 @@ export async function build_server_nodes(
 		/** @type {string[]} */
 		let fonts = [];
 
+		/** @type {Set<string>} */
+		let eager_assets = new Set();
+
 		if (node.component && client_manifest) {
 			exports.push(
 				'let component_cache;',
@@ -135,7 +188,7 @@ export async function build_server_nodes(
 			const entry_path = `${normalizePath(kit.outDir)}/generated/client-optimized/nodes/${i}.js`;
 			const entry = find_deps(client_manifest, entry_path, true);
 
-			// eagerly load client stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
+			// Eagerly load client stylesheets and fonts imported by the SSR-ed page to avoid FOUC.
 			// However, if it is not used during SSR (not present in the server manifest),
 			// then it can be lazily loaded in the browser.
 
@@ -153,8 +206,6 @@ export async function build_server_nodes(
 
 			/** @type {Set<string>} */
 			const eager_css = new Set();
-			/** @type {Set<string>} */
-			const eager_assets = new Set();
 
 			entry.stylesheet_map.forEach((value, filepath) => {
 				// pages and layouts are renamed to node indexes when optimised for the client
@@ -180,27 +231,46 @@ export async function build_server_nodes(
 			`export const fonts = ${s(fonts)};`
 		);
 
-		/** @type {string[]} */
-		const inline_styles = [];
-
-		stylesheets.forEach((file, i) => {
-			if (stylesheets_to_inline.has(file)) {
-				const filename = basename(file);
-				const dest = `${out}/server/stylesheets/${filename}.js`;
-				const source = stylesheets_to_inline.get(file);
-				if (!source) {
-					throw new Error(`Server stylesheet source not found for client stylesheet ${file}`);
+		/**
+		 * Assets that have been processed by Vite (decoded and with the asset path stripped)
+		 * @type {Set<string>}
+		 */
+		let vite_assets = new Set();
+
+		// Keep track of Vite asset filenames so that we avoid touching unrelated ones
+		// when adjusting the inlined CSS
+		if (stylesheets_to_inline.size && assets_path && eager_assets.size) {
+			vite_assets = new Set(
+				Array.from(eager_assets).map((asset) => {
+					return decodeURIComponent(asset.replace(`${assets_path}/`, ''));
+				})
+			);
+		}
+
+		if (stylesheets_to_inline.size) {
+			/** @type {string[]} */
+			const inline_styles = [];
+
+			stylesheets.forEach((file, i) => {
+				if (stylesheets_to_inline.has(file)) {
+					const filename = basename(file);
+					const dest = `${out}/server/stylesheets/${filename}.js`;
+
+					let css = /** @type {string} */ (stylesheets_to_inline.get(file));
+
+					fs.writeFileSync(
+						dest,
+						`// ${filename}\nexport default ${prepare_css_for_inlining(css, vite_assets)};`
+					);
+					const name = `stylesheet_${i}`;
+					imports.push(`import ${name} from '../stylesheets/${filename}.js';`);
+					inline_styles.push(`\t${s(file)}: ${name}`);
 				}
-				fs.writeFileSync(dest, `// ${filename}\nexport default ${s(source)};`);
+			});
 
-				const name = `stylesheet_${i}`;
-				imports.push(`import ${name} from '../stylesheets/${filename}.js';`);
-				inline_styles.push(`\t${s(file)}: ${name}`);
+			if (inline_styles.length > 0) {
+				exports.push(`export const inline_styles = () => ({\n${inline_styles.join(',\n')}\n});`);
 			}
-		});
-
-		if (inline_styles.length > 0) {
-			exports.push(`export const inline_styles = () => ({\n${inline_styles.join(',\n')}\n});`);
 		}
 
 		fs.writeFileSync(
@@ -209,37 +279,3 @@ export async function build_server_nodes(
 		);
 	}
 }
-
-/**
- * @param {(import('vite').Rollup.OutputAsset | import('vite').Rollup.OutputChunk)[]} chunks
- */
-function get_stylesheets(chunks) {
-	/**
-	 * A map of module IDs and the stylesheets they use.
-	 * @type {Map<string, string[]>}
-	 */
-	const stylesheets_used = new Map();
-
-	/**
-	 * A map of stylesheet names and their content.
-	 * @type {Map<string, string>}
-	 */
-	const stylesheet_content = new Map();
-
-	for (const chunk of chunks) {
-		if (chunk.type === 'asset') {
-			if (chunk.fileName.endsWith('.css')) {
-				stylesheet_content.set(chunk.fileName, chunk.source.toString());
-			}
-			continue;
-		}
-
-		if (chunk.viteMetadata?.importedCss.size) {
-			const css = Array.from(chunk.viteMetadata.importedCss);
-			for (const id of chunk.moduleIds) {
-				stylesheets_used.set(id, css);
-			}
-		}
-	}
-	return { stylesheets_used, stylesheet_content };
-}

package/src/exports/vite/index.js

@@ -848,6 +848,14 @@ async function kit({ svelte_config }) {
 						input[name] = path.resolve(file);
 					});
 
+					// ...and the hooks files
+					if (manifest_data.hooks.server) {
+						input['entries/hooks.server'] = path.resolve(manifest_data.hooks.server);
+					}
+					if (manifest_data.hooks.universal) {
+						input['entries/hooks.universal'] = path.resolve(manifest_data.hooks.universal);
+					}
+
 					// ...and the server instrumentation file
 					const server_instrumentation = resolve_entry(
 						path.join(kit.files.src, 'instrumentation.server')
@@ -1023,7 +1031,7 @@ async function kit({ svelte_config }) {
 		 */
 		writeBundle: {
 			sequential: true,
-			async handler(_options, bundle) {
+			async handler(_options) {
 				if (secondary_build_started) return; // only run this once
 
 				const verbose = vite_config.logLevel === 'info';
@@ -1263,7 +1271,7 @@ async function kit({ svelte_config }) {
 					manifest_data,
 					server_manifest,
 					client_manifest,
-					bundle,
+					assets_path,
 					client_chunks,
 					svelte_config.kit.output,
 					static_exports

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

@@ -1,6 +1,2 @@
-import { BROWSER, DEV } from 'esm-env';
+export { BROWSER as browser, DEV as dev } from 'esm-env';
 export { building, version } from '__sveltekit/environment';
-
-export const browser = BROWSER;
-
-export const dev = DEV;

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

@@ -78,7 +78,9 @@ export function command(validate_or_fn, maybe_fn) {
 
 		state.refreshes ??= {};
 
-		const promise = Promise.resolve(run_remote_function(event, state, true, arg, validate, fn));
+		const promise = Promise.resolve(
+			run_remote_function(event, state, true, () => validate(arg), fn)
+		);
 
 		// @ts-expect-error
 		promise.updates = () => {

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

@@ -145,8 +145,7 @@ export function form(validate_or_fn, maybe_fn) {
 							event,
 							state,
 							true,
-							data,
-							(d) => d,
+							() => data,
 							(data) => (!maybe_fn ? fn() : fn(data, issue))
 						);
 					} catch (e) {

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

@@ -131,7 +131,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 			}
 
 			const promise = get_response(__, arg, state, () =>
-				run_remote_function(event, state, false, arg, validate, fn)
+				run_remote_function(event, state, false, () => validate(arg), fn)
 			);
 
 			if (state.prerendering) {

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

@@ -5,6 +5,8 @@ import { get_request_store } from '@sveltejs/kit/internal/server';
 import { create_remote_key, stringify_remote_arg } from '../../../shared.js';
 import { prerendering } from '__sveltekit/environment';
 import { create_validator, get_cache, get_response, run_remote_function } from './shared.js';
+import { handle_error_and_jsonify } from '../../../server/utils.js';
+import { HttpError, SvelteKitError } from '@sveltejs/kit/internal';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -73,7 +75,7 @@ export function query(validate_or_fn, maybe_fn) {
 		const { event, state } = get_request_store();
 
 		const get_remote_function_result = () =>
-			run_remote_function(event, state, false, arg, validate, fn);
+			run_remote_function(event, state, false, () => validate(arg), fn);
 
 		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
 		const promise = get_response(__, arg, state, get_remote_function_result);
@@ -137,7 +139,7 @@ export function query(validate_or_fn, maybe_fn) {
  */
 /*@__NO_SIDE_EFFECTS__*/
 function batch(validate_or_fn, maybe_fn) {
-	/** @type {(args?: Input[]) => (arg: Input, idx: number) => Output} */
+	/** @type {(args?: Input[]) => MaybePromise<(arg: Input, idx: number) => Output>} */
 	const fn = maybe_fn ?? validate_or_fn;
 
 	/** @type {(arg?: any) => MaybePromise<Input>} */
@@ -148,16 +150,34 @@ function batch(validate_or_fn, maybe_fn) {
 		type: 'query_batch',
 		id: '',
 		name: '',
-		run: (args) => {
+		run: async (args, options) => {
 			const { event, state } = get_request_store();
 
 			return run_remote_function(
 				event,
 				state,
 				false,
-				args,
-				(array) => Promise.all(array.map(validate)),
-				fn
+				async () => Promise.all(args.map(validate)),
+				async (/** @type {any[]} */ input) => {
+					const get_result = await fn(input);
+
+					return Promise.all(
+						input.map(async (arg, i) => {
+							try {
+								return { type: 'result', data: get_result(arg, i) };
+							} catch (error) {
+								return {
+									type: 'error',
+									error: await handle_error_and_jsonify(event, state, options, error),
+									status:
+										error instanceof HttpError || error instanceof SvelteKitError
+											? error.status
+											: 500
+								};
+							}
+						})
+					);
+				}
 			);
 		}
 	};
@@ -190,22 +210,23 @@ function batch(validate_or_fn, maybe_fn) {
 					batching = { args: [], resolvers: [] };
 
 					try {
-						const get_result = await run_remote_function(
+						return await run_remote_function(
 							event,
 							state,
 							false,
-							batched.args,
-							(array) => Promise.all(array.map(validate)),
-							fn
-						);
-
-						for (let i = 0; i < batched.resolvers.length; i++) {
-							try {
-								batched.resolvers[i].resolve(get_result(batched.args[i], i));
-							} catch (error) {
-								batched.resolvers[i].reject(error);
+							async () => Promise.all(batched.args.map(validate)),
+							async (input) => {
+								const get_result = await fn(input);
+
+								for (let i = 0; i < batched.resolvers.length; i++) {
+									try {
+										batched.resolvers[i].resolve(get_result(input[i], i));
+									} catch (error) {
+										batched.resolvers[i].reject(error);
+									}
+								}
 							}
-						}
+						);
 					} catch (error) {
 						for (const resolver of batched.resolvers) {
 							resolver.reject(error);

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

@@ -97,11 +97,10 @@ export function parse_remote_response(data, transport) {
  * @param {RequestEvent} event
  * @param {RequestState} state
  * @param {boolean} allow_cookies
- * @param {any} arg
- * @param {(arg: any) => any} validate
+ * @param {() => any} get_input
  * @param {(arg?: any) => T} fn
  */
-export async function run_remote_function(event, state, allow_cookies, arg, validate, fn) {
+export async function run_remote_function(event, state, allow_cookies, get_input, fn) {
 	/** @type {RequestStore} */
 	const store = {
 		event: {
@@ -142,8 +141,8 @@ export async function run_remote_function(event, state, allow_cookies, arg, vali
 	};
 
 	// In two parts, each with_event, so that runtimes without async local storage can still get the event at the start of the function
-	const validated = await with_request_store(store, () => validate(arg));
-	return with_request_store(store, () => fn(validated));
+	const input = await with_request_store(store, get_input);
+	return with_request_store(store, () => fn(input));
 }
 
 /**

package/src/runtime/client/client.js

@@ -1860,8 +1860,8 @@ if (import.meta.hot) {
 function setup_preload() {
 	/** @type {NodeJS.Timeout} */
 	let mousemove_timeout;
-	/** @type {Element} */
-	let current_a;
+	/** @type {{ element: Element | SVGAElement | undefined; href: string | SVGAnimatedString | undefined }} */
+	let current_a = { element: undefined, href: undefined };
 	/** @type {PreloadDataPriority} */
 	let current_priority;
 
@@ -1903,7 +1903,8 @@ function setup_preload() {
 		const a = find_anchor(element, container);
 
 		// we don't want to preload data again if the user has already hovered/tapped
-		const interacted = a === current_a && priority >= current_priority;
+		const interacted =
+			a === current_a.element && a?.href === current_a.href && priority >= current_priority;
 		if (!a || interacted) return;
 
 		const { url, external, download } = get_link_info(a, base, app.hash);
@@ -1916,7 +1917,7 @@ function setup_preload() {
 		if (options.reload || same_url) return;
 
 		if (priority <= options.preload_data) {
-			current_a = a;
+			current_a = { element: a, href: a.href };
 			// we don't want to preload data again on tap if we've already preloaded it on hover
 			current_priority = PRELOAD_PRIORITIES.tap;
 
@@ -1938,7 +1939,7 @@ function setup_preload() {
 				void _preload_data(intent);
 			}
 		} else if (priority <= options.preload_code) {
-			current_a = a;
+			current_a = { element: a, href: a.href };
 			current_priority = priority;
 			void _preload_code(/** @type {URL} */ (url));
 		}

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

@@ -138,14 +138,20 @@ class BaseProvider {
 		}
 
 		/** @param {(import('types').Csp.Source | import('types').Csp.ActionSource)[] | undefined} directive */
-		const needs_csp = (directive) =>
+		const style_needs_csp = (directive) =>
 			!!directive && !directive.some((value) => value === 'unsafe-inline');
 
-		this.#script_src_needs_csp = needs_csp(effective_script_src);
-		this.#script_src_elem_needs_csp = needs_csp(script_src_elem);
-		this.#style_src_needs_csp = needs_csp(effective_style_src);
-		this.#style_src_attr_needs_csp = needs_csp(style_src_attr);
-		this.#style_src_elem_needs_csp = needs_csp(style_src_elem);
+		/** @param {(import('types').Csp.Source | import('types').Csp.ActionSource)[] | undefined} directive */
+		const script_needs_csp = (directive) =>
+			!!directive &&
+			(!directive.some((value) => value === 'unsafe-inline') ||
+				directive.some((value) => value === 'strict-dynamic'));
+
+		this.#script_src_needs_csp = script_needs_csp(effective_script_src);
+		this.#script_src_elem_needs_csp = script_needs_csp(script_src_elem);
+		this.#style_src_needs_csp = style_needs_csp(effective_style_src);
+		this.#style_src_attr_needs_csp = style_needs_csp(style_src_attr);
+		this.#style_src_elem_needs_csp = style_needs_csp(style_src_elem);
 
 		this.#script_needs_csp = this.#script_src_needs_csp || this.#script_src_elem_needs_csp;
 		this.#style_needs_csp =

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

@@ -245,7 +245,14 @@ export async function render_response({
 			for (const url of node.fonts) fonts.add(url);
 
 			if (node.inline_styles && !client.inline) {
-				Object.entries(await node.inline_styles()).forEach(([k, v]) => inline_styles.set(k, v));
+				Object.entries(await node.inline_styles()).forEach(([filename, css]) => {
+					if (typeof css === 'string') {
+						inline_styles.set(filename, css);
+						return;
+					}
+
+					inline_styles.set(filename, css(`${assets}/${paths.app_dir}/immutable/assets`, assets));
+				});
 			}
 		}
 	} else {

package/src/runtime/server/remote.js

@@ -73,23 +73,12 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			/** @type {{ payloads: string[] }} */
 			const { payloads } = await event.request.json();
 
-			const args = payloads.map((payload) => parse_remote_arg(payload, transport));
-			const get_result = await with_request_store({ event, state }, () => info.run(args));
-			const results = await Promise.all(
-				args.map(async (arg, i) => {
-					try {
-						return { type: 'result', data: get_result(arg, i) };
-					} catch (error) {
-						return {
-							type: 'error',
-							error: await handle_error_and_jsonify(event, state, options, error),
-							status:
-								error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
-						};
-					}
-				})
+			const args = await Promise.all(
+				payloads.map((payload) => parse_remote_arg(payload, transport))
 			);
 
+			const results = await with_request_store({ event, state }, () => info.run(args, options));
+
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',

package/src/types/internal.d.ts

@@ -431,7 +431,9 @@ export interface SSRNode {
 	server_id?: string;
 
 	/** inlined styles */
-	inline_styles?(): MaybePromise<Record<string, string>>;
+	inline_styles?(): MaybePromise<
+		Record<string, string | ((assets: string, base: string) => string)>
+	>;
 	/** Svelte component */
 	component?: SSRComponentLoader;
 	/** +page.js or +layout.js */
@@ -570,8 +572,8 @@ export type RemoteInfo =
 			type: 'query_batch';
 			id: string;
 			name: string;
-			/** Direct access to the function without batching etc logic, for remote functions called from the client */
-			run: (args: any[]) => Promise<(arg: any, idx: number) => any>;
+			/** Direct access to the function, for remote functions called from the client */
+			run: (args: any[], options: SSROptions) => Promise<any[]>;
 	  }
 	| {
 			type: 'form';

package/src/types/private.d.ts

@@ -241,3 +241,5 @@ export interface RouteSegment {
 }
 
 export type TrailingSlash = 'never' | 'always' | 'ignore';
+
+export type IsAny<T> = 0 extends 1 & T ? true : false;

package/src/utils/css.js

@@ -0,0 +1,210 @@
+import MagicString from 'magic-string';
+import * as svelte from 'svelte/compiler';
+
+/** @typedef {ReturnType<typeof import('svelte/compiler').parseCss>['children']} StyleSheetChildren */
+
+/** @typedef {{ property: string; value: string; start: number; end: number; type: 'Declaration' }} Declaration */
+
+const parse = svelte.parseCss
+	? svelte.parseCss
+	: /** @param {string} css */
+		(css) => {
+			return /** @type {{ css: { children: StyleSheetChildren } }} */ (
+				svelte.parse(`<style>${css}</style>`)
+			).css;
+		};
+
+const SKIP_PARSING_REGEX = /url\(/i;
+
+/** Capture a single url(...) so we can process them one at a time */
+const URL_FUNCTION_REGEX = /url\(\s*.*?\)/gi;
+
+/** Captures the value inside a CSS url(...) */
+const URL_PARAMETER_REGEX = /url\(\s*(['"]?)(.*?)\1\s*\)/i;
+
+/** Splits the URL if there's a query string or hash fragment */
+const HASH_OR_QUERY_REGEX = /[#?]/;
+
+/**
+ * Assets handled by Vite that are referenced in the stylesheet always start
+ * with this prefix because Vite emits them into the same directory as the CSS file
+ */
+const VITE_ASSET_PREFIX = './';
+
+const AST_OFFSET = '<style>'.length;
+
+/**
+ * We need to fix the asset URLs in the CSS before we inline them into a document
+ * because they are now relative to the document instead of the CSS file.
+ * @param {{
+ * 	css: string;
+ * 	vite_assets: Set<string>;
+ * 	static_assets: Set<string>;
+ * 	paths_assets: string;
+ * 	base: string;
+ * 	static_asset_prefix: string;
+ * }} opts
+ * @returns {string}
+ */
+export function fix_css_urls({
+	css,
+	vite_assets,
+	static_assets,
+	paths_assets,
+	base,
+	static_asset_prefix
+}) {
+	// skip parsing if there are no url(...) occurrences
+	if (!SKIP_PARSING_REGEX.test(css)) {
+		return css;
+	}
+
+	// safe guard in case of trailing slashes (but this should never happen)
+	if (paths_assets.endsWith('/')) {
+		paths_assets = paths_assets.slice(0, -1);
+	}
+
+	if (base.endsWith('/')) {
+		base = base.slice(0, -1);
+	}
+
+	const s = new MagicString(css);
+
+	const parsed = parse(css);
+
+	for (const child of parsed.children) {
+		find_declarations(child, (declaration) => {
+			if (!SKIP_PARSING_REGEX.test) return;
+
+			const cleaned = tippex_comments_and_strings(declaration.value);
+
+			/** @type {string} */
+			let new_value = declaration.value;
+
+			/** @type {RegExpExecArray | null} */
+			let url_function_found;
+			URL_FUNCTION_REGEX.lastIndex = 0;
+			while ((url_function_found = URL_FUNCTION_REGEX.exec(cleaned))) {
+				const [url_function] = url_function_found;
+
+				// After finding a legitimate url(...), we want to operate on the original
+				// that may have a string inside it
+				const original_url_function = declaration.value.slice(
+					url_function_found.index,
+					url_function_found.index + url_function.length
+				);
+
+				const url_parameter_found = URL_PARAMETER_REGEX.exec(original_url_function);
+				if (!url_parameter_found) continue;
+
+				const [, , url] = url_parameter_found;
+				const [url_without_hash_or_query] = url.split(HASH_OR_QUERY_REGEX);
+
+				/** @type {string | undefined} */
+				let new_prefix;
+
+				// Check if it's an asset processed by Vite...
+				let current_prefix = url_without_hash_or_query.slice(0, VITE_ASSET_PREFIX.length);
+				let filename = url_without_hash_or_query.slice(VITE_ASSET_PREFIX.length);
+				const decoded = decodeURIComponent(filename);
+
+				if (current_prefix === VITE_ASSET_PREFIX && vite_assets.has(decoded)) {
+					new_prefix = paths_assets;
+				} else {
+					// ...or if it's from the static directory
+					current_prefix = url_without_hash_or_query.slice(0, static_asset_prefix.length);
+					filename = url_without_hash_or_query.slice(static_asset_prefix.length);
+					const decoded = decodeURIComponent(filename);
+
+					if (current_prefix === static_asset_prefix && static_assets.has(decoded)) {
+						new_prefix = base;
+					}
+				}
+
+				if (!new_prefix) continue;
+
+				new_value = new_value.replace(`${current_prefix}${filename}`, `${new_prefix}/${filename}`);
+			}
+
+			if (declaration.value === new_value) return;
+
+			if (!svelte.parseCss) {
+				declaration.start = declaration.start - AST_OFFSET;
+				declaration.end = declaration.end - AST_OFFSET;
+			}
+
+			s.update(declaration.start, declaration.end, `${declaration.property}: ${new_value}`);
+		});
+	}
+
+	return s.toString();
+}
+
+/**
+ * @param {StyleSheetChildren[0]} rule
+ * @param {(declaration: Declaration) => void} callback
+ */
+function find_declarations(rule, callback) {
+	// Vite already inlines relative @import rules, so we don't need to handle them here
+	if (!rule.block) return;
+
+	for (const child of rule.block.children) {
+		if (child.type !== 'Declaration') {
+			find_declarations(child, callback);
+			continue;
+		}
+		callback(child);
+	}
+}
+
+/**
+ * Replaces comment and string contents with whitespace.
+ * @param {string} value
+ * @returns {string}
+ */
+export function tippex_comments_and_strings(value) {
+	let new_value = '';
+	let escaped = false;
+	let in_comment = false;
+
+	/** @type {null | '"' | "'"} */
+	let quote_mark = null;
+
+	let i = 0;
+	while (i < value.length) {
+		const char = value[i];
+
+		if (in_comment) {
+			if (char === '*' && value[i + 1] === '/') {
+				in_comment = false;
+				new_value += char;
+			} else {
+				new_value += ' ';
+			}
+		} else if (!quote_mark && char === '/' && value[i + 1] === '*') {
+			in_comment = true;
+			new_value += '/*';
+			i++; // skip the '*' since we already added it
+		} else if (escaped) {
+			new_value += ' ';
+			escaped = false;
+		} else if (quote_mark && char === '\\') {
+			escaped = true;
+			new_value += ' ';
+		} else if (char === quote_mark) {
+			quote_mark = null;
+			new_value += char;
+		} else if (quote_mark) {
+			new_value += ' ';
+		} else if (quote_mark === null && (char === '"' || char === "'")) {
+			quote_mark = char;
+			new_value += char;
+		} else {
+			new_value += char;
+		}
+
+		i++;
+	}
+
+	return new_value;
+}

package/src/utils/routing.js

@@ -162,8 +162,12 @@ export function exec(match, params, matchers) {
 
 		// if `value` is undefined, it means this is an optional or rest parameter
 		if (value === undefined) {
-			if (param.rest) result[param.name] = '';
-			continue;
+			if (param.rest) {
+				// We need to allow the matcher to run so that it can decide if this optional rest param should be allowed to match
+				value = '';
+			} else {
+				continue;
+			}
 		}
 
 		if (!param.matcher || matchers[param.matcher](value)) {

package/src/version.js

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

package/types/index.d.ts

@@ -1929,6 +1929,18 @@ declare module '@sveltejs/kit' {
 		[key: string | number]: UnknownField<any>;
 	};
 
+	type RemoteFormFieldsRoot<Input extends RemoteFormInput | void> =
+		IsAny<Input> extends true
+			? RecursiveFormFields
+			: Input extends void
+				? {
+						/** Validation issues, if any */
+						issues(): RemoteFormIssue[] | undefined;
+						/** Validation issues belonging to this or any of the fields that belong to it, if any */
+						allIssues(): RemoteFormIssue[] | undefined;
+					}
+				: RemoteFormFields<Input>;
+
 	/**
 	 * Recursive type to build form fields structure with proxy access
 	 */
@@ -2053,7 +2065,7 @@ declare module '@sveltejs/kit' {
 		/** The number of pending submissions */
 		get pending(): number;
 		/** Access form fields using object notation */
-		fields: RemoteFormFields<Input>;
+		fields: RemoteFormFieldsRoot<Input>;
 	};
 
 	/**
@@ -2371,6 +2383,8 @@ declare module '@sveltejs/kit' {
 	}
 
 	type TrailingSlash = 'never' | 'always' | 'ignore';
+
+	type IsAny<T> = 0 extends 1 & T ? true : false;
 	interface Asset {
 		file: string;
 		size: number;
@@ -2546,7 +2560,9 @@ declare module '@sveltejs/kit' {
 		server_id?: string;
 
 		/** inlined styles */
-		inline_styles?(): MaybePromise<Record<string, string>>;
+		inline_styles?(): MaybePromise<
+			Record<string, string | ((assets: string, base: string) => string)>
+		>;
 		/** Svelte component */
 		component?: SSRComponentLoader;
 		/** +page.js or +layout.js */

package/types/index.d.ts.map

@@ -68,6 +68,7 @@
 		"RemoteFormField",
 		"RemoteFormFieldContainer",
 		"UnknownField",
+		"RemoteFormFieldsRoot",
 		"RemoteFormFields",
 		"RecursiveFormFields",
 		"MaybeArray",
@@ -102,6 +103,7 @@
 		"RequestOptions",
 		"RouteSegment",
 		"TrailingSlash",
+		"IsAny",
 		"Asset",
 		"BuildData",
 		"ManifestData",
@@ -215,6 +217,6 @@
 		null,
 		null
 	],
-	"mappings": "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",
+	"mappings": "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",
 	"ignoreList": []
 }