Migrating to SvelteKit v3

npx sv migrate sveltekit-3

import { defineConfig(alias) function defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
 } from 'vite';
import { sveltekit(alias) function sveltekit(config?: Config): Promise<Plugin[]>
import sveltekit
The SvelteKit Vite plugin, which must be added to your vite.config.js file along with your project's configuration:
/// file: vite.config.js
import adapter from '@sveltejs/adapter-auto';
import { sveltekit } from '@sveltejs/kit/vite';
import { defineConfig } from 'vite';

export default defineConfig({
	plugins: [
		sveltekit({
			adapter: adapter(),
			compilerOptions: {
				experimental: {
					async: true
				}
			},
			experimental: {
				remoteFunctions: true
			}
		})
	]
});
As well as SvelteKit, the plugin options are used by other tooling that integrates with Svelte such as editor extensions.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte, so you can set options like inspector here too. The experimental namespace is shared — SvelteKit reads its own flags and forwards the rest.

[!LEGACY]
Prior to SvelteKit 3, config lived in a svelte.config.js file, which is no longer supported. The ability to configure SvelteKit via vite.config.js was added in version 2.62.

reference } from '@sveltejs/kit/vite';
import adapter(alias) function adapter(): Adapter
import adapter from '@sveltejs/adapter-auto';

export default defineConfig(alias) defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
({
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [
		sveltekit(alias) sveltekit(config?: Config): Promise<Plugin[]>
import sveltekit
The SvelteKit Vite plugin, which must be added to your vite.config.js file along with your project's configuration:
/// file: vite.config.js
import adapter from '@sveltejs/adapter-auto';
import { sveltekit } from '@sveltejs/kit/vite';
import { defineConfig } from 'vite';

export default defineConfig({
	plugins: [
		sveltekit({
			adapter: adapter(),
			compilerOptions: {
				experimental: {
					async: true
				}
			},
			experimental: {
				remoteFunctions: true
			}
		})
	]
});
As well as SvelteKit, the plugin options are used by other tooling that integrates with Svelte such as editor extensions.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte, so you can set options like inspector here too. The experimental namespace is shared — SvelteKit reads its own flags and forwards the rest.

[!LEGACY]
Prior to SvelteKit 3, config lived in a svelte.config.js file, which is no longer supported. The ability to configure SvelteKit via vite.config.js was added in version 2.62.

reference({
			compilerOptions(property) compilerOptions?: Omit<CompileOptions, "filename" | "format" | "generate"> | undefined
The options to be passed to the Svelte compiler. A few options are set by default,
including dev and css. However, some options are non-configurable, like
filename, format, generate, and cssHash (in dev).
https://svelte.dev/docs/svelte/svelte-compiler#CompileOptions
: { experimental(property) experimental?: {
    async?: boolean;
} | undefined
Experimental options
5.36
: { async(property) async?: boolean | undefined
Allow await keyword in deriveds, template expressions, and the top level of components
5.36
: true }},
			adapter(property) Config.adapter?: Adapter | undefined
Your adapter is run when executing vite build. It determines how the output is converted for different platforms.
undefined
: adapter(alias) adapter(): Adapter
import adapter()
		})
	]
});

{
	"imports": {
		"#lib": "./src/lib/index.js",
		"#lib/*": "./src/lib/*"
	}
}

import { foo } from '$lib/foo';
import { fooimport foo } from '#lib/foo.js';

// instead of this...
pushState('/foo', state);
replaceState('/bar', state);
// ...do this:goto(alias) goto(url: string | URL, opts?: GotoOptions): Promise<void>
import goto
Allows you to navigate programmatically to a given route, with control over details such as whether scroll and focus are reset
(as they would be with a regular navigation) or preserved.
Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) or the state change has been applied.
goto is intended for navigations to routes that belong to the app, and will reject if a route cannot be resolved.
For external URLs, use window.location = url to perform a full-page navigation instead of calling goto(url).reference
url 
Where to navigate to. Note that if you've set config.paths.base and the URL is root-relative, you need to prepend the base path if you want to navigate within the app.
opts 
Options related to the navigation
('/foo', { shallow(property) GotoOptions.shallow?: boolean | undefined
If true, updates the URL and page.state without navigating.
false
: true, state(property) GotoOptions.state?: App.PageState | undefined
An optional object that will be available as page.state.
 });
goto(alias) goto(url: string | URL, opts?: GotoOptions): Promise<void>
import goto
Allows you to navigate programmatically to a given route, with control over details such as whether scroll and focus are reset
(as they would be with a regular navigation) or preserved.
Returns a Promise that resolves when SvelteKit navigates (or fails to navigate, in which case the promise rejects) or the state change has been applied.
goto is intended for navigations to routes that belong to the app, and will reject if a route cannot be resolved.
For external URLs, use window.location = url to perform a full-page navigation instead of calling goto(url).reference
url 
Where to navigate to. Note that if you've set config.paths.base and the URL is root-relative, you need to prepend the base path if you want to navigate within the app.
opts 
Options related to the navigation
('/bar', { shallow(property) GotoOptions.shallow?: boolean | undefined
If true, updates the URL and page.state without navigating.
false
: true, replace(property) GotoOptions.replace?: boolean | undefined
If true, replaces the current history entry rather than creating a new one.
false
: true, state(property) GotoOptions.state?: App.PageState | undefined
An optional object that will be available as page.state.
 });

const resultconst result: ({
    type: "loaded";
    data: Record<string, any>;
} | {
    type: "redirect";
    location: string;
} | {
    type: "error";
    error: App.Error;
}) & {
    status: number;
} = await preloadData(alias) preloadData(href: string): Promise<({
    type: "loaded";
    data: Record<string, any>;
} | {
    type: "redirect";
    location: string;
} | {
    type: "error";
    error: App.Error;
}) & {
    status: number;
}>
import preloadData
Programmatically preloads the given page, which means

ensuring that the code for the page is loaded, and
calling the page's load function with the appropriate options.

This is the same behaviour that SvelteKit triggers when the user taps or mouses over an <a> element with data-sveltekit-preload-data.
If the next navigation is to href, the values returned from load will be used, making navigation instantaneous.
Returns a Promise that resolves with the result of running the new route's load functions once the preload is complete.
href 
Page to preload
reference(urlconst url: "/somewhere");

if (resultconst result: ({
    type: "loaded";
    data: Record<string, any>;
} | {
    type: "redirect";
    location: string;
} | {
    type: "error";
    error: App.Error;
}) & {
    status: number;
}.type(property) type: "loaded" | "redirect" | "error" === 'loaded') {
	// ...} else if (resultconst result: ({
    type: "redirect";
    location: string;
} & {
    status: number;
}) | ({
    type: "error";
    error: App.Error;
} & {
    status: number;
}).type(property) type: "redirect" | "error" === 'error') {
	// do something in case of an error
}

// instead of this...
const pathname = base + resolveRoute('/blog/[slug]', { slug });
const file = assets + '/foo.png';
// ...do this:const pathnameconst pathname: string = resolve(alias) resolve<"/blog/[slug]">(route: "/blog/[slug]", params: Record<string, string>): ResolvedPathname
import resolve
Resolve a pathname by prefixing it with the base path, if any, or resolve a route ID by populating dynamic segments with parameters.
In hash routing mode, the returned URL starts with #.
During server rendering, the base path is relative and depends on the page currently being rendered.reference
import { resolve } from '$app/paths';

// using a pathname
const resolved = resolve(`blog/hello-world`);

// using a route ID plus parameters
const resolved = resolve('/blog/[slug]', {
	slug: 'hello-world'
});
2.26
('/blog/[slug]', { slug(property) slug: string });
const fileconst file: string = asset(alias) asset(file: AssetPath): string
import asset
Resolve the URL of an asset in your static directory, by prefixing it with config.paths.assets if configured, or otherwise by prefixing it with the base path.
During server rendering, the base path is relative and depends on the page currently being rendered.reference
<script>
	import { asset } from '$app/paths';
</script>

<img alt="a potato" src={asset('potato.jpg')} />
2.26
('foo.png');

const urlconst url: URL = new URLvar URL: new (url: string | URL, base?: string | URL) => URL
The URL interface is used to parse, construct, normalize, and encode URLs. It works by providing properties which allow you to easily read and modify the components of a URL.
MDN Reference
URL class is a global reference for import { URL } from 'url'
https://nodejs.org/api/url.html#the-whatwg-url-api
v10.0.0
(pageany.urlany.hrefany);
urlconst url: URL.searchParams(property) URL.searchParams: URLSearchParams
The searchParams read-only property of the URL interface returns a URLSearchParams object allowing access to the GET decoded query arguments contained in the URL.
MDN Reference
.set(method) URLSearchParams.set(name: string, value: string): void
The set() method of the URLSearchParams interface sets the value associated with a given search parameter to the given value. If there were several matching values, this method deletes the others. If the search parameter doesn't exist, this method creates it.
MDN Reference
('q', 'svelte');

<script>
	import { page } from '$app/state';
</script>

<p>current pathname: {page.url.pathname}</p>

{
	"extends": "$app/tsconfig",
	"include": ["src", "test", "*"],
	"exclude": ["src/service-worker"]
}

{
	"extends": "$app/tsconfig/service-worker"
}

export default defineConfig(alias) defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
({
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [
		sveltekit(alias) sveltekit(config?: Config): Promise<Plugin[]>
import sveltekit
The SvelteKit Vite plugin, which must be added to your vite.config.js file along with your project's configuration:
/// file: vite.config.js
import adapter from '@sveltejs/adapter-auto';
import { sveltekit } from '@sveltejs/kit/vite';
import { defineConfig } from 'vite';

export default defineConfig({
	plugins: [
		sveltekit({
			adapter: adapter(),
			compilerOptions: {
				experimental: {
					async: true
				}
			},
			experimental: {
				remoteFunctions: true
			}
		})
	]
});
As well as SvelteKit, the plugin options are used by other tooling that integrates with Svelte such as editor extensions.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte, so you can set options like inspector here too. The experimental namespace is shared — SvelteKit reads its own flags and forwards the rest.

[!LEGACY]
Prior to SvelteKit 3, config lived in a svelte.config.js file, which is no longer supported. The ability to configure SvelteKit via vite.config.js was added in version 2.62.

reference({
			csrf(property) Config.csrf?: {
    checkOrigin?: boolean;
    trustedOrigins?: string[];
} | undefined
Protection against cross-site request forgery (CSRF) attacks.
: {
				checkOrigin: false
				trustedOrigins(property) trustedOrigins?: string[] | undefined
An array of origins that are allowed to make cross-origin form submissions to your app.
Each origin should be a complete origin including protocol (e.g., https://payment-gateway.com).
This is useful for allowing trusted third-party services like payment gateways or authentication providers to submit forms to your app.
If the array contains '*', all origins will be trusted. This is generally not recommended!

[!NOTE] Only add origins you completely trust, as this bypasses CSRF protection for those origins.

CSRF checks only apply in production, not in local development.
[]
['https://checkout.stripe.com', 'https://accounts.google.com']: ['https://trusted-site.com']
			}
		})
	]
});

export default defineConfig(alias) defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
({
	server(property) UserConfig.server?: ServerOptions$1 | undefined
Server specific options, e.g. host, port, https...
: {
		cors(property) CommonServerOptions.cors?: boolean | CorsOptions | undefined
Configure CORS for the dev server.
Uses https://github.com/expressjs/cors.
When enabling this option, we recommend setting a specific value
rather than true to avoid exposing the source code to untrusted origins.
Set to true to allow all methods from any origin, or configure separately
using an object.
false
: { origin(property) CorsOptions.origin?: CorsOrigin | ((origin: string | undefined, cb: (err: Error, origins: CorsOrigin) => void) => void) | undefined
Configures the Access-Control-Allow-Origin CORS header.
We recommend setting a specific value rather than
true to avoid exposing the source code to untrusted origins.
: '*' }
	}
});

cookiesconst cookies: Cookies.set(property) Cookies.set: (name: string, value: string, opts: SerializeOptions) => void
Sets a cookie. This will add a set-cookie header to the response, but also make the cookie available via cookies.get or cookies.getAll during the current request.
The httpOnly is true by default, as is secure, except during development, when it defaults to false. These must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP.
The path option is '/' by default. You can use relative paths, or set path: '' to make the cookie only available on the current path and its children.
name 
the name of the cookie
value 
the cookie value
opts 
the options passed to cookie.stringifySetCookie with the SvelteKit defaults described above. See documentation here
(nameconst name: string, valueconst value: string, { path(property) path?: string | undefined
Specifies the value for the Path Set-Cookie attribute.
When no path is set, the path is considered the "default path".
: '/some/path' });

import { defineParams(alias) function defineParams<T extends Record<string, ParamDefinition>>(definitions: T): DefinedParams<T>
import defineParams
Define parameter matchers for your app.
reference } from '@sveltejs/kit/params';
import * as vimport v from 'valibot';

export const paramsconst params: DefinedParams<{
    integer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]>;
    fruit: (param: string) => "apple" | "orange" | undefined;
}> = defineParams(alias) defineParams<{
    integer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]>;
    fruit: (param: string) => "apple" | "orange" | undefined;
}>(definitions: {
    integer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]>;
    fruit: (param: string) => "apple" | "orange" | undefined;
}): DefinedParams<{
    integer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]>;
    fruit: (param: string) => "apple" | "orange" | undefined;
}>
import defineParams
Define parameter matchers for your app.
reference({
	// schema variant	integer(property) integer: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]>: vimport v.pipe(alias) pipe<v.StringSchema<undefined>, v.ToNumberAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.ToNumberAction<string, undefined> | v.PipeAction<string, number, v.ToNumberIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.ToNumberAction<string, undefined>]> (+20 overloads)
export pipe
Adds a pipeline to a schema, that can validate and transform its input.
schema 
The root schema.
item1 
The first pipe item.
A schema with a pipeline.
(vimport v.string(alias) string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
A string schema.
(), vimport v.toNumber(alias) toNumber<string>(): v.ToNumberAction<string, undefined> (+1 overload)
export toNumber
Creates a to number transformation action.
A to number action.
()),
	// function variant	fruit(property) fruit: (param: string) => "apple" | "orange" | undefined: (param(parameter) param: string) => {
		if (param(parameter) param: string === 'apple' || param(parameter) param: string === 'orange') {
			return param(parameter) param: "apple" | "orange";
		}
	}
});

export default defineConfig(alias) defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
({
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [
		sveltekit(alias) sveltekit(config?: Config): Promise<Plugin[]>
import sveltekit
The SvelteKit Vite plugin, which must be added to your vite.config.js file along with your project's configuration:
/// file: vite.config.js
import adapter from '@sveltejs/adapter-auto';
import { sveltekit } from '@sveltejs/kit/vite';
import { defineConfig } from 'vite';

export default defineConfig({
	plugins: [
		sveltekit({
			adapter: adapter(),
			compilerOptions: {
				experimental: {
					async: true
				}
			},
			experimental: {
				remoteFunctions: true
			}
		})
	]
});
As well as SvelteKit, the plugin options are used by other tooling that integrates with Svelte such as editor extensions.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte, so you can set options like inspector here too. The experimental namespace is shared — SvelteKit reads its own flags and forwards the rest.

[!LEGACY]
Prior to SvelteKit 3, config lived in a svelte.config.js file, which is no longer supported. The ability to configure SvelteKit via vite.config.js was added in version 2.62.

reference({
			tracing(property) Config.tracing?: {
    server?: boolean;
} | undefined
Options for enabling OpenTelemetry tracing for SvelteKit operations.
{ server: false }
: { server(property) server?: boolean | undefined
Enables server-side OpenTelemetry span emission for SvelteKit operations including the handle hook, load functions, form actions, and remote functions. Tracing — and more significantly, observability instrumentation — can have a nontrivial overhead, so consider whether you really need it, or if it might be more appropriate to turn it on in development and preview environments only.
false
: true }
		})
	]
});

import { envimport env, waitUntilimport waitUntil } from 'cloudflare:workers';

const valueconst value: any = await envimport env.KVany.getany('key');

export async function GETfunction GET({ request }: {
    request: any;
}): Promise<void>({ request(parameter) request: any }) {
	const { countryconst country: any } = request(parameter) request: any.cfany;
}

const myCacheconst myCache: Cache = await cachesvar caches: CacheStorage
Available only in secure contexts.
MDN Reference
.open(method) CacheStorage.open(cacheName: string): Promise<Cache>
The open() method of the CacheStorage interface returns a Promise that resolves to the Cache object matching the cacheName.
MDN Reference
('foo');
await myCacheconst myCache: Cache.match(method) Cache.match(request: RequestInfo | URL, options?: CacheQueryOptions): Promise<Response | undefined>
The match() method of the Cache interface returns a Promise that resolves to the Response associated with the first matching request in the Cache object. If no match is found, the Promise resolves to undefined.
MDN Reference
(requestlet request: Request);

const initializerconst initializer: string = builderconst builder: Builder.createInstrumentationInitializer(property) Builder.createInstrumentationInitializer: (options: {
    outputDirectory: string;
    environment?: string;
    serverDirectory?: string;
}) => string
Generate an initializer that populates $env/dynamic/private before server instrumentation
runs. Include the returned module in any subsequent bundling or tracing step.
options 
an object containing the following properties:
options.outputDirectory 
the directory in which to create the initializer.
options.environment 
the contents of a module whose default export contains the platform's environment variables. If omitted, process.env is used.
options.serverDirectory 
the directory containing the server build output. Defaults to getServerDirectory().
the filesystem path to the generated initializer.
3.0.0
({ outputDirectory(property) outputDirectory: string: temporary_directoryconst temporary_directory: string });
// Include `initializer` in any bundling or file tracing here
builderconst builder: Builder.instrument(property) Builder.instrument: (args: {
    entrypoint: string;
    instrumentation: string;
    start?: string;
    initializer: string;
    module?: {
        exports: string[];
    } | {
        generateText: (args: {
            instrumentation: string;
            start: string;
            initializer: string;
        }) => string;
    };
}) => void
Instrument entrypoint with instrumentation.
Renames entrypoint to start and creates a new module at
entrypoint which imports instrumentation and then dynamically imports start. This allows
the module hooks necessary for instrumentation libraries to be loaded prior to any application code.
initializer is a module generated by createInstrumentationInitializer. It must be included
in any bundling or tracing step before calling this method.
Caveats:

"Live exports" will not work. If your adapter uses live exports, your users will need to manually import the server instrumentation on startup.
If tla is false, OTEL auto-instrumentation may not work properly. Use it if your environment supports it.
Use hasServerInstrumentationFile to check if the user has a server instrumentation file; if they don't, you shouldn't do this.

options 
an object containing the following properties:
options.entrypoint 
the path to the entrypoint to trace.
options.instrumentation 
the path to the instrumentation file.
options.start 
the name of the start file. This is what entrypoint will be renamed to.
options.initializer 
the filesystem path to the bundled or copied instrumentation initializer.
options.module 
configuration for the resulting entrypoint module.
options.module.generateText 
a function that receives the relative paths to the initializer, instrumentation and start files, and generates the text of the module to be traced. It must import initializer before instrumentation, and dynamically import start after instrumentation has run. If not provided, the default implementation will be used, which uses top-level await.
3.0.0
({
	entrypoint(property) entrypoint: string,
	instrumentation(property) instrumentation: string,
	initializer(property) initializer: string
});

const initializerconst initializer: string = builderconst builder: Builder.createInstrumentationInitializer(property) Builder.createInstrumentationInitializer: (options: {
    outputDirectory: string;
    environment?: string;
    serverDirectory?: string;
}) => string
Generate an initializer that populates $env/dynamic/private before server instrumentation
runs. Include the returned module in any subsequent bundling or tracing step.
options 
an object containing the following properties:
options.outputDirectory 
the directory in which to create the initializer.
options.environment 
the contents of a module whose default export contains the platform's environment variables. If omitted, process.env is used.
options.serverDirectory 
the directory containing the server build output. Defaults to getServerDirectory().
the filesystem path to the generated initializer.
3.0.0
({
	outputDirectory(property) outputDirectory: string: temporary_directoryconst temporary_directory: string,
	environment(property) environment?: string | undefined: `import { env } from 'cloudflare:workers';\nexport default env;`
});

export default defineConfig(alias) defineConfig(config: UserConfig): UserConfig (+5 overloads)
import defineConfig
Type helper to make it easier to use vite.config.ts
accepts a direct 
{@link 
UserConfig
}
 object, or a function that returns it.
The function receives a 
{@link 
ConfigEnv
}
 object.
({
	plugins(property) UserConfig.plugins?: PluginOption[] | undefined
Array of vite plugins to use.
: [
		sveltekit(alias) sveltekit(config?: Config): Promise<Plugin[]>
import sveltekit
The SvelteKit Vite plugin, which must be added to your vite.config.js file along with your project's configuration:
/// file: vite.config.js
import adapter from '@sveltejs/adapter-auto';
import { sveltekit } from '@sveltejs/kit/vite';
import { defineConfig } from 'vite';

export default defineConfig({
	plugins: [
		sveltekit({
			adapter: adapter(),
			compilerOptions: {
				experimental: {
					async: true
				}
			},
			experimental: {
				remoteFunctions: true
			}
		})
	]
});
As well as SvelteKit, the plugin options are used by other tooling that integrates with Svelte such as editor extensions.
Any options that don't belong to SvelteKit are passed through to vite-plugin-svelte, so you can set options like inspector here too. The experimental namespace is shared — SvelteKit reads its own flags and forwards the rest.

[!LEGACY]
Prior to SvelteKit 3, config lived in a svelte.config.js file, which is no longer supported. The ability to configure SvelteKit via vite.config.js was added in version 2.62.

reference({
			compilerOptions(property) compilerOptions?: Omit<CompileOptions, "filename" | "format" | "generate"> | undefined
The options to be passed to the Svelte compiler. A few options are set by default,
including dev and css. However, some options are non-configurable, like
filename, format, generate, and cssHash (in dev).
https://svelte.dev/docs/svelte/svelte-compiler#CompileOptions
: {
				experimental(property) experimental?: {
    async?: boolean;
} | undefined
Experimental options
5.36
: {
					async(property) async?: boolean | undefined
Allow await keyword in deriveds, template expressions, and the top level of components
5.36
: true
				}
			},
			experimental(property) Config.experimental?: (ExperimentalOptions & {
    remoteFunctions?: boolean;
    forkPreloads?: boolean;
}) | undefined
Experimental features. Here be dragons. These are not subject to semantic versioning, so breaking changes or removal can happen in any release.
: {
				remoteFunctions(property) remoteFunctions?: boolean | undefined
Whether to enable the experimental remote functions feature. This feature is not yet stable and may be changed or removed at any time.
false
: true
			}
		})
	]
});

<input {...myform.fields.message.as('text')}>

<a href="..." data-sveltekit-preload-data="off">
<a href="..." data-sveltekit-preload-data="false">

redirect(alias) redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL, options?: {
    external?: boolean | string[];
}): never
import redirect
Redirect a request. When called 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.
Most common status codes:

303 See Other: redirect as a GET request (often used after a form POST request)
307 Temporary Redirect: redirect will keep the request method
308 Permanent Redirect: redirect will keep the request method, SEO will be transferred to the new page

See all redirect status codes
status 
The HTTP status code. Must be in the range 300-308.
location 
The location to redirect to.
options 
To redirect to an external URL, you must pass { external: true } to allow any external URL except javascript: URLs, or { external: [...] } with an allowlist of permitted origins.
{import('./public.js').Redirect} This error instructs SvelteKit to redirect to the specified location.
{Error} If the provided status is invalid, the location cannot be used as a header value, or the location is an external URL without permission.
reference(307, 'https://example.com', { external(property) external?: boolean | string[] | undefined: true });