@sveltejs/kit 3.0.0-next.19 → 3.0.0-next.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "3.0.0-next.19",
+  "version": "3.0.0-next.20",
   "description": "SvelteKit is the fastest way to build Svelte apps",
   "keywords": [
     "framework",
@@ -19,30 +19,30 @@
   "type": "module",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "@sveltejs/acorn-typescript": "^1.0.10",
-    "acorn": "^8.17.0",
-    "cookie": "^2.0.0",
-    "devalue": "^5.8.1",
+    "@sveltejs/acorn-typescript": "^1.0.12",
+    "acorn": "^8.18.0",
+    "cookie": "^2.0.1",
+    "devalue": "^5.9.0",
     "esm-env": "^1.2.2",
-    "magic-string": "^0.30.21",
-    "mrmime": "^2.0.0",
+    "magic-string": "^1.1.0",
+    "mrmime": "^2.0.1",
     "sirv": "^3.0.2"
   },
   "devDependencies": {
-    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api": "^1.9.1",
     "@playwright/test": "^1.62.0",
-    "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@types/connect": "^3.4.38",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@types/node": "^22.19.19",
     "dts-buddy": "^0.8.3",
     "jsdom": "^30.0.0",
-    "rolldown": "^1.2.0",
-    "svelte": "^5.56.3",
+    "rolldown": "^1.2.3",
+    "svelte": "^5.56.8",
     "svelte-preprocess": "^6.0.5",
     "typescript": "~6.0.3",
     "valibot": "^1.4.2",
-    "vite": "^8.1.5",
+    "vite": "^8.2.1",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {

package/src/core/adapt/builder.js

@@ -1,7 +1,8 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 /** @import { Builder } from '@sveltejs/kit' */
 /** @import { ResolvedConfig } from 'vite' */
-/** @import { RouteDefinition, EnvVarConfig } from '@sveltejs/kit' */
+/** @import { RouteDefinition } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 /** @import { RouteData, ValidatedConfig, BuildData, ServerMetadata, ServerMetadataRoute, Prerendered, PrerenderMap, Logger, RemoteChunk } from 'types' */
 import { loadEnv } from 'vite';
 import * as devalue from 'devalue';

package/src/core/adapt/index.js

@@ -10,7 +10,7 @@ import { create_builder } from './builder.js';
  * @param {import('types').Logger} log
  * @param {import('types').RemoteChunk[]} remotes
  * @param {import('vite').ResolvedConfig} vite_config
- * @param {Record<string, import('@sveltejs/kit').EnvVarConfig<any>> | null} explicit_env_config
+ * @param {Record<string, import('@sveltejs/kit/env').EnvVarConfig<any>> | null} explicit_env_config
  */
 export async function adapt(
 	config,

package/src/core/env.js

@@ -1,5 +1,5 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 /** @import { ValidatedKitConfig } from 'types' */
 import path from 'node:path';
 import * as devalue from 'devalue';

package/src/core/postbuild/prerender.js

@@ -1,5 +1,7 @@
+import process from 'node:process';
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { clearLine, moveCursor } from 'node:readline';
 import { pathToFileURL } from 'node:url';
 import { walk } from '../../utils/filesystem.js';
 import { posixify } from '../../utils/os.js';
@@ -16,7 +18,6 @@ import * as devalue from 'devalue';
 import { createReadableStream } from '@sveltejs/kit/node';
 import generate_fallback from './fallback.js';
 import { stringify_remote_arg } from '../../runtime/shared.js';
-import { log_response } from '../../exports/vite/utils.js';
 import { matches_content_type } from '../../utils/http.js';
 
 export default forked(import.meta.url, prerender);
@@ -36,19 +37,30 @@ const SPECIAL_HASHLINKS = new Set(['', 'top']);
  *   verbose: boolean;
  *   env: Record<string, string>;
  *   vite_config_file: string | undefined;
+ *   is_tty: boolean | undefined;
  * }} opts
  */
-async function prerender({ hash, out, manifest_path, metadata, verbose, env, vite_config_file }) {
+async function prerender({
+	hash,
+	out,
+	manifest_path,
+	metadata,
+	verbose,
+	env,
+	vite_config_file,
+	is_tty
+}) {
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
 
 	/** @type {import('types').ServerInternalModule} */
-	const internal = await import(pathToFileURL(`${out}/server/internal.js`).href);
+	const { set_building, set_prerendering, set_manifest, set_read_implementation, log_response } =
+		await import(pathToFileURL(`${out}/server/internal.js`).href);
 
 	// configure `import { building } from `$app/env` —
 	// essential we do this before analysing the code
-	internal.set_building();
-	internal.set_prerendering();
+	set_building();
+	set_prerendering();
 
 	// `set_env` and `Server` live in modules that import the user's `src/env` config. We import them
 	// *after* `set_building()` so that `building`-dependent expressions resolve correctly
@@ -263,6 +275,45 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 	/** @type {Map<string, Promise<any>>} */
 	const remote_responses = new Map();
 
+	/** @type {(path: string) => void} */
+	let progress_line = noop;
+
+	if (is_tty) {
+		// Where possible, provide progress feedback by showing the path we're
+		// currently requesting, then clearing the line once the response comes in.
+		// This avoids the wall of text that happens when you prerender
+		// many pages and log each response
+		let current = false;
+		const stdout_write = process.stdout.write;
+		const stderr_write = process.stderr.write;
+
+		process.stdout.write = new Proxy(stdout_write, {
+			apply(target, this_arg, args) {
+				current = false;
+				return Reflect.apply(target, this_arg, args);
+			}
+		});
+
+		process.stderr.write = new Proxy(stderr_write, {
+			apply(target, this_arg, args) {
+				current = false;
+				return Reflect.apply(target, this_arg, args);
+			}
+		});
+
+		progress_line = (path) => {
+			// If app code writes to stdout or stderr, don't move the cursor to clear
+			// the previous progress log, because that will corrupt things
+			if (current) {
+				moveCursor(process.stdout, 0, -1);
+				clearLine(process.stdout, 0);
+			}
+
+			stdout_write.call(process.stdout, `rendering ${path}...\n`);
+			current = true;
+		};
+	}
+
 	/** @type {Set<string>} */
 	const resolved_route_ids = new Set();
 
@@ -303,6 +354,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 		/** @type {Map<string, import('types').PrerenderDependency>} */
 		const dependencies = new Map();
 
+		progress_line(decoded);
+
 		const request = new Request(prerender_origin + encoded);
 
 		const response = await server.respond(request, {
@@ -344,7 +397,7 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 			});
 		}
 
-		if (response.status !== 204) {
+		if (response.status >= 400) {
 			log_response(response.status, request);
 		}
 
@@ -574,8 +627,8 @@ async function prerender({ hash, out, manifest_path, metadata, verbose, env, vit
 
 	// the user's remote function modules may reference `read` or the `manifest` at the top-level
 	// so we need to set them before evaluating those modules to avoid potential runtime errors
-	internal.set_manifest(manifest);
-	internal.set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
+	set_manifest(manifest);
+	set_read_implementation((file) => createReadableStream(`${out}/server/${file}`));
 
 	/** @type {Array<import('types').RemotePrerenderInternals>} */
 	const prerender_functions = [];

package/src/core/sync/write_env.js

@@ -1,4 +1,4 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 import path from 'node:path';
 import { create_explicit_env_types } from '../env.js';
 import { write_if_changed } from './utils.js';

package/src/core/sync/write_server.js

@@ -25,7 +25,7 @@ const server_template = ({
 }) => `
 import { set_building, set_prerendering } from '$app/env/internal';
 import { set_assets } from '$app/paths/internal/server';
-import { set_fix_stack_trace, set_manifest, set_read_implementation } from '__sveltekit/server';
+import { set_fix_stack_trace, set_manifest, set_read_implementation, log_response } from '__sveltekit/server';
 import error from '../shared/error-template.js';
 
 export const options = {
@@ -78,7 +78,7 @@ export async function get_hooks() {
 	};
 }
 
-export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation };
+export { set_assets, set_building, set_fix_stack_trace, set_manifest, set_prerendering, set_read_implementation, log_response };
 `;
 
 /**

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

@@ -6,7 +6,6 @@ import { styleText } from 'node:util';
 import { write_if_changed } from '../utils.js';
 import {
 	ESSENTIAL_OPTIONS,
-	get_subpath_imports,
 	normalize_config,
 	RECOMMENDED_OPTIONS,
 	remove_trailing_slashstar
@@ -243,8 +242,7 @@ const alias_value = /^(.+?)((\/\*)|(\.\w+))?$/;
  */
 function get_paths(config, root) {
 	const alias = {
-		...config.alias,
-		...get_subpath_imports(root)
+		...config.alias
 	};
 
 	/** @type {Record<string, string[]>} */

package/src/core/sync/write_tsconfig/utils.js

@@ -1,5 +1,4 @@
 import path from 'node:path';
-import { normalize_import_value, read_package_imports } from '../../../utils/imports.js';
 import { posixify } from '../../../utils/os.js';
 
 /**
@@ -76,26 +75,3 @@ export function remove_trailing_slashstar(file) {
 		return file;
 	}
 }
-
-/**
- * @param {string} root
- */
-export function get_subpath_imports(root) {
-	// Add all `#`-prefixed imports from package.json as path aliases
-	const imports = read_package_imports(root);
-
-	/** @type {Record<string, string>} */
-	const alias = {};
-
-	if (imports) {
-		for (const [key, raw_value] of Object.entries(imports)) {
-			if (!key.startsWith('#')) continue;
-			const value = normalize_import_value(raw_value);
-			if (value) {
-				alias[key] = value;
-			}
-		}
-	}
-
-	return alias;
-}

package/src/exports/env/index.js

@@ -1,5 +1,5 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-/** @import { DefinedEnvVars, EnvVarConfig } from '@sveltejs/kit' */
+/** @import { DefinedEnvVars, EnvVarConfig } from '@sveltejs/kit/env' */
 
 /**
  * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),

package/src/exports/env/public.d.ts

@@ -0,0 +1,55 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+export * from './index.js';
+
+/**
+ * [Environment variables](https://svelte.dev/docs/kit/environment-variables) can be configured by exporting
+ * a `variables` object from `src/env.ts`, using [`defineEnvVars`](https://svelte.dev/docs/kit/@sveltejs-kit-env#defineEnvVars).
+ */
+export interface EnvVarConfig<T> {
+	/**
+	 * Whether the environment variable can be accessed by client-side code.
+	 * - if `true`, it can be imported from `$app/env/public`
+	 * - if `false`, it can be imported from `$app/env/private`, which is a [server-only module](https://svelte.dev/docs/kit/server-only-modules)
+	 * @default false
+	 */
+	public?: boolean;
+	/**
+	 * Whether the value is determined at build time or when the app runs.
+	 * - if `true`, the build time value is inlined into the bundle. This enables optimisations like dead-code elimination
+	 * - if `false`, the value is read from the environment when the app starts
+	 * @default false
+	 */
+	static?: boolean;
+	/**
+	 * A [Standard Schema](https://standardschema.dev/) validator that is applied to the value when the app starts.
+	 * Alternatively, a function that returns the (possibly transformed) value, or throws an error explaining
+	 * the problem. Returning `undefined` is valid, so a function can describe an optional variable.
+	 * The validator can output any value — not necessarily a string — but public, non-static values must be
+	 * serializable by [devalue](https://github.com/sveltejs/devalue) so that they can be sent to the browser.
+	 *
+	 * If omitted, the value must be set, but may be an empty string.
+	 */
+	schema?: StandardSchemaV1<string | undefined, T> | ((value: string | undefined) => T | undefined);
+	/**
+	 * A description of the variable that will be used for inline documentation on hover.
+	 */
+	description?: string;
+}
+
+/**
+ * The return type of [`defineEnvVars`](https://svelte.dev/docs/kit/@sveltejs-kit-env#defineEnvVars).
+ */
+export type DefinedEnvVars<T extends Record<string, EnvVarConfig<any>>> = {
+	readonly [K in keyof T]: EnvVarEntry<T[K]>;
+};
+
+/**
+ * Normalizes an environment variable config's schema (standard schema or function) to standard schema.
+ */
+type EnvVarEntry<C extends EnvVarConfig<any>> =
+	C['schema'] extends StandardSchemaV1<any, any>
+		? C
+		: C['schema'] extends (value: any) => infer R
+			? Omit<C, 'schema'> & { schema: StandardSchemaV1<string | undefined, R> }
+			: C;

package/src/exports/hooks/public.d.ts

@@ -0,0 +1,194 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { NavigationEvent, RequestEvent } from '@sveltejs/kit';
+import { MaybePromise } from 'types';
+
+export * from './index.js';
+
+/**
+ * The [`handle`](https://svelte.dev/docs/kit/hooks#handle) hook runs every time the SvelteKit server receives a [request](https://svelte.dev/docs/kit/web-standards#Fetch-APIs-Request) and
+ * determines the [response](https://svelte.dev/docs/kit/web-standards#Fetch-APIs-Response).
+ * It receives an `event` object representing the request and a function called `resolve`, which renders the route and generates a `Response`.
+ * This allows you to modify response headers or bodies, or bypass SvelteKit entirely (for implementing routes programmatically, for example).
+ */
+export type Handle = (input: {
+	event: RequestEvent;
+	resolve: (event: RequestEvent, opts?: ResolveOptions) => Promise<Response>;
+}) => MaybePromise<Response>;
+
+type CaughtErrorMap = {
+	app: App.Error;
+	framework: { status: number; message: string };
+	unknown: unknown;
+};
+
+type ValidationCaughtError<Issue extends StandardSchemaV1.Issue> = {
+	kind: 'validation';
+	error: { status: number; message: string };
+	issues: Issue[];
+};
+
+/**
+ * The error passed to the [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hooks.
+ * Use the `kind` discriminant to distinguish errors from your app (thrown with the
+ * [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper), errors generated by
+ * SvelteKit itself (such as 404s), validation errors, and unknown errors (thrown by your code,
+ * or code it calls).
+ */
+export type CaughtError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> =
+	| {
+			[Kind in keyof CaughtErrorMap]: {
+				/** Identifies the category and origin of the error */
+				kind: Kind;
+				/** The caught error. Its type depends on `kind` */
+				error: CaughtErrorMap[Kind];
+				/** Only present for validation errors */
+				issues?: undefined;
+			};
+	  }[keyof CaughtErrorMap]
+	| ValidationCaughtError<Issue>;
+
+/** The error passed to the client-side `handleError` hook. */
+export type ClientCaughtError = Exclude<CaughtError, { kind: 'validation' }>;
+
+/**
+ * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while responding to a request, except redirects.
+ *
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s), _validation_ errors (caused by invalid remote function arguments)
+ * and _unknown_ errors (thrown by your code, or code it calls).
+ *
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework and validation errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+ *
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleServerError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (
+	input: CaughtError<Issue> & { event: RequestEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
+
+/**
+ * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs for every error thrown while navigating, except redirects.
+ * Errors that were already transformed by the server-side hook are not passed to it a second time.
+ *
+ * The `kind` property discriminates between _app_ errors (thrown with the [`error`](https://svelte.dev/docs/kit/errors#App-errors) helper),
+ * _framework_ errors (generated by SvelteKit itself, such as 404s) and _unknown_ errors (thrown by your code, or code it calls).
+ *
+ * The hook returns an object matching `App.Error`, in which `status` and `message` are optional — return them only to
+ * override the defaults. Omitted properties are inherited from the caught error: the body passed to `error(...)` for app errors,
+ * the status and safe message for framework errors, and `500`/`'Internal Error'` for unknown errors. Return nothing to
+ * keep the defaults entirely (if you augment `App.Error` with required properties, you must return those).
+ *
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleClientError = (
+	input: ClientCaughtError & { event: NavigationEvent }
+) => MaybePromise<AppErrorWithOptionalDefaults | VoidIfNoRequiredAppErrorProperties>;
+
+/**
+ * The [`handleFetch`](https://svelte.dev/docs/kit/hooks#handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](https://svelte.dev/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.
+ */
+export type HandleFetch = (input: {
+	event: RequestEvent;
+	request: Request;
+	fetch: typeof fetch;
+}) => MaybePromise<Response>;
+
+/**
+ * The [`init`](https://svelte.dev/docs/kit/hooks#init) will be invoked before the server responds to its first request
+ * @since 2.10.0
+ */
+export type ServerInit = () => MaybePromise<void>;
+
+/**
+ * The [`init`](https://svelte.dev/docs/kit/hooks#init) will be invoked once the app starts in the browser
+ * @since 2.10.0
+ */
+export type ClientInit = () => MaybePromise<void>;
+
+/**
+ * The [`reroute`](https://svelte.dev/docs/kit/hooks#reroute) hook allows you to modify the URL before it is used to determine which route to render.
+ * @since 2.3.0
+ */
+export type Reroute = (event: { url: URL; fetch: typeof fetch }) => MaybePromise<void | string>;
+
+/**
+ * The [`transport`](https://svelte.dev/docs/kit/hooks#transport) hook allows you to transport custom types across the server/client boundary.
+ *
+ * Each transporter has a pair of `encode` and `decode` functions. On the server, `encode` determines whether a value is an instance of the custom type and, if so, returns a non-falsy encoding of the value which can be an object or an array (or `false` otherwise).
+ *
+ * In the browser, `decode` turns the encoding back into an instance of the custom type.
+ *
+ * ```ts
+ * import type { Transport } from '@sveltejs/kit/hooks';
+ *
+ * declare class MyCustomType {
+ * 	data: any
+ * }
+ *
+ * // hooks.js
+ * export const transport: Transport = {
+ * 	MyCustomType: {
+ * 		encode: (value) => value instanceof MyCustomType && [value.data],
+ * 		decode: ([data]) => new MyCustomType(data)
+ * 	}
+ * };
+ * ```
+ * @since 2.11.0
+ */
+export type Transport = Record<string, Transporter>;
+
+/**
+ * A member of the [`transport`](https://svelte.dev/docs/kit/hooks#transport) hook.
+ */
+export interface Transporter<
+	T = any,
+	U = any /* minus falsy values, but we can't properly express that */
+> {
+	encode: (value: T) => false | U;
+	decode: (data: U) => T;
+}
+
+export interface ResolveOptions {
+	/**
+	 * Applies custom transforms to HTML. If `done` is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML
+	 * (they could include an element's opening tag but not its closing tag, for example)
+	 * but they will always be split at sensible boundaries such as `%sveltekit.head%` or layout/page components.
+	 * @param input the html chunk and the info if this is the last chunk
+	 */
+	transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise<string | undefined>;
+	/**
+	 * Determines which headers should be included in serialized responses when a `load` function loads a resource with `fetch`.
+	 * By default, none will be included.
+	 * @param name header name
+	 * @param value header value
+	 */
+	filterSerializedResponseHeaders?: (name: string, value: string) => boolean;
+	/**
+	 * Determines which files should be preloaded. Files are preloaded via `<link>` tags added to the
+	 * `<head>` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the
+	 * [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead.
+	 * By default, `js` and `css` files will be preloaded.
+	 * @param input the type of the file and its path
+	 */
+	preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean;
+}
+
+type AppErrorWithOptionalDefaults = Omit<App.Error, 'status' | 'message'> & {
+	status?: App.Error['status'];
+	message?: App.Error['message'];
+};
+
+/**
+ * `void` is only a valid `handleError` return when `App.Error` adds no required properties
+ * beyond `status` and `message` — both of which are optional in the return, since they default
+ * to those of the caught error. If `App.Error` is augmented with required properties, the hook
+ * must return them, so returning nothing becomes a type error.
+ */
+type VoidIfNoRequiredAppErrorProperties = {
+	status: number;
+	message: string;
+} extends App.Error
+	? void
+	: never;

package/src/exports/hooks/sequence.js

@@ -1,4 +1,5 @@
-/** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { Handle, ResolveOptions } from '@sveltejs/kit/hooks' */
 import {
 	merge_tracing,
 	get_request_store,
@@ -17,7 +18,7 @@ import {
  * /// file: src/hooks.server.js
  * import { sequence } from '@sveltejs/kit/hooks';
  *
- * /// type: import('@sveltejs/kit').Handle
+ * /// type: import('@sveltejs/kit/hooks').Handle
  * async function first({ event, resolve }) {
  * 	console.log('first pre-processing');
  * 	const result = await resolve(event, {
@@ -36,7 +37,7 @@ import {
  * 	return result;
  * }
  *
- * /// type: import('@sveltejs/kit').Handle
+ * /// type: import('@sveltejs/kit/hooks').Handle
  * async function second({ event, resolve }) {
  * 	console.log('second pre-processing');
  * 	const result = await resolve(event, {

package/src/exports/index.js

@@ -273,7 +273,7 @@ export function invalid(...issues) {
 /**
  * Checks whether this is an validation error thrown by {@link invalid}.
  * @param {unknown} e The object to check.
- * @return {e is import('./public.js').ActionFailure}
+ * @return {e is import('$app/server').ValidationError}
  * @since 2.47.3
  */
 export function isValidationError(e) {

package/src/exports/internal/env.js

@@ -1,5 +1,5 @@
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { EnvVarConfig } from '@sveltejs/kit/env' */
 
 import { stackless } from '../../utils/error.js';
 

package/src/exports/params/public.d.ts

@@ -11,14 +11,14 @@ export type ParamMatcher<Output = any> = StandardSchemaV1<string, Output>;
 export type ParamValue = string | number | boolean | bigint;
 
 /**
- * A param matcher definition passed to [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
+ * A param matcher definition passed to [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit-params#defineParams).
  */
 export type ParamDefinition =
 	| ((param: string) => ParamValue | undefined)
 	| StandardSchemaV1<string, ParamValue>;
 
 /**
- * The return type of [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit#defineParams).
+ * The return type of [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit-params#defineParams).
  */
 export type DefinedParams<T extends Record<string, ParamDefinition>> = {
 	readonly [K in keyof T]: ParamEntry<T[K]>;