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

package/src/core/env.js

@@ -38,6 +38,7 @@ export async function load_explicit_env(kit, file, root, mode) {
 		logLevel: 'silent',
 		mode,
 		define: {
+			__SVELTEKIT_PAYLOAD__: 'undefined', // coming in through static import in env/internal.js but will end up unused
 			__SVELTEKIT_APP_VERSION__: JSON.stringify(kit.version.name) // needed by $app/env
 		},
 		resolve: {
@@ -94,8 +95,9 @@ export async function load_explicit_env(kit, file, root, mode) {
  * @param {Record<string, EnvVarConfig<any> | undefined> | null} variables
  * @param {Record<string, string>} env
  * @param {string | null} entry
+ * @param {boolean} is_dev
  */
-export function create_sveltekit_env(variables, env, entry) {
+export function create_sveltekit_env(variables, env, entry, is_dev) {
 	const imports = entry
 		? [
 				`import { variables } from ${JSON.stringify(entry)};`,
@@ -149,6 +151,19 @@ export function create_sveltekit_env(variables, env, entry) {
 			}`
 	];
 
+	// In dev, initialise the env immediately. Tools like `vite-node` load modules
+	// through the Vite config but don't run the SvelteKit dev server, which is what
+	// normally calls `set_env`. Without this, dynamic env vars imported from
+	// `$app/env/public` and `$app/env/private` would be `undefined` in such contexts.
+	if (is_dev) {
+		/** @type {Record<string, string>} */
+		const dev_env = {};
+		for (const name of Object.keys(variables ?? {})) {
+			if (name in env) dev_env[name] = env[name];
+		}
+		blocks.push(`set_env(${devalue.uneval(dev_env)});`);
+	}
+
 	const module = blocks.join('\n\n');
 
 	return module;
@@ -361,3 +376,73 @@ export const reserved = new Set([
 ]);
 
 export const valid_identifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+/**
+ * Generates `export const` declarations (and, for reserved-word names that need
+ * aliasing, `const` + re-export specifiers) for a set of named exports.
+ *
+ * For regular names, emits a single efficient `export const name = expr;` statement.
+ * For reserved-word names (e.g. `delete`, `class`), emits `const alias = expr;` plus
+ * a re-export specifier (`alias as name`), since reserved words can't be `const`
+ * binding names but CAN appear in export specifiers.
+ *
+ * You can do evil things like `export { c as class }`. In order to import/re-export
+ * these, you need to alias the binding, then un-alias it when re-exporting:
+ *
+ *   const _0 = ...; // safe binding name
+ *   export { _0 as class }; // valid — `class` is allowed in export specifiers
+ *
+ * Aliases are chosen to avoid collisions with any of the supplied names. The
+ * namespace binding (used to hold the imported module) is likewise chosen to
+ * avoid collisions.
+ *
+ * @param {Iterable<string>} names — the export names
+ * @param {(name: string, namespace: string) => string} build_expression —
+ *   called for each name to produce the right-hand side of the declaration;
+ *   receives the chosen namespace binding so it can reference the imported module
+ * @param {string} namespace_prefix — the preferred binding name for the namespace
+ *   (suffixed with a number if it collides with any export name)
+ * @returns {{ namespace: string, declarations: string[], reexports: string[] }}
+ */
+export function create_exported_declarations(names, build_expression, namespace_prefix) {
+	/** @type {Set<string>} */
+	const set = new Set(names);
+
+	let namespace = namespace_prefix;
+	let namespace_index = 0;
+	while (set.has(namespace)) {
+		namespace = `${namespace_prefix}${namespace_index++}`;
+	}
+
+	let alias_index = 0;
+	/** @type {Map<string, string>} */
+	const aliases = new Map();
+
+	for (const name of set) {
+		if (!reserved.has(name)) continue;
+
+		let alias = `_${alias_index++}`;
+		while (set.has(alias)) {
+			alias = `_${alias_index++}`;
+		}
+		aliases.set(name, alias);
+	}
+
+	/** @type {string[]} */
+	const declarations = [];
+	/** @type {string[]} */
+	const reexports = [];
+
+	for (const name of set) {
+		const alias = aliases.get(name);
+		const expr = build_expression(name, namespace);
+		if (alias) {
+			declarations.push(`const ${alias} = ${expr};`);
+			reexports.push(`${alias} as ${name}`);
+		} else {
+			declarations.push(`export const ${name} = ${expr};`);
+		}
+	}
+
+	return { namespace, declarations, reexports };
+}

package/src/core/generate_manifest/index.js

@@ -1,7 +1,7 @@
 /** @import { RemoteChunk } from 'types' */
 import fs from 'node:fs';
 import path from 'node:path';
-import * as mime from 'mrmime';
+import { lookup as mime_lookup } from '../../utils/mime.js';
 import { s } from '../../utils/misc.js';
 import { get_mime_lookup } from '../utils.js';
 import { resolve_symlinks } from '../../exports/vite/build/utils.js';
@@ -69,10 +69,8 @@ export function generate_manifest({
 		assets.push(build_data.service_worker);
 	}
 
-	// In case of server-side route resolution, we need to include all matchers. Prerendered routes are not part
-	// of the server manifest, and they could reference matchers that then would not be included.
-	const matchers = new Set(
-		build_data.client?.nodes ? Object.keys(build_data.manifest_data.matchers) : undefined
+	const uses_matchers = build_data.manifest_data.routes.some((route) =>
+		route.params.some((param) => param.matcher)
 	);
 
 	/** @param {Array<number | undefined>} indexes */
@@ -93,7 +91,7 @@ export function generate_manifest({
 		files[file] = fs.statSync(path.resolve(build_data.out_dir, 'server', file)).size;
 
 		const ext = path.extname(file);
-		mime_types[ext] ??= mime.lookup(ext) || '';
+		mime_types[ext] ??= mime_lookup(ext) || '';
 	}
 
 	// prettier-ignore
@@ -117,10 +115,6 @@ export function generate_manifest({
 					${routes.map(route => {
 						if (!route.page && !route.endpoint) return;
 
-						route.params.forEach(param => {
-							if (param.matcher) matchers.add(param.matcher);
-						});
-
 						return dedent`
 							{
 								id: ${s(route.id)},
@@ -134,11 +128,14 @@ export function generate_manifest({
 				],
 				prerendered_routes: new Set(${s(prerendered)}),
 				matchers: async () => {
-					${Array.from(
-						matchers,
-						type => `const { match: ${type} } = await import ('${(join_relative(relative_path, `/entries/matchers/${type}.js`))}')`
-					).join('\n')}
-					return { ${Array.from(matchers).join(', ')} };
+					${
+						uses_matchers && build_data.manifest_data.params
+							? dedent`
+								const { params } = await import('${join_relative(relative_path, '/entries/params.js')}');
+								return params;
+							`
+							: 'return {};'
+					}
 				},
 				server_assets: ${s(files)}
 			}

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

@@ -1,4 +1,4 @@
-import { lookup } from 'mrmime';
+import { lookup } from '../../../utils/mime.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { styleText } from 'node:util';
@@ -29,22 +29,13 @@ export default function create_manifest_data({
 }) {
 	const assets = create_assets(config);
 	const hooks = create_hooks(config, cwd);
-	const matchers = create_matchers(config, cwd);
+	const params = resolve_params(config, cwd);
 	const { nodes, routes } = create_routes_and_nodes(cwd, config, fallback);
 
-	// validate matcher names used in parameterised routes
-	for (const route of routes) {
-		for (const param of route.params) {
-			if (param.matcher && !matchers[param.matcher]) {
-				throw new Error(`No matcher found for parameter '${param.matcher}' in route ${route.id}`);
-			}
-		}
-	}
-
 	return {
 		assets,
 		hooks,
-		matchers,
+		params,
 		nodes,
 		routes
 	};
@@ -82,38 +73,9 @@ function create_hooks(config, cwd) {
  * @param {import('types').ValidatedConfig} config
  * @param {string} cwd
  */
-function create_matchers(config, cwd) {
-	const params_base = path.relative(cwd, config.kit.files.params);
-
-	/** @type {Record<string, string>} */
-	const matchers = {};
-	if (fs.existsSync(config.kit.files.params)) {
-		for (const file of fs.readdirSync(config.kit.files.params)) {
-			const ext = path.extname(file);
-			if (!config.kit.moduleExtensions.includes(ext)) continue;
-			const type = file.slice(0, -ext.length);
-
-			if (/^\w+$/.test(type)) {
-				const matcher_file = path.join(params_base, file);
-
-				// Disallow same matcher with different extensions
-				if (matchers[type]) {
-					throw new Error(`Duplicate matchers: ${matcher_file} and ${matchers[type]}`);
-				} else {
-					matchers[type] = matcher_file;
-				}
-			} else {
-				// Allow for matcher test collocation
-				if (type.endsWith('.test') || type.endsWith('.spec')) continue;
-
-				throw new Error(
-					`Matcher names can only have underscores and alphanumeric characters — "${file}" is invalid`
-				);
-			}
-		}
-	}
-
-	return matchers;
+function resolve_params(config, cwd) {
+	const params_file = resolve_entry(config.kit.files.params);
+	return params_file ? posixify(path.relative(cwd, params_file)) : null;
 }
 
 /**
@@ -180,7 +142,7 @@ function create_routes_and_nodes(cwd, config, fallback) {
 				throw new Error(`Route ${id} should be renamed to ${id.replace(/#/g, '[x+23]')}`);
 			}
 
-			if (/\[\.\.\.\w+\]\/\[\[/.test(id)) {
+			if (/\[\.\.\.[\w-]+\]\/\[\[/.test(id)) {
 				throw new Error(
 					`Invalid route ${id} — an [[optional]] route segment cannot follow a [...rest] route segment`
 				);

package/src/core/sync/sync.js

@@ -2,7 +2,6 @@ import path from 'node:path';
 import process from 'node:process';
 import create_manifest_data from './create_manifest_data/index.js';
 import { write_client_manifest } from './write_client_manifest.js';
-import { write_root } from './write_root.js';
 import { write_tsconfig } from './write_tsconfig.js';
 import { write_types, write_all_types } from './write_types/index.js';
 import { write_ambient } from './write_ambient.js';
@@ -37,7 +36,6 @@ export function create(config, root) {
 
 	write_client_manifest(config.kit, manifest_data, `${output}/client`);
 	write_server(config, output, root);
-	write_root(manifest_data, config, output);
 	write_all_types(config, manifest_data, root);
 	write_non_ambient(config.kit, manifest_data);
 

package/src/core/sync/write_client_manifest.js

@@ -139,11 +139,6 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 	write_if_changed(
 		`${output}/app.js`,
 		dedent`
-			// in dev, this makes Vite inject its client as this module's first dependency,
-			// so that global constant replacements are installed before any other module
-			// (including user hooks) evaluates. In build it's inert.
-			import.meta.hot;
-
 			${
 				client_hooks_file
 					? `import * as client_hooks from '${relative_path(output, client_hooks_file)}';`
@@ -181,28 +176,19 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 
 			export const decode = (type, value) => decoders[type](value);
 
-			export { default as root } from '../root.js';
-
 			export const get_error_template = () => import('../shared/error-template.js').then(m => m.default);
 		`
 	);
 
 	if (client_routing) {
-		// write matchers to a separate module so that we don't
-		// need to worry about name conflicts
-		const imports = [];
-		const matchers = [];
-
-		for (const key in manifest_data.matchers) {
-			const src = manifest_data.matchers[key];
-
-			imports.push(`import { match as ${key} } from ${s(relative_path(output, src))};`);
-			matchers.push(key);
-		}
+		const uses_matchers = manifest_data.routes.some((route) =>
+			route.params.some((param) => param.matcher)
+		);
 
-		const module = imports.length
-			? `${imports.join('\n')}\n\nexport const matchers = { ${matchers.join(', ')} };`
-			: 'export const matchers = {};';
+		const module =
+			!manifest_data.params || !uses_matchers
+				? 'export const matchers = {};'
+				: `import { params as matchers } from ${s(relative_path(output, manifest_data.params))};\n\nexport { matchers };`;
 
 		write_if_changed(`${output}/matchers.js`, module);
 	}

package/src/core/sync/write_non_ambient.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { GENERATED_COMMENT } from '../../constants.js';
+import { resolve_entry } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
 import { write_if_changed } from './utils.js';
 import { s } from '../../utils/misc.js';
@@ -85,10 +86,6 @@ export {};
  * @param {import('types').ValidatedKitConfig} config
  */
 function generate_app_types(manifest_data, config) {
-	/** @param {string} matcher */
-	const path_to_matcher = (matcher) =>
-		posixify(path.relative(config.outDir, path.join(config.files.params, matcher + '.js')));
-
 	/** @type {Map<string, string>} */
 	const matcher_types = new Map();
 
@@ -98,7 +95,15 @@ function generate_app_types(manifest_data, config) {
 
 		let type = matcher_types.get(matcher);
 		if (!type) {
-			type = `MatcherParam<typeof import('${path_to_matcher(matcher)}').match>`;
+			const path_to_params = () => {
+				const params_file =
+					resolve_entry(config.files.params) ??
+					config.files.params.replace(/\.(js|ts)$/, '') + '.js';
+
+				return posixify(path.relative(config.outDir, params_file));
+			};
+
+			type = `import('@sveltejs/kit').MatcherParam<(typeof import('${path_to_params()}').params)[${JSON.stringify(matcher)}]>`;
 			matcher_types.set(matcher, type);
 		}
 
@@ -204,7 +209,7 @@ function generate_app_types(manifest_data, config) {
 		if (route.params.length > 0) {
 			const params = route.params.map((p) => {
 				const type = get_matcher_type(p.matcher);
-				return `${p.name}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
+				return `${/^\w+$/.test(p.name) ? p.name : `'${p.name}'`}${p.optional ? '?:' : ':'} ${type}${p.optional ? ' | undefined' : ''}`;
 			});
 			const route_type = `${s(route.id)}: { ${params.join('; ')} }`;
 
@@ -225,7 +230,7 @@ function generate_app_types(manifest_data, config) {
 			const params = Array.from(layout_params)
 				.map(([name, { optional, matchers }]) => {
 					const type = get_matchers_type(matchers);
-					return `${name}${optional ? '?:' : ':'} ${type}${optional ? ' | undefined' : ''}`;
+					return `${/^\w+$/.test(name) ? name : `'${name}'`}${optional ? '?:' : ':'} ${type}${optional ? ' | undefined' : ''}`;
 				})
 				.join('; ');
 
@@ -239,8 +244,6 @@ function generate_app_types(manifest_data, config) {
 
 	return [
 		'declare module "$app/types" {',
-		'\ttype MatcherParam<M> = M extends (param : string) => param is (infer U extends string) ? U : string;',
-		'',
 		'\texport interface AppTypes {',
 		`\t\tRouteId(): ${manifest_data.routes.map((r) => s(r.id)).join(' | ')};`,
 		`\t\tRouteParams(): {\n\t\t\t${dynamic_routes.join(';\n\t\t\t')}\n\t\t};`,

package/src/core/sync/write_server.js

@@ -24,7 +24,6 @@ const server_template = ({
 	has_service_worker,
 	template
 }) => `
-import root from '../root.js';
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
 import { set_manifest, set_read_implementation } from '__sveltekit/server';
@@ -32,7 +31,6 @@ import error from '../shared/error-template.js';
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
-	async: ${s(!!config.compilerOptions?.experimental?.async)},
 	csp: ${s(config.kit.csp)},
 	csrf_check_origin: ${s(!config.kit.csrf.trustedOrigins.includes('*'))},
 	csrf_trusted_origins: ${s(config.kit.csrf.trustedOrigins)},
@@ -41,10 +39,8 @@ export const options = {
 	hooks: null, // added lazily, via \`get_hooks\`
 	link_header_preload: ${s(config.kit.output.linkHeaderPreload)},
 	paths_origin: ${s(config.kit.paths.origin)},
-	root,
 	service_worker: ${has_service_worker},
 	service_worker_options: ${config.kit.serviceWorker.register ? s(config.kit.serviceWorker.options) : 'null'},
-	server_error_boundaries: ${s(!!config.kit.experimental.handleRenderingErrors)},
 	templates: {
 		app: ({ head, body, assets, nonce, env }) => ${s(template)
 			.replace('%sveltekit.head%', '" + head + "')

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';
-import { rimraf, walk } from '../../../utils/filesystem.js';
+import { rimraf, walk, resolve_entry } from '../../../utils/filesystem.js';
 import { compact } from '../../../utils/array.js';
 import { posixify } from '../../../utils/os.js';
 import { ts } from '../ts.js';
@@ -198,11 +198,6 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 	// Makes sure a type is "repackaged" and therefore more readable
 	declarations.push('type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;');
 
-	// returns the predicate of a matcher's type guard - or string if there is no type guard
-	declarations.push(
-		'type MatcherParam<M> = M extends (param : string) => param is (infer U extends string) ? U : string;'
-	);
-
 	declarations.push(
 		'type RouteParams = ' + generate_params_type(route.params, outdir, config) + ';'
 	);
@@ -236,7 +231,9 @@ function update_types(config, routes, route, root, to_delete = new Set()) {
 			'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>;',
+
+			'export type ErrorProps = { error: App.Error };'
 		);
 	}
 
@@ -268,15 +265,8 @@ function update_types(config, routes, route, root, 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>'
-			);
-			exports.push(
-				'export type Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>'
-			);
-		}
-
-		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 Actions<OutputData extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, OutputData, RouteId>',
 				'export type PageProps = { params: RouteParams; data: PageData; form: ActionData }'
 			);
 		} else {
@@ -604,16 +594,22 @@ function replace_ext_with_js(file_path) {
  * @param {import('types').ValidatedConfig} config
  */
 function generate_params_type(params, outdir, config) {
-	/** @param {string} matcher */
-	const path_to_matcher = (matcher) =>
-		posixify(path.relative(outdir, path.join(config.kit.files.params, matcher + '.js')));
+	const path_to_params = () => {
+		const params_file =
+			resolve_entry(config.kit.files.params) ??
+			config.kit.files.params.replace(/\.(js|ts)$/, '') + '.js';
+
+		return posixify(path.relative(outdir, params_file));
+	};
+
+	const params_import = path_to_params();
 
 	return `{ ${params
 		.map(
 			(param) =>
-				`${param.name}${param.optional ? '?' : ''}: ${
+				`${/^\w+$/.test(param.name) ? param.name : `'${param.name}'`}${param.optional ? '?' : ''}: ${
 					param.matcher
-						? `MatcherParam<typeof import('${path_to_matcher(param.matcher)}').match>`
+						? `import('@sveltejs/kit').MatcherParam<(typeof import('${params_import}').params)[${JSON.stringify(param.matcher)}]>`
 						: 'string'
 				}${param.optional ? ' | undefined' : ''}`
 		)
@@ -642,6 +638,16 @@ export function tweak_types(content, is_server) {
 		const code = new MagicString(content);
 
 		const exports = new Map();
+		/** @param {import('typescript').BindingName} name */
+		function add_export(name) {
+			if (ts.isIdentifier(name)) {
+				if (names.has(name.text)) exports.set(name.text, name.text);
+			} else {
+				for (const element of name.elements) {
+					if (ts.isBindingElement(element)) add_export(element.name);
+				}
+			}
+		}
 
 		ast.forEachChild((node) => {
 			if (
@@ -668,9 +674,7 @@ export function tweak_types(content, is_server) {
 
 				if (ts.isVariableStatement(node)) {
 					node.declarationList.declarations.forEach((declaration) => {
-						if (ts.isIdentifier(declaration.name) && names.has(declaration.name.text)) {
-							exports.set(declaration.name.text, declaration.name.text);
-						}
+						add_export(declaration.name);
 					});
 				}
 			}

package/src/core/utils.js

@@ -7,7 +7,7 @@ import { noop } from '../utils/functions.js';
 import { posixify } from '../utils/os.js';
 
 /**
- * Resolved path of the `runtime` directory
+ * Resolved path of the `runtime` directory posix-ified
  *
  * TODO Windows issue:
  * Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment.
@@ -25,7 +25,7 @@ export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', im
  */
 export function get_runtime_base(root) {
 	return runtime_directory.startsWith(root)
-		? `/${path.relative(root, runtime_directory)}`
+		? `/${posixify(path.relative(root, runtime_directory))}`
 		: to_fs(runtime_directory);
 }
 

package/src/exports/index.js

@@ -1,6 +1,5 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-
-import { HttpError, Redirect, ActionFailure, ValidationError } from './internal/index.js';
+import { HttpError, Redirect, ActionFailure, ValidationError } from './internal/shared.js';
 import { BROWSER, DEV } from 'esm-env';
 import {
 	add_data_suffix,
@@ -11,9 +10,10 @@ import {
 	strip_resolution_suffix
 } from '../runtime/pathname.js';
 import { text_encoder } from '../runtime/utils.js';
-import { validate_redirect_location } from '../utils/url.js';
+import { validate_redirect_location } from './url.js';
 
 export { VERSION } from '../version.js';
+export { defineParams } from './params.js';
 
 // Keep the status codes as `number` because restricting to certain numbers makes it unnecessarily hard to use compared to the benefits
 // (we have runtime errors already to check for invalid codes). Also see https://github.com/sveltejs/kit/issues/11780

package/src/exports/internal/client.js

@@ -0,0 +1,5 @@
+export function get_origin() {
+	return window.location.origin;
+}
+
+export * from './shared.js';

package/src/exports/internal/index.js

@@ -1,91 +1 @@
-/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-
-export class HttpError {
-	/**
-	 * @param {number} status
-	 * @param {Omit<App.Error, 'status'> | string | undefined} body
-	 * @param {Omit<App.Error, 'status' | 'message'>} [properties]
-	 */
-	constructor(status, body, properties) {
-		this.status = status;
-		if (typeof body === 'string') {
-			this.body = { ...properties, message: body, status };
-		} else if (body) {
-			this.body = { ...body, status };
-		} else {
-			this.body = { message: `Error: ${status}`, status };
-		}
-	}
-
-	toString() {
-		return JSON.stringify(this.body);
-	}
-}
-
-export class Redirect {
-	/**
-	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
-	 * @param {string} location
-	 */
-	constructor(status, location) {
-		try {
-			new Headers({ location });
-		} catch {
-			throw new Error(
-				`Invalid redirect location ${JSON.stringify(location)}: ` +
-					'this string contains characters that cannot be used in HTTP headers'
-			);
-		}
-
-		this.status = status;
-		this.location = location;
-	}
-}
-
-/**
- * An error that was thrown from within the SvelteKit runtime that is not fatal and doesn't result in a 500, such as a 404.
- * `SvelteKitError` goes through `handleError`.
- * @extends Error
- */
-export class SvelteKitError extends Error {
-	/**
-	 * @param {number} status
-	 * @param {string} text
-	 * @param {string} message
-	 */
-	constructor(status, text, message) {
-		super(message);
-		this.status = status;
-		this.text = text;
-	}
-}
-
-/**
- * @template [T=undefined]
- */
-export class ActionFailure {
-	/**
-	 * @param {number} status
-	 * @param {T} data
-	 */
-	constructor(status, data) {
-		this.status = status;
-		this.data = data;
-	}
-}
-
-/**
- * Error thrown when form validation fails imperatively
- */
-export class ValidationError extends Error {
-	/**
-	 * @param {StandardSchemaV1.Issue[]} issues
-	 */
-	constructor(issues) {
-		super('Validation failed');
-		this.name = 'ValidationError';
-		this.issues = issues;
-	}
-}
-
-export { init_remote_functions } from './remote-functions.js';
+export * from '#internal';

package/src/exports/internal/{event.js → server/event.js}

@@ -1,8 +1,7 @@
 /** @import { RequestEvent } from '@sveltejs/kit' */
 /** @import { RequestStore } from 'types' */
 /** @import { AsyncLocalStorage } from 'node:async_hooks' */
-
-import { IN_WEBCONTAINER } from '../../runtime/server/constants.js';
+import { IN_WEBCONTAINER } from '../../../runtime/server/constants.js';
 
 /** @type {RequestStore | null} */
 let sync_store = null;