@sveltejs/kit 3.0.0-next.10 → 3.0.0-next.12

package/src/exports/vite/module_ids.js

@@ -6,10 +6,10 @@ export const sveltekit_env_public_client = '\0virtual:__sveltekit/env/public/cli
 export const sveltekit_env_public_server = '\0virtual:__sveltekit/env/public/server';
 export const sveltekit_env_private = '\0virtual:__sveltekit/env/private';
 export const sveltekit_env_service_worker = '\0virtual:__sveltekit/env/service-worker';
-
+export const sveltekit_server = '\0virtual:__sveltekit/server';
 export const service_worker = '\0virtual:service-worker';
 
-export const sveltekit_server = '\0virtual:__sveltekit/server';
+export const sveltekit_manifest_data = '\0virtual:__sveltekit/manifest-data';
 
 export const app_server = posixify(
 	fileURLToPath(new URL('../../runtime/app/server/index.js', import.meta.url))

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

@@ -10,6 +10,7 @@ import { loadEnv, normalizePath } from 'vite';
 import { createReadableStream, getRequest, setResponse } from '../../../exports/node/index.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { is_chrome_devtools_request, not_found } from '../utils.js';
+import { stackless } from '../../../utils/error.js';
 
 /**
  * @param {PreviewServer} vite
@@ -27,8 +28,8 @@ export async function preview(vite, vite_config, svelte_config) {
 
 	const dir = join(svelte_config.kit.outDir, 'output/server');
 
-	if (!fs.existsSync(dir)) {
-		throw new Error(`Server files not found at ${dir}, did you run \`build\` first?`);
+	if (!fs.existsSync(`${dir}/manifest.js`)) {
+		throw stackless(`Server files not found at ${dir}, did you run \`build\` first?`);
 	}
 
 	const instrumentation = join(dir, 'instrumentation.server.js');

package/src/exports/vite/utils.js

@@ -4,12 +4,8 @@ import { negotiate } from '../../utils/http.js';
 import { escape_html } from '../../utils/escape.js';
 import { stackless } from '../../utils/error.js';
 import { dedent } from '../../core/sync/utils.js';
-import {
-	app_server,
-	app_env_private,
-	service_worker,
-	sveltekit_env_private
-} from './module_ids.js';
+import { app_server, app_env_private, sveltekit_env_private } from './module_ids.js';
+import { styleText } from 'node:util';
 
 /**
  * Transforms alias to a valid vite.resolve.alias array.
@@ -142,13 +138,13 @@ export function normalize_id(id, aliases, cwd) {
 		return '$app/env/private';
 	}
 
-	if (id === service_worker) {
-		return '$service-worker';
-	}
-
 	return posixify(id);
 }
 
+export const remote_module_pattern = /[/.]remote(\.[^/]+)+$/;
+export const server_only_module_pattern = /[/.]server(\.[^/]+)+$/;
+export const server_only_directory_pattern = /\/server\//;
+
 export const strip_virtual_prefix = /** @param {string} id */ (id) => id.replace('\0virtual:', '');
 
 /**
@@ -187,3 +183,18 @@ export function error_for_missing_config(feature_name, path, value) {
 		`
 	);
 }
+
+/**
+ * @param {number} status
+ * @param {Request} request
+ */
+export function log_response(status, request) {
+	const url = new URL(request.url);
+	const log = `[${status}] ${request.method} ${url.href.replace(url.origin, '')}`;
+
+	if (status < 400) {
+		console.log(log);
+	} else {
+		console.error(styleText(['bold', 'red'], log));
+	}
+}

package/src/runner.js

@@ -0,0 +1,13 @@
+/** @import { ViteDevServer } from 'vite' */
+import * as vite from 'vite';
+
+/**
+ * @param {ViteDevServer} server
+ */
+export function get_runner(server) {
+	if (!vite.isRunnableDevEnvironment(server.environments.ssr)) {
+		throw new Error('The configured Vite SSR environment must be a RunnableDevEnvironment');
+	}
+
+	return server.environments.ssr.runner;
+}

package/src/runtime/app/forms.js

@@ -4,6 +4,7 @@ import { noop } from '../../utils/functions.js';
 import { refreshAll } from './navigation.js';
 import { app as client_app, applyAction, handle_error } from '../client/client.js';
 import { app as server_app } from '../server/app.js';
+import { notify_version } from '../client/state.svelte.js';
 
 export { applyAction };
 
@@ -201,6 +202,9 @@ export function enhance(form_element, submit = noop) {
 				signal: controller.signal
 			});
 
+			// detect new deployments from the response header
+			notify_version(response.headers.get('x-sveltekit-version'));
+
 			if (response.status === 204) {
 				result = { type: 'success', status: 204 };
 			} else {

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

@@ -0,0 +1 @@
+export * from '__sveltekit/manifest-data';

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

@@ -1,8 +1,8 @@
-/** @import { Asset, RouteId, RouteIdWithSearchOrHash, Pathname, PathnameWithSearchOrHash, ResolvedPathname, RouteParams } from '$app/types' */
+/** @import { AssetPath, RouteId, RouteIdWithSearchOrHash, Path, PathnameWithSearchOrHash, ResolvedPathname, RouteParams } from '$app/types' */
 /** @import { ResolveArgs } from './types.js' */
-import { base, assets, hash_routing } from './internal/client.js';
+import { base, assets, hash_routing, match_implementation } from './internal/client.js';
 import { resolve_route } from '../../../utils/routing.js';
-import { get_navigation_intent } from '../../client/client.js';
+import { DEV } from 'esm-env';
 
 /**
  * Resolve the URL of an asset in your `static` directory, by prefixing it with [`config.paths.assets`](https://svelte.dev/docs/kit/configuration#paths) if configured, or otherwise by prefixing it with the base path.
@@ -15,15 +15,24 @@ import { get_navigation_intent } from '../../client/client.js';
  * 	import { asset } from '$app/paths';
  * </script>
  *
- * <img alt="a potato" src={asset('/potato.jpg')} />
+ * <img alt="a potato" src={asset('potato.jpg')} />
  * ```
  * @since 2.26
  *
- * @param {Asset} file
+ * @param {AssetPath} file
  * @returns {string}
  */
 export function asset(file) {
-	return (assets || base) + file;
+	// TODO 4.0 remove this
+	if (file[0] === '/') {
+		if (DEV) {
+			console.warn(`\`asset('${file}')\` should now be \`asset('${file.slice(1)}')\``);
+		}
+
+		file = file.slice(1);
+	}
+
+	return (assets || base) + '/' + file;
 }
 
 const pathname_prefix = hash_routing ? '#' : '';
@@ -38,7 +47,7 @@ const pathname_prefix = hash_routing ? '#' : '';
  * import { resolve } from '$app/paths';
  *
  * // using a pathname
- * const resolved = resolve(`/blog/hello-world`);
+ * const resolved = resolve(`blog/hello-world`);
  *
  * // using a route ID plus parameters
  * const resolved = resolve('/blog/[slug]', {
@@ -52,14 +61,18 @@ const pathname_prefix = hash_routing ? '#' : '';
  * @returns {ResolvedPathname}
  */
 export function resolve(...args) {
-	if (!args[0].startsWith('/')) {
-		throw new Error(
-			`Cannot use \`resolve(...)\` with a non-absolute pathname or route ID (got "${args[0]}"). ` +
-				'`resolve` is only for internal pathnames and route IDs; external URLs should be used directly.'
-		);
+	if (args[0][0] === '/') {
+		const [id, params] = args;
+
+		// route ID
+		if (id.includes('[') && !params) {
+			throw new Error(`Missing params for dynamic route ID ${id}`);
+		}
+
+		return base + pathname_prefix + resolve_route(args[0], args[1] ?? {});
 	}
 
-	return base + pathname_prefix + resolve_route(args[0], args[1] ?? {});
+	return base + pathname_prefix + '/' + args[0];
 }
 
 /**
@@ -69,7 +82,7 @@ export function resolve(...args) {
  * ```js
  * import { match } from '$app/paths';
  *
- * const route = await match('/blog/hello-world');
+ * const route = await match('blog/hello-world');
  *
  * if (route?.id === '/blog/[slug]') {
  * 	const slug = route.params.slug;
@@ -79,22 +92,9 @@ export function resolve(...args) {
  * ```
  * @since 2.52.0
  *
- * @param {Pathname | URL | (string & {})} url
+ * @param {Path | URL | (string & {})} url
  * @returns {Promise<{ [K in RouteId]: { id: K; params: RouteParams<K>; } }[RouteId] | null>}
  */
-export async function match(url) {
-	if (typeof url === 'string') {
-		url = new URL(url, location.href);
-	}
-
-	const intent = await get_navigation_intent(url, false);
-
-	if (intent) {
-		return {
-			id: /** @type {RouteId} */ (intent.route.id),
-			params: intent.params
-		};
-	}
-
-	return null;
+export function match(url) {
+	return match_implementation(url);
 }

package/src/runtime/app/paths/internal/client.js

@@ -1,6 +1,32 @@
+/** @import { RouteId, Path } from '$app/types' */
 import { payload } from '../../../client/payload.js';
 
 export const base = payload.base ?? __SVELTEKIT_PATHS_BASE__;
 export const assets = payload.assets ?? base ?? __SVELTEKIT_PATHS_ASSETS__;
 export const app_dir = __SVELTEKIT_APP_DIR__;
 export const hash_routing = __SVELTEKIT_HASH_ROUTING__;
+
+/**
+ * We make this configurable per-environment so that it's possible to import `$app/paths`
+ * into a service worker without importing the entire client
+ * @param {Path | URL | (string & {})} _url
+ * @returns {Promise<{ [K in RouteId]: { id: K; params: import('$app/types').RouteParams<K>; } }[RouteId] | null>}
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+export let match_implementation = async (_url) => {
+	// @ts-ignore
+	if (typeof ServiceWorkerGlobalScope !== 'undefined' && self instanceof ServiceWorkerGlobalScope) {
+		throw new Error(
+			'Cannot use `match(...)` inside a service worker, as it depends on the SvelteKit client instance'
+		);
+	}
+
+	return null;
+};
+
+/**
+ * @param {typeof match_implementation} fn
+ */
+export function set_match_implementation(fn) {
+	match_implementation = fn;
+}

package/src/runtime/app/paths/server.js

@@ -3,25 +3,38 @@ import { resolve_route, find_route } from '../../../utils/routing.js';
 import { decode_pathname } from '../../../utils/url.js';
 import { add_data_suffix } from '../../pathname.js';
 import { try_get_request_store } from '@sveltejs/kit/internal/server';
-import { manifest } from '__sveltekit/server';
+import { manifest } from '../../server/internal.js';
 import { get_hooks } from '__SERVER__/internal.js';
+import { DEV } from 'esm-env';
 
 /** @type {import('./client.js').asset} */
 export function asset(file) {
-	// @ts-expect-error we use the `resolve` mechanism, but with the 'wrong' input
-	return assets && assets !== base ? assets + file : resolve(file);
+	// TODO 4.0 remove this
+	if (file[0] === '/') {
+		if (DEV) {
+			console.warn(`\`asset('${file}')\` should now be \`asset('${file.slice(1)}')\``);
+		}
+
+		file = file.slice(1);
+	}
+
+	return assets !== base ? `${assets}/${file}` : resolve(file);
 }
 
 /** @type {import('./client.js').resolve} */
 export function resolve(id, params) {
-	if (!id.startsWith('/')) {
-		throw new Error(
-			`Cannot use \`resolve(...)\` with a non-absolute pathname or route ID (got "${id}"). ` +
-				'`resolve` is only for internal pathnames and route IDs; external URLs should be used directly.'
-		);
-	}
+	let resolved;
+
+	if (id[0] === '/') {
+		// route ID
+		if (id.includes('[') && !params) {
+			throw new Error(`Missing params for dynamic route ID ${id}`);
+		}
 
-	const resolved = resolve_route(id, params ?? {});
+		resolved = resolve_route(id, params ?? {});
+	} else {
+		resolved = '/' + id;
+	}
 
 	if (relative) {
 		const store = try_get_request_store();

package/src/runtime/app/paths/types.d.ts

@@ -1,23 +1,15 @@
-import {
-	PathnameWithSearchOrHash,
-	RouteId,
-	RouteIdWithSearchOrHash,
-	RouteParams
-} from '$app/types';
+import { RouteId, RouteParams } from '$app/types';
 
-type StripSearchOrHash<T extends string> = T extends `${infer Pathname}?${string}`
-	? Pathname
-	: T extends `${infer Pathname}#${string}`
-		? Pathname
+type StripSearchOrHash<T extends string> = T extends `${infer U}?${string}`
+	? U
+	: T extends `${infer U}#${string}`
+		? U
 		: T;
 
-export type ResolveArgs<T extends RouteIdWithSearchOrHash | PathnameWithSearchOrHash> =
-	T extends RouteId
-		? RouteParams<T> extends Record<string, never>
+export type ResolveArgs<T> = T extends `/${string}`
+	? StripSearchOrHash<T> extends infer U extends RouteId
+		? RouteParams<U> extends Record<string, never>
 			? [route: T]
-			: [route: T, params: RouteParams<T>]
-		: StripSearchOrHash<T> extends infer U extends RouteId
-			? RouteParams<U> extends Record<string, never>
-				? [route: T]
-				: [route: T, params: RouteParams<U>]
-			: [route: T];
+			: [route: T, params: RouteParams<U>]
+		: [never]
+	: [pathname: T];

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

@@ -1,4 +1,4 @@
-import { read_implementation, manifest } from '__sveltekit/server';
+import { read_implementation, manifest } from '../../server/internal.js';
 import { assets } from '$app/paths/internal/server';
 import { base64_decode } from '../../utils.js';
 

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

@@ -65,16 +65,21 @@ export function command(validate_or_fn, maybe_fn) {
 	const wrapper = (arg) => {
 		const { event, state } = get_request_store();
 
-		if (!MUTATIVE_METHODS.includes(event.request.method)) {
-			throw new Error(
-				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) from a ${event.request.method} handler`
-			);
+		if (
+			!MUTATIVE_METHODS.includes(event.request.method) ||
+			state.is_in_remote_query ||
+			state.is_in_remote_prerender
+		) {
+			const violation =
+				state.is_in_remote_query || state.is_in_remote_prerender
+					? `inside a query or prerender function`
+					: `from a ${event.request.method} handler`;
+
+			throw new Error(`Cannot call a command (${__.name}) ${violation}`);
 		}
 
 		if (state.is_in_render) {
-			throw new Error(
-				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) during server-side rendering`
-			);
+			throw new Error(`Cannot call a command (${__.name}) during server-side rendering`);
 		}
 
 		const promise = Promise.resolve(

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

@@ -7,7 +7,8 @@ import {
 	set_nested_value,
 	deep_set,
 	normalize_issue,
-	flatten_issues
+	flatten_issues,
+	parse_form_key
 } from '../../../form-utils.js';
 import { get_cache, get_implicit_lookup, run_remote_function } from './shared.js';
 import { ValidationError } from '@sveltejs/kit/internal';
@@ -102,7 +103,7 @@ export function form(validate_or_fn, maybe_fn) {
 				}
 
 				if (validated?.issues !== undefined) {
-					handle_issues(output, validated.issues, form_data);
+					handle_issues(output, validated.issues, form_data, __.id);
 				} else {
 					if (validated !== undefined) {
 						data = validated.value;
@@ -120,7 +121,7 @@ export function form(validate_or_fn, maybe_fn) {
 						);
 					} catch (e) {
 						if (e instanceof ValidationError) {
-							handle_issues(output, e.issues, form_data);
+							handle_issues(output, e.issues, form_data, __.id);
 						} else {
 							throw e;
 						}
@@ -135,7 +136,7 @@ export function form(validate_or_fn, maybe_fn) {
 
 					// register under the client-side action id so the output is serialized
 					// into the page, allowing the hydrated client to restore `result`/`issues`/`input`
-					get_implicit_lookup(__, state)[__.action_id ?? __.id] = () => cache[''];
+					get_implicit_lookup(__, state)[__.key ? `${__.id}/${__.key}` : __.id] = () => cache[''];
 				}
 
 				return output;
@@ -145,7 +146,7 @@ export function form(validate_or_fn, maybe_fn) {
 		Object.defineProperty(instance, '__', { value: __ });
 
 		Object.defineProperty(instance, 'action', {
-			get: () => `?/remote=${__.id}`,
+			get: () => `?/remote=${__.key ? `${__.id}/${encodeURIComponent(__.key)}` : __.id}`,
 			enumerable: true
 		});
 
@@ -153,10 +154,10 @@ export function form(validate_or_fn, maybe_fn) {
 			get() {
 				// the form instance is created once per module and shared across requests,
 				// so the current request's state has to be resolved at access time
-				return create_field_proxy(
-					{},
-					() => get_cache(__, get_request_store().state)?.['']?.input ?? {},
-					(path, value) => {
+				return create_field_proxy({
+					form_id: __.id,
+					get: () => get_cache(__, get_request_store().state)?.['']?.input ?? {},
+					set: (path, value) => {
 						const cache = get_cache(__, get_request_store().state);
 						const entry = cache[''];
 
@@ -174,11 +175,11 @@ export function form(validate_or_fn, maybe_fn) {
 						deep_set(input, path.map(String), value);
 						(cache[''] ??= {}).input = input;
 					},
-					() => flatten_issues(get_cache(__, get_request_store().state)?.['']?.issues ?? []),
-					() => ({}),
-					() => ({}),
-					[]
-				);
+					get_issues: () =>
+						flatten_issues(get_cache(__, get_request_store().state)?.['']?.issues ?? []),
+					get_touched: () => ({}),
+					get_dirty: () => ({})
+				});
 			}
 		});
 
@@ -228,12 +229,15 @@ export function form(validate_or_fn, maybe_fn) {
 				value: (key) => {
 					const { state } = get_request_store();
 					const cache_key = __.id + '|' + JSON.stringify(key);
+					/** @type {RemoteForm<Input, Output> & { __: RemoteFormInternals }} */
 					let instance = (state.remote.forms ??= new Map()).get(cache_key);
 
 					if (!instance) {
-						instance = create_instance(key);
-						instance.__.id = `${__.id}/${encodeURIComponent(JSON.stringify(key))}`;
-						instance.__.action_id = `${__.id}/${JSON.stringify(key)}`;
+						instance = /** @type {RemoteForm<Input, Output> & { __: RemoteFormInternals }} */ (
+							create_instance(key)
+						);
+						instance.__.id = __.id;
+						instance.__.key = JSON.stringify(key);
 						instance.__.name = __.name;
 
 						state.remote.forms.set(cache_key, instance);
@@ -254,8 +258,9 @@ export function form(validate_or_fn, maybe_fn) {
  * @param {{ issues?: InternalRemoteFormIssue[], input?: Record<string, any>, result: any }} output
  * @param {readonly StandardSchemaV1.Issue[]} issues
  * @param {FormData | null} form_data - null if the form is progressively enhanced
+ * @param {string} form_id - hash/name of the form
  */
-function handle_issues(output, issues, form_data) {
+function handle_issues(output, issues, form_data, form_id) {
 	output.issues = issues.map((issue) => normalize_issue(issue, true));
 
 	// if it was a progressively-enhanced submission, we don't need
@@ -263,19 +268,17 @@ function handle_issues(output, issues, form_data) {
 	if (form_data) {
 		output.input = {};
 
-		for (let key of form_data.keys()) {
+		for (const field_name of form_data.keys()) {
 			// redact sensitive fields
-			if (/^[.\]]?_/.test(key)) continue;
-
-			const is_array = key.endsWith('[]');
-			const values = form_data.getAll(key).filter((value) => typeof value === 'string');
+			if (/^[.\]]?_/.test(field_name)) continue;
 
-			if (is_array) key = key.slice(0, -2);
+			const values = form_data.getAll(field_name).filter((value) => typeof value === 'string');
+			const field = parse_form_key(form_id, field_name);
 
 			set_nested_value(
 				/** @type {Record<string, any>} */ (output.input),
-				key,
-				is_array ? values : values[0]
+				field,
+				field.is_array ? values : values[0]
 			);
 		}
 	}

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

@@ -102,7 +102,8 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 				try {
 					// TODO adapters can provide prerendered data more efficiently than
 					// fetching from the public internet
-					const response = await fetch(new URL(url, event.url.origin).href);
+					// `request.url` rather than `event.url`, which throws inside queries
+					const response = await fetch(new URL(url, event.request.url).href);
 
 					if (!response.ok) {
 						throw new Error('Prerendered response not found');
@@ -126,7 +127,13 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 				return /** @type {Promise<any>} */ (state.prerendering.remote_responses.get(url));
 			}
 
-			const promise = run_remote_function(event, state, false, () => validate(arg), fn);
+			const promise = run_remote_function(
+				event,
+				{ ...state, is_in_remote_prerender: true },
+				false,
+				() => validate(arg),
+				fn
+			);
 
 			if (state.prerendering) {
 				state.prerendering.remote_responses.set(url, promise);

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

@@ -13,7 +13,7 @@ import {
 } from './shared.js';
 import { noop } from '../../../../utils/functions.js';
 import { SharedIterator } from '../../../../utils/shared-iterator.js';
-import { handle_error_and_jsonify } from '../../../server/utils.js';
+import { handle_error_and_jsonify } from '../../../server/errors.js';
 
 /**
  * Creates a remote query. When called from the browser, the function will be invoked on the server via a `fetch` call.
@@ -404,17 +404,18 @@ export function refresh(event, state, internals, payload, fn) {
 		return;
 	}
 
-	if (!event.isRemoteRequest) {
-		// or this is a no-JS form submission
+	if (!event.isRemoteRequest && state.is_in_remote_form_or_command) {
+		// ...or this is a no-JS (native) form submission, where the page re-renders
+		// anyway so there's no live client cache to apply a single-flight update to.
 		return;
 	}
 
 	const key = create_remote_key(internals.id, payload);
 
 	// `fn` is stored rather than invoked eagerly. The query is run at the end of
-	// the command/form (in `collect_remote_data`), so that it observes any state
+	// the request (in `collect_remote_data`), so that it observes any state
 	// mutations that happen after `refresh()` is called. If the developer re-awaits
-	// the query before the command finishes, the cache entry created by that await
+	// the query before the request finishes, the cache entry created by that await
 	// is reused instead of re-running the query.
 	(state.remote.explicit ??= new Map()).set(key, {
 		internals,