@sveltejs/kit 1.18.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "The fastest way to build Svelte apps",
   "repository": {
     "type": "git",
@@ -33,6 +33,7 @@
     "@types/node": "^16.18.6",
     "@types/sade": "^1.7.4",
     "@types/set-cookie-parser": "^2.4.2",
+    "dts-buddy": "^0.0.9",
     "marked": "^4.2.3",
     "rollup": "^3.7.0",
     "svelte": "^3.56.0",
@@ -64,15 +65,19 @@
       "import": "./src/exports/index.js"
     },
     "./node": {
+      "types": "./types/index.d.ts",
       "import": "./src/exports/node/index.js"
     },
     "./node/polyfills": {
+      "types": "./types/index.d.ts",
       "import": "./src/exports/node/polyfills.js"
     },
     "./hooks": {
+      "types": "./types/index.d.ts",
       "import": "./src/exports/hooks/index.js"
     },
     "./vite": {
+      "types": "./types/index.d.ts",
       "import": "./src/exports/vite/index.js"
     }
   },

package/src/core/adapt/builder.js

@@ -24,7 +24,7 @@ const pipe = promisify(pipeline);
  *   prerender_map: import('types').PrerenderMap;
  *   log: import('types').Logger;
  * }} opts
- * @returns {import('types').Builder}
+ * @returns {import('@sveltejs/kit').Builder}
  */
 export function create_builder({
 	config,
@@ -35,7 +35,7 @@ export function create_builder({
 	prerender_map,
 	log
 }) {
-	/** @type {Map<import('types').RouteDefinition, import('types').RouteData>} */
+	/** @type {Map<import('@sveltejs/kit').RouteDefinition, import('types').RouteData>} */
 	const lookup = new Map();
 
 	/**
@@ -47,7 +47,7 @@ export function create_builder({
 			server_metadata.routes.get(route.id)
 		);
 
-		/** @type {import('types').RouteDefinition} */
+		/** @type {import('@sveltejs/kit').RouteDefinition} */
 		const facade = {
 			id: route.id,
 			api,

package/src/core/config/index.js

@@ -73,7 +73,7 @@ export async function load_config({ cwd = process.cwd() } = {}) {
 }
 
 /**
- * @param {import('types').Config} config
+ * @param {import('@sveltejs/kit').Config} config
  * @returns {import('types').ValidatedConfig}
  */
 function process_config(config, { cwd = process.cwd() } = {}) {
@@ -95,7 +95,7 @@ function process_config(config, { cwd = process.cwd() } = {}) {
 }
 
 /**
- * @param {import('types').Config} config
+ * @param {import('@sveltejs/kit').Config} config
  * @returns {import('types').ValidatedConfig}
  */
 export function validate_config(config) {

package/src/core/config/options.js

@@ -210,7 +210,7 @@ const options = object(
 					(/** @type {any} */ { message }) => {
 						throw new Error(
 							message +
-								`\nTo suppress or handle this error, implement \`handleHttpError\` in https://kit.svelte.dev/docs/configuration#prerender`
+								'\nTo suppress or handle this error, implement `handleHttpError` in https://kit.svelte.dev/docs/configuration#prerender'
 						);
 					},
 					(input, keypath) => {
@@ -224,7 +224,7 @@ const options = object(
 					(/** @type {any} */ { message }) => {
 						throw new Error(
 							message +
-								`\nTo suppress or handle this error, implement \`handleMissingId\` in https://kit.svelte.dev/docs/configuration#prerender`
+								'\nTo suppress or handle this error, implement `handleMissingId` in https://kit.svelte.dev/docs/configuration#prerender'
 						);
 					},
 					(input, keypath) => {
@@ -238,7 +238,7 @@ const options = object(
 					(/** @type {any} */ { message }) => {
 						throw new Error(
 							message +
-								`\nTo suppress or handle this error, implement \`handleEntryGeneratorMismatch\` in https://kit.svelte.dev/docs/configuration#prerender`
+								'\nTo suppress or handle this error, implement `handleEntryGeneratorMismatch` in https://kit.svelte.dev/docs/configuration#prerender'
 						);
 					},
 					(input, keypath) => {

package/src/core/env.js

@@ -75,7 +75,7 @@ export function create_dynamic_types(id, env, prefix) {
 
 	if (id === 'private') {
 		properties.push(`${prefixed}: undefined;`);
-		properties.push(`[key: string]: string | undefined;`);
+		properties.push('[key: string]: string | undefined;');
 	} else {
 		properties.push(`${prefixed}: string | undefined;`);
 	}

package/src/core/generate_manifest/index.js

@@ -55,7 +55,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 
 	/** @param {Array<number | undefined>} indexes */
 	function get_nodes(indexes) {
-		let string = indexes.map((n) => reindexed.get(n) ?? '').join(',');
+		const string = indexes.map((n) => reindexed.get(n) ?? '').join(',');
 
 		// since JavaScript ignores trailing commas, we need to insert a dummy
 		// comma so that the array has the correct length if the last item
@@ -65,7 +65,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 
 	// prettier-ignore
 	// String representation of
-	/** @type {import('types').SSRManifest} */
+	/** @type {import('@sveltejs/kit').SSRManifest} */
 	return dedent`
 		{
 			appDir: ${s(build_data.app_dir)},

package/src/core/postbuild/analyse.js

@@ -12,7 +12,7 @@ import { load_config } from '../config/index.js';
 import { forked } from '../../utils/fork.js';
 import { should_polyfill } from '../../utils/platform.js';
 import { installPolyfills } from '../../exports/node/polyfills.js';
-import { resolve_entry } from '../../utils/routing.js';
+import { resolvePath } from '../../exports/index.js';
 
 export default forked(import.meta.url, analyse);
 
@@ -23,7 +23,7 @@ export default forked(import.meta.url, analyse);
  * }} opts
  */
 async function analyse({ manifest_path, env }) {
-	/** @type {import('types').SSRManifest} */
+	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ValidatedKitConfig} */
@@ -145,7 +145,7 @@ async function analyse({ manifest_path, env }) {
 			},
 			prerender,
 			entries:
-				entries && (await entries()).map((entry_object) => resolve_entry(route.id, entry_object))
+				entries && (await entries()).map((entry_object) => resolvePath(route.id, entry_object))
 		});
 	}
 

package/src/core/postbuild/fallback.js

@@ -27,7 +27,7 @@ async function generate_fallback({ manifest_path, env }) {
 	/** @type {import('types').ServerModule} */
 	const { Server } = await import(pathToFileURL(`${server_root}/server/index.js`).href);
 
-	/** @type {import('types').SSRManifest} */
+	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	set_building(true);

package/src/core/postbuild/prerender.js

@@ -26,7 +26,7 @@ export default forked(import.meta.url, prerender);
  * }} opts
  */
 async function prerender({ out, manifest_path, metadata, verbose, env }) {
-	/** @type {import('types').SSRManifest} */
+	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */

package/src/core/sync/create_manifest_data/index.js

@@ -456,7 +456,7 @@ function analyze(project_relative, file, component_extensions, module_extensions
 			);
 		}
 
-		const kind = !!(match[1] || match[4] || match[7]) ? 'server' : 'universal';
+		const kind = match[1] || match[4] || match[7] ? 'server' : 'universal';
 
 		return {
 			kind,
@@ -513,7 +513,7 @@ function prevent_conflicts(routes) {
 		const normalized = normalize_route_id(route.id);
 
 		// find all permutations created by optional parameters
-		const split = normalized.split(/<\?(.+?)\>/g);
+		const split = normalized.split(/<\?(.+?)>/g);
 
 		let permutations = [/** @type {string} */ (split[0])];
 

package/src/core/sync/write_ambient.js

@@ -8,7 +8,7 @@ import { write_if_changed } from './utils.js';
 
 // TODO these types should be described in a neutral place, rather than
 // inside either `packages/kit` or `kit.svelte.dev`
-const descriptions_dir = fileURLToPath(new URL('../../../types/synthetic', import.meta.url));
+const descriptions_dir = fileURLToPath(new URL('../../../src/types/synthetic', import.meta.url));
 
 /** @param {string} filename */
 function read_description(filename) {

package/src/core/sync/write_client_manifest.js

@@ -21,7 +21,7 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 		if (node.universal) {
 			declarations.push(
 				`import * as universal from ${s(relative_path(`${output}/nodes`, node.universal))};`,
-				`export { universal };`
+				'export { universal };'
 			);
 		}
 

package/src/core/sync/write_server.js

@@ -75,7 +75,7 @@ export { set_assets, set_building, set_private_env, set_public_env };
  * @param {string} output
  */
 export function write_server(config, output) {
-	// TODO the casting shouldn't be necessary — investigate
+	// TODO the casting shouldn't be necessary — investigate
 	const hooks_file = /** @type {string} */ (resolve_entry(config.kit.files.hooks.server));
 
 	/** @param {string} file */

package/src/core/sync/write_types/index.js

@@ -52,7 +52,7 @@ export async function write_all_types(config, manifest_data) {
 	// it could be invoked by another process in the meantime.
 	const meta_data_file = `${types_dir}/route_meta_data.json`;
 	const has_meta_data = fs.existsSync(meta_data_file);
-	let meta_data = has_meta_data
+	const meta_data = has_meta_data
 		? /** @type {Record<string, string[]>} */ (JSON.parse(fs.readFileSync(meta_data_file, 'utf-8')))
 		: {};
 	const routes_map = create_routes_map(manifest_data);
@@ -177,7 +177,7 @@ function update_types(config, routes, route, to_delete = new Set()) {
 	const outdir = path.join(config.kit.outDir, 'types', routes_dir, route.id);
 
 	// now generate new types
-	const imports = [`import type * as Kit from '@sveltejs/kit';`];
+	const imports = ["import type * as Kit from '@sveltejs/kit';"];
 
 	/** @type {string[]} */
 	const declarations = [];
@@ -196,7 +196,7 @@ function update_types(config, routes, route, to_delete = new Set()) {
 
 	if (route.params.length > 0) {
 		exports.push(
-			`export type EntryGenerator = () => Promise<Array<RouteParams>> | Array<RouteParams>;`
+			'export type EntryGenerator = () => Promise<Array<RouteParams>> | Array<RouteParams>;'
 		);
 	}
 
@@ -206,24 +206,24 @@ function update_types(config, routes, route, to_delete = new Set()) {
 	if (route.layout || route.leaf) {
 		declarations.push(
 			// If T extends the empty object, void is also allowed as a return type
-			`type MaybeWithVoid<T> = {} extends T ? T | void : T;`,
+			'type MaybeWithVoid<T> = {} extends T ? T | void : T;',
 
 			// Returns the key of the object whose values are required.
-			`export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];`,
+			'export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];',
 
 			// Helper type to get the correct output type for load functions. It should be passed the parent type to check what types from App.PageData are still required.
 			// If none, void is also allowed as a return type.
-			`type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>`,
+			'type OutputDataShape<T> = MaybeWithVoid<Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>>',
 
 			// null & {} == null, we need to prevent that in some situations
-			`type EnsureDefined<T> = T extends null | undefined ? {} : T;`,
+			'type EnsureDefined<T> = T extends null | undefined ? {} : T;',
 
 			// Takes a union type and returns a union type where each type also has all properties
 			// of all possible types (typed as undefined), making accessing them more ergonomic
-			`type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;`,
+			'type OptionalUnion<U extends Record<string, any>, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<A, keyof U>]?: never } & U : never;',
 
 			// Re-export `Snapshot` from @sveltejs/kit — in future we could use this to infer <T> from the return type of `snapshot.capture`
-			`export type Snapshot<T = any> = Kit.Snapshot<T>;`
+			'export type Snapshot<T = any> = Kit.Snapshot<T>;'
 		);
 	}
 
@@ -255,10 +255,10 @@ function update_types(config, routes, route, to_delete = new Set()) {
 
 		if (route.leaf.server) {
 			exports.push(
-				`export type Action<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, OutputData, RouteId>`
+				'export type Action<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, OutputData, RouteId>'
 			);
 			exports.push(
-				`export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>`
+				'export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>'
 			);
 		}
 	}
@@ -326,11 +326,11 @@ function update_types(config, routes, route, to_delete = new Set()) {
 	}
 
 	if (route.endpoint) {
-		exports.push(`export type RequestHandler = Kit.RequestHandler<RouteParams, RouteId>;`);
+		exports.push('export type RequestHandler = Kit.RequestHandler<RouteParams, RouteId>;');
 	}
 
 	if (route.leaf?.server || route.layout?.server || route.endpoint) {
-		exports.push(`export type RequestEvent = Kit.RequestEvent<RouteParams, RouteId>;`);
+		exports.push('export type RequestEvent = Kit.RequestEvent<RouteParams, RouteId>;');
 	}
 
 	const output = [imports.join('\n'), declarations.join('\n'), exports.join('\n')]
@@ -386,7 +386,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 		// +page.js load present -> server can return all-optional data
 		const output_data_shape =
 			node.universal || (!is_page && all_pages_have_load)
-				? `Partial<App.PageData> & Record<string, any> | void`
+				? 'Partial<App.PageData> & Record<string, any> | void'
 				: `OutputDataShape<${parent_type}>`;
 		exports.push(
 			`export type ${prefix}ServerLoad<OutputData extends ${output_data_shape} = ${output_data_shape}> = Kit.ServerLoad<${params}, ${parent_type}, OutputData, ${route_id}>;`
@@ -404,15 +404,15 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 					: path_to_original(outdir, node.server);
 
 				exports.push(
-					`type ExcludeActionFailure<T> = T extends Kit.ActionFailure<any> ? never : T extends void ? never : T;`,
-					`type ActionsSuccess<T extends Record<string, (...args: any) => any>> = { [Key in keyof T]: ExcludeActionFailure<Awaited<ReturnType<T[Key]>>>; }[keyof T];`,
-					`type ExtractActionFailure<T> = T extends Kit.ActionFailure<infer X>	? X extends void ? never : X : never;`,
-					`type ActionsFailure<T extends Record<string, (...args: any) => any>> = { [Key in keyof T]: Exclude<ExtractActionFailure<Awaited<ReturnType<T[Key]>>>, void>; }[keyof T];`,
+					'type ExcludeActionFailure<T> = T extends Kit.ActionFailure<any> ? never : T extends void ? never : T;',
+					'type ActionsSuccess<T extends Record<string, (...args: any) => any>> = { [Key in keyof T]: ExcludeActionFailure<Awaited<ReturnType<T[Key]>>>; }[keyof T];',
+					'type ExtractActionFailure<T> = T extends Kit.ActionFailure<infer X>	? X extends void ? never : X : never;',
+					'type ActionsFailure<T extends Record<string, (...args: any) => any>> = { [Key in keyof T]: Exclude<ExtractActionFailure<Awaited<ReturnType<T[Key]>>>, void>; }[keyof T];',
 					`type ActionsExport = typeof import('${from}').actions`,
-					`export type SubmitFunction = Kit.SubmitFunction<Expand<ActionsSuccess<ActionsExport>>, Expand<ActionsFailure<ActionsExport>>>`
+					'export type SubmitFunction = Kit.SubmitFunction<Expand<ActionsSuccess<ActionsExport>>, Expand<ActionsFailure<ActionsExport>>>'
 				);
 
-				type = `Expand<Kit.AwaitedActions<ActionsExport>> | null`;
+				type = 'Expand<Kit.AwaitedActions<ActionsExport>> | null';
 			}
 			exports.push(`export type ActionData = ${type};`);
 		}
@@ -440,7 +440,7 @@ function process_node(node, outdir, is_page, proxies, all_pages_have_load = true
 
 		const output_data_shape =
 			!is_page && all_pages_have_load
-				? `Partial<App.PageData> & Record<string, any> | void`
+				? 'Partial<App.PageData> & Record<string, any> | void'
 				: `OutputDataShape<${parent_type}>`;
 		exports.push(
 			`export type ${prefix}Load<OutputData extends ${output_data_shape} = ${output_data_shape}> = Kit.Load<${params}, ${prefix}ServerData, ${parent_type}, OutputData, ${route_id}>;`
@@ -688,7 +688,7 @@ export function tweak_types(content, is_server) {
 						// remove type from `export const load: Load ...`
 						if (declaration.type) {
 							let a = declaration.type.pos;
-							let b = declaration.type.end;
+							const b = declaration.type.end;
 							while (/\s/.test(content[a])) a += 1;
 
 							const type = content.slice(a, b);
@@ -760,7 +760,7 @@ export function tweak_types(content, is_server) {
 						// remove type from `export const actions: Actions ...`
 						if (declaration.type) {
 							let a = declaration.type.pos;
-							let b = declaration.type.end;
+							const b = declaration.type.end;
 							while (/\s/.test(content[a])) a += 1;
 
 							const type = content.slice(a, b);
@@ -788,7 +788,7 @@ export function tweak_types(content, is_server) {
 											if (arg && !arg.type) {
 												code.appendLeft(
 													arg.name.end,
-													`: import('./$types').RequestEvent` + (add_parens ? ')' : '')
+													": import('./$types').RequestEvent" + (add_parens ? ')' : '')
 												);
 											}
 										}

package/src/exports/hooks/sequence.js

@@ -1,6 +1,70 @@
 /**
- * @param {...import('types').Handle} handlers
- * @returns {import('types').Handle}
+ * A helper function for sequencing multiple `handle` calls in a middleware-like manner.
+ * The behavior for the `handle` options is as follows:
+ * - `transformPageChunk` is applied in reverse order and merged
+ * - `preload` is applied in forward order, the first option "wins" and no `preload` options after it are called
+ * - `filterSerializedResponseHeaders` behaves the same as `preload`
+ *
+ * ```js
+ * /// file: src/hooks.server.js
+ * import { sequence } from '@sveltejs/kit/hooks';
+ *
+ * /// type: import('@sveltejs/kit').Handle
+ * async function first({ event, resolve }) {
+ * 	console.log('first pre-processing');
+ * 	const result = await resolve(event, {
+ * 		transformPageChunk: ({ html }) => {
+ * 			// transforms are applied in reverse order
+ * 			console.log('first transform');
+ * 			return html;
+ * 		},
+ * 		preload: () => {
+ * 			// this one wins as it's the first defined in the chain
+ * 			console.log('first preload');
+ * 		}
+ * 	});
+ * 	console.log('first post-processing');
+ * 	return result;
+ * }
+ *
+ * /// type: import('@sveltejs/kit').Handle
+ * async function second({ event, resolve }) {
+ * 	console.log('second pre-processing');
+ * 	const result = await resolve(event, {
+ * 		transformPageChunk: ({ html }) => {
+ * 			console.log('second transform');
+ * 			return html;
+ * 		},
+ * 		preload: () => {
+ * 			console.log('second preload');
+ * 		},
+ * 		filterSerializedResponseHeaders: () => {
+ * 			// this one wins as it's the first defined in the chain
+ *    		console.log('second filterSerializedResponseHeaders');
+ * 		}
+ * 	});
+ * 	console.log('second post-processing');
+ * 	return result;
+ * }
+ *
+ * export const handle = sequence(first, second);
+ * ```
+ *
+ * The example above would print:
+ *
+ * ```
+ * first pre-processing
+ * first preload
+ * second pre-processing
+ * second filterSerializedResponseHeaders
+ * second transform
+ * first transform
+ * second post-processing
+ * first post-processing
+ * ```
+ *
+ * @param {...import('@sveltejs/kit').Handle} handlers The chain of `handle` functions
+ * @returns {import('@sveltejs/kit').Handle}
  */
 export function sequence(...handlers) {
 	const length = handlers.length;
@@ -11,8 +75,8 @@ export function sequence(...handlers) {
 
 		/**
 		 * @param {number} i
-		 * @param {import('types').RequestEvent} event
-		 * @param {import('types').ResolveOptions | undefined} parent_options
+		 * @param {import('@sveltejs/kit').RequestEvent} event
+		 * @param {import('@sveltejs/kit').ResolveOptions | undefined} parent_options
 		 * @returns {import('types').MaybePromise<Response>}
 		 */
 		function apply_handle(i, event, parent_options) {
@@ -21,7 +85,7 @@ export function sequence(...handlers) {
 			return handle({
 				event,
 				resolve: (event, options) => {
-					/** @type {import('types').ResolveOptions['transformPageChunk']} */
+					/** @type {import('@sveltejs/kit').ResolveOptions['transformPageChunk']} */
 					const transformPageChunk = async ({ html, done }) => {
 						if (options?.transformPageChunk) {
 							html = (await options.transformPageChunk({ html, done })) ?? '';
@@ -34,12 +98,12 @@ export function sequence(...handlers) {
 						return html;
 					};
 
-					/** @type {import('types').ResolveOptions['filterSerializedResponseHeaders']} */
+					/** @type {import('@sveltejs/kit').ResolveOptions['filterSerializedResponseHeaders']} */
 					const filterSerializedResponseHeaders =
 						parent_options?.filterSerializedResponseHeaders ??
 						options?.filterSerializedResponseHeaders;
 
-					/** @type {import('types').ResolveOptions['preload']} */
+					/** @type {import('@sveltejs/kit').ResolveOptions['preload']} */
 					const preload = parent_options?.preload ?? options?.preload;
 
 					return i < length - 1

package/src/exports/index.js

@@ -1,22 +1,43 @@
 import { HttpError, Redirect, ActionFailure } from '../runtime/control.js';
 import { BROWSER, DEV } from 'esm-env';
+import { get_route_segments } from '../utils/routing.js';
 
-// For some reason we need to type the params as well here,
-// JSdoc doesn't seem to like @type with function overloads
 /**
- * @type {import('@sveltejs/kit').error}
+ * @overload
  * @param {number} status
- * @param {any} message
+ * @param {App.Error} body
+ * @return {HttpError}
  */
-export function error(status, message) {
+
+/**
+ * @overload
+ * @param {number} status
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
+ * @return {HttpError}
+ */
+
+/**
+ * Creates an `HttpError` object with an HTTP status code and an optional message.
+ * This object, if thrown during request handling, will cause SvelteKit to
+ * return an error response without invoking `handleError`.
+ * Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ */
+export function error(status, body) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 400 || status > 599)) {
 		throw new Error(`HTTP error status codes must be between 400 and 599 — ${status} is invalid`);
 	}
 
-	return new HttpError(status, message);
+	return new HttpError(status, body);
 }
 
-/** @type {import('@sveltejs/kit').redirect} */
+/**
+ * Create a `Redirect` object. If thrown during request handling, SvelteKit will return a redirect response.
+ * Make sure you're not catching the thrown redirect, which would prevent SvelteKit from handling it.
+ * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.
+ * @param {string} location The location to redirect to.
+ */
 export function redirect(status, location) {
 	if ((!BROWSER || DEV) && (isNaN(status) || status < 300 || status > 308)) {
 		throw new Error('Invalid status code');
@@ -25,7 +46,11 @@ export function redirect(status, location) {
 	return new Redirect(status, location);
 }
 
-/** @type {import('@sveltejs/kit').json} */
+/**
+ * Create a JSON `Response` object from the supplied data.
+ * @param {any} data The value that will be serialized as JSON.
+ * @param {ResponseInit} [init] Options such as `status` and `headers` that will be added to the response. `Content-Type: application/json` and `Content-Length` headers will be added automatically.
+ */
 export function json(data, init) {
 	// TODO deprecate this in favour of `Response.json` when it's
 	// more widely supported
@@ -51,7 +76,11 @@ export function json(data, init) {
 
 const encoder = new TextEncoder();
 
-/** @type {import('@sveltejs/kit').text} */
+/**
+ * Create a `Response` object from the supplied body.
+ * @param {string} body The value that will be used as-is.
+ * @param {ResponseInit} [init] Options such as `status` and `headers` that will be added to the response. A `Content-Length` header will be added automatically.
+ */
 export function text(body, init) {
 	const headers = new Headers(init?.headers);
 	if (!headers.has('content-length')) {
@@ -65,10 +94,57 @@ export function text(body, init) {
 }
 
 /**
- * Generates an `ActionFailure` object.
- * @param {number} status
- * @param {Record<string, any> | undefined} [data]
+ * Create an `ActionFailure` object.
+ * @template {Record<string, unknown> | undefined} [T=undefined]
+ * @param {number} status The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). Must be in the range 400-599.
+ * @param {T} [data] Data associated with the failure (e.g. validation errors)
+ * @returns {ActionFailure<T>}
  */
 export function fail(status, data) {
 	return new ActionFailure(status, data);
 }
+
+const basic_param_pattern = /\[(\[)?(?:\.\.\.)?(\w+?)(?:=(\w+))?\]\]?/g;
+
+/**
+ * Populate a route ID with params to resolve a pathname.
+ * @example
+ * ```js
+ * resolvePath(
+ *   `/blog/[slug]/[...somethingElse]`,
+ *   {
+ *     slug: 'hello-world',
+ *     somethingElse: 'something/else'
+ *   }
+ * ); // `/blog/hello-world/something/else`
+ * ```
+ * @param {string} id
+ * @param {Record<string, string | undefined>} params
+ * @returns {string}
+ */
+export function resolvePath(id, params) {
+	const segments = get_route_segments(id);
+	return (
+		'/' +
+		segments
+			.map((segment) =>
+				segment.replace(basic_param_pattern, (_, optional, name) => {
+					const param_value = params[name];
+
+					// This is nested so TS correctly narrows the type
+					if (!param_value) {
+						if (optional) return '';
+						throw new Error(`Missing parameter '${name}' in route ${id}`);
+					}
+
+					if (param_value.startsWith('/') || param_value.endsWith('/'))
+						throw new Error(
+							`Parameter '${name}' in route ${id} cannot start or end with a slash -- this would cause an invalid route like foo//bar`
+						);
+					return param_value;
+				})
+			)
+			.filter(Boolean)
+			.join('/')
+	);
+}