+ We recommend building UIs with a
+
+ component-driven
+
+ process starting with atomic components and ending with pages.
+
+
+ Render pages with mock data. This makes it easy to build and review page states without
+ needing to navigate to them in your app. Here are some handy patterns for managing page data
+ in Storybook:
+
+
+
+ Use a higher-level connected component. Storybook helps you compose such data from the
+ "args" of child component stories
+
+
+ Assemble data in the page component from your services. You can mock these services out
+ using Storybook.
+
+
+
+ Get a guided tutorial on component-driven development at
+
+ Storybook tutorials
+
+ . Read more in the
+ docs
+ .
+
+
+ Tip
+ Adjust the width of the canvas with the
+
+ Viewports addon in the toolbar
+
+ We recommend building UIs with a
+
+ component-driven
+
+ process starting with atomic components and ending with pages.
+
+
+ Render pages with mock data. This makes it easy to build and review page states without
+ needing to navigate to them in your app. Here are some handy patterns for managing page data
+ in Storybook:
+
+
+
+ Use a higher-level connected component. Storybook helps you compose such data from the
+ "args" of child component stories
+
+
+ Assemble data in the page component from your services. You can mock these services out
+ using Storybook.
+
+
+
+ Get a guided tutorial on component-driven development at
+
+ Storybook tutorials
+
+ . Read more in the
+ docs
+ .
+
+
+ Tip
+ Adjust the width of the canvas with the
+
+ Viewports addon in the toolbar
+
+ We recommend building UIs with a
+
+ component-driven
+
+ process starting with atomic components and ending with pages.
+
+
+ Render pages with mock data. This makes it easy to build and review page states without
+ needing to navigate to them in your app. Here are some handy patterns for managing page data
+ in Storybook:
+
+
+
+ Use a higher-level connected component. Storybook helps you compose such data from the
+ "args" of child component stories
+
+
+ Assemble data in the page component from your services. You can mock these services out
+ using Storybook.
+
+
+
+ Get a guided tutorial on component-driven development at
+
+ Storybook tutorials
+
+ . Read more in the
+ docs
+ .
+
+
+ Tip
+ Adjust the width of the canvas with the
+
+ Viewports addon in the toolbar
+
+ We recommend building UIs with a
+
+ component-driven
+
+ process starting with atomic components and ending with pages.
+
+
+ Render pages with mock data. This makes it easy to build and review page states without
+ needing to navigate to them in your app. Here are some handy patterns for managing page data
+ in Storybook:
+
+
+
+ Use a higher-level connected component. Storybook helps you compose such data from the
+ "args" of child component stories
+
+
+ Assemble data in the page component from your services. You can mock these services out
+ using Storybook.
+
+
+
+ Get a guided tutorial on component-driven development at
+
+ Storybook tutorials
+
+ . Read more in the
+ docs
+ .
+
+
+ Tip
+ Adjust the width of the canvas with the
+
+ Viewports addon in the toolbar
+
+ {/if}
+ `
+ );
+
+ if (isSvelte5Plus()) {
+ write_if_changed(
+ `${output}/root.js`,
+ dedent`
+ import { asClassComponent } from 'svelte/legacy';
+ import Root from './root.svelte';
+ export default asClassComponent(Root);
+ `
+ );
+ }
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_server.js b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_server.js
new file mode 100644
index 0000000000000000000000000000000000000000..764783f11f875ebf957e10f8b3f51607ee7e44dc
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_server.js
@@ -0,0 +1,146 @@
+import path from 'node:path';
+import process from 'node:process';
+import { hash } from '../../utils/hash.js';
+import { posixify, resolve_entry } from '../../utils/filesystem.js';
+import { s } from '../../utils/misc.js';
+import { load_error_page, load_template } from '../config/index.js';
+import { runtime_directory } from '../utils.js';
+import { isSvelte5Plus, write_if_changed } from './utils.js';
+import colors from 'kleur';
+import { escape_html } from '../../utils/escape.js';
+
+/**
+ * @param {{
+ * server_hooks: string | null;
+ * universal_hooks: string | null;
+ * config: import('types').ValidatedConfig;
+ * has_service_worker: boolean;
+ * runtime_directory: string;
+ * template: string;
+ * }} opts
+ */
+const server_template = ({
+ config,
+ server_hooks,
+ universal_hooks,
+ has_service_worker,
+ runtime_directory,
+ template
+}) => `
+import root from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';
+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';
+import { set_private_env, set_public_env } from '${runtime_directory}/shared-server.js';
+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.checkOrigin && !config.kit.csrf.trustedOrigins.includes('*'))},
+ csrf_trusted_origins: ${s(config.kit.csrf.trustedOrigins)},
+ embedded: ${config.kit.embedded},
+ env_public_prefix: '${config.kit.env.publicPrefix}',
+ env_private_prefix: '${config.kit.env.privatePrefix}',
+ hash_routing: ${s(config.kit.router.type === 'hash')},
+ hooks: null, // added lazily, via \`get_hooks\`
+ preload_strategy: ${s(config.kit.output.preloadStrategy)},
+ 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 + "')
+ .replace('%sveltekit.body%', '" + body + "')
+ .replace(/%sveltekit\.assets%/g, '" + assets + "')
+ .replace(/%sveltekit\.nonce%/g, '" + nonce + "')
+ .replace(/%sveltekit\.version%/g, escape_html(config.kit.version.name))
+ .replace(
+ /%sveltekit\.env\.([^%]+)%/g,
+ (_match, capture) => `" + (env[${s(capture)}] ?? "") + "`
+ )},
+ error
+ },
+ version_hash: ${s(hash(config.kit.version.name))}
+};
+
+export async function get_hooks() {
+ let handle;
+ let handleFetch;
+ let handleError;
+ let handleValidationError;
+ let init;
+ ${server_hooks ? `({ handle, handleFetch, handleError, handleValidationError, init } = await import(${s(server_hooks)}));` : ''}
+
+ let reroute;
+ let transport;
+ ${universal_hooks ? `({ reroute, transport } = await import(${s(universal_hooks)}));` : ''}
+
+ return {
+ handle,
+ handleFetch,
+ handleError,
+ handleValidationError,
+ init,
+ reroute,
+ transport
+ };
+}
+
+export { set_assets, set_building, set_manifest, set_prerendering, set_private_env, set_public_env, set_read_implementation };
+`;
+
+// TODO need to re-run this whenever src/app.html or src/error.html are
+// created or changed, or src/service-worker.js is created or deleted.
+// Also, need to check that updating hooks.server.js works
+
+/**
+ * Write server configuration to disk
+ * @param {import('types').ValidatedConfig} config
+ * @param {string} output
+ */
+export function write_server(config, output) {
+ const server_hooks_file = resolve_entry(config.kit.files.hooks.server);
+ const universal_hooks_file = resolve_entry(config.kit.files.hooks.universal);
+
+ const typo = resolve_entry('src/+hooks.server');
+ if (typo) {
+ console.log(
+ colors
+ .bold()
+ .yellow(
+ `Unexpected + prefix. Did you mean ${typo.split('/').at(-1)?.slice(1)}?` +
+ ` at ${path.resolve(typo)}`
+ )
+ );
+ }
+
+ /** @param {string} file */
+ function relative(file) {
+ return posixify(path.relative(`${output}/server`, file));
+ }
+
+ write_if_changed(
+ `${output}/shared/error-template.js`,
+ `export default ({ status, message }) => ${s(load_error_page(config))
+ .replace(/%sveltekit\.status%/g, '" + status + "')
+ .replace(/%sveltekit\.error\.message%/g, '" + message + "')};`
+ );
+
+ // Contains the stringified version of
+ /** @type {import('types').SSROptions} */
+ write_if_changed(
+ `${output}/server/internal.js`,
+ server_template({
+ config,
+ server_hooks: server_hooks_file ? relative(server_hooks_file) : null,
+ universal_hooks: universal_hooks_file ? relative(universal_hooks_file) : null,
+ has_service_worker:
+ config.kit.serviceWorker.register && !!resolve_entry(config.kit.files.serviceWorker),
+ runtime_directory: relative(runtime_directory),
+ template: load_template(process.cwd(), config)
+ })
+ );
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_tsconfig.js b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_tsconfig.js
new file mode 100644
index 0000000000000000000000000000000000000000..a6f8a25102b05aed1e5d3678476f272781ca4f60
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_tsconfig.js
@@ -0,0 +1,245 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import colors from 'kleur';
+import { posixify } from '../../utils/filesystem.js';
+import { write_if_changed } from './utils.js';
+
+/**
+ * @param {string} cwd
+ * @param {string} file
+ */
+function maybe_file(cwd, file) {
+ const resolved = path.resolve(cwd, file);
+ if (fs.existsSync(resolved)) {
+ return resolved;
+ }
+}
+
+/**
+ * @param {string} file
+ */
+function project_relative(file) {
+ return posixify(path.relative('.', file));
+}
+
+/**
+ * @param {string} file
+ */
+function remove_trailing_slashstar(file) {
+ if (file.endsWith('/*')) {
+ return file.slice(0, -2);
+ } else {
+ return file;
+ }
+}
+
+/**
+ * Generates the tsconfig that the user's tsconfig inherits from.
+ * @param {import('types').ValidatedKitConfig} kit
+ */
+export function write_tsconfig(kit, cwd = process.cwd()) {
+ const out = path.join(kit.outDir, 'tsconfig.json');
+
+ const user_config = load_user_tsconfig(cwd);
+ if (user_config) validate_user_config(cwd, out, user_config);
+
+ write_if_changed(out, JSON.stringify(get_tsconfig(kit), null, '\t'));
+}
+
+/**
+ * Generates the tsconfig that the user's tsconfig inherits from.
+ * @param {import('types').ValidatedKitConfig} kit
+ */
+export function get_tsconfig(kit) {
+ /** @param {string} file */
+ const config_relative = (file) => posixify(path.relative(kit.outDir, file));
+
+ const include = new Set([
+ 'ambient.d.ts', // careful: changing this name would be a breaking change, because it's referenced in the service-workers documentation
+ 'env.d.ts',
+ 'non-ambient.d.ts',
+ './types/**/$types.d.ts',
+ config_relative('vite.config.js'),
+ config_relative('vite.config.ts')
+ ]);
+ const src_includes = [kit.files.routes, kit.files.lib, kit.files.src].filter((dir) => {
+ const relative = path.relative(kit.files.src, dir);
+ return !relative || relative.startsWith('..');
+ });
+ for (const dir of src_includes) {
+ include.add(config_relative(`${dir}/**/*.js`));
+ include.add(config_relative(`${dir}/**/*.ts`));
+ include.add(config_relative(`${dir}/**/*.svelte`));
+ }
+
+ // Test folder is a special case - we advocate putting tests in a top-level test folder
+ // and it's not configurable (should we make it?)
+ const test_folder = project_relative('test');
+ include.add(config_relative(`${test_folder}/**/*.js`));
+ include.add(config_relative(`${test_folder}/**/*.ts`));
+ include.add(config_relative(`${test_folder}/**/*.svelte`));
+ const tests_folder = project_relative('tests');
+ include.add(config_relative(`${tests_folder}/**/*.js`));
+ include.add(config_relative(`${tests_folder}/**/*.ts`));
+ include.add(config_relative(`${tests_folder}/**/*.svelte`));
+
+ const exclude = [config_relative('node_modules/**')];
+ // Add service worker to exclude list so that worker types references in it don't spill over into the rest of the app
+ // (i.e. suddenly ServiceWorkerGlobalScope would be available throughout the app, and some types might even clash)
+ if (path.extname(kit.files.serviceWorker)) {
+ exclude.push(config_relative(kit.files.serviceWorker));
+ } else {
+ exclude.push(config_relative(`${kit.files.serviceWorker}.js`));
+ exclude.push(config_relative(`${kit.files.serviceWorker}/**/*.js`));
+ exclude.push(config_relative(`${kit.files.serviceWorker}.ts`));
+ exclude.push(config_relative(`${kit.files.serviceWorker}/**/*.ts`));
+ exclude.push(config_relative(`${kit.files.serviceWorker}.d.ts`));
+ exclude.push(config_relative(`${kit.files.serviceWorker}/**/*.d.ts`));
+ }
+
+ const config = {
+ compilerOptions: {
+ // generated options
+ paths: {
+ ...get_tsconfig_paths(kit),
+ '$app/types': ['./types/index.d.ts']
+ },
+ rootDirs: [config_relative('.'), './types'],
+
+ // essential options
+ // svelte-preprocess cannot figure out whether you have a value or a type, so tell TypeScript
+ // to enforce using \`import type\` instead of \`import\` for Types.
+ // Also, TypeScript doesn't know about import usages in the template because it only sees the
+ // script of a Svelte file. Therefore preserve all value imports.
+ verbatimModuleSyntax: true,
+ // Vite compiles modules one at a time
+ isolatedModules: true,
+
+ // This is required for svelte-package to work as expected
+ // Can be overwritten
+ lib: ['esnext', 'DOM', 'DOM.Iterable'],
+ moduleResolution: 'bundler',
+ module: 'esnext',
+ noEmit: true, // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
+ target: 'esnext'
+ },
+ include: [...include],
+ exclude
+ };
+
+ return kit.typescript.config(config) ?? config;
+}
+
+/** @param {string} cwd */
+function load_user_tsconfig(cwd) {
+ const file = maybe_file(cwd, 'tsconfig.json') || maybe_file(cwd, 'jsconfig.json');
+
+ if (!file) return;
+
+ // we have to eval the file, since it's not parseable as JSON (contains comments)
+ const json = fs.readFileSync(file, 'utf-8');
+
+ return {
+ kind: path.basename(file),
+ options: (0, eval)(`(${json})`)
+ };
+}
+
+/**
+ * @param {string} cwd
+ * @param {string} out
+ * @param {{ kind: string, options: any }} config
+ */
+function validate_user_config(cwd, out, config) {
+ // we need to check that the user's tsconfig extends the framework config
+ const extend = config.options.extends;
+ const extends_framework_config =
+ typeof extend === 'string'
+ ? path.resolve(cwd, extend) === out
+ : Array.isArray(extend)
+ ? extend.some((e) => path.resolve(cwd, e) === out)
+ : false;
+
+ const options = config.options.compilerOptions || {};
+
+ if (extends_framework_config) {
+ const { paths, baseUrl } = options;
+
+ // TODO: baseUrl will be removed in TypeScript 7.0
+ if (baseUrl || paths) {
+ console.warn(
+ colors
+ .bold()
+ .yellow(
+ `You have specified a baseUrl and/or paths in your ${config.kind} which interferes with SvelteKit's auto-generated tsconfig.json. ` +
+ 'Remove it to avoid problems with intellisense. For path aliases, use `kit.alias` instead: https://svelte.dev/docs/kit/configuration#alias'
+ )
+ );
+ }
+ } else {
+ let relative = posixify(path.relative('.', out));
+ if (!relative.startsWith('./')) relative = './' + relative;
+
+ console.warn(
+ colors
+ .bold()
+ .yellow(`Your ${config.kind} should extend the configuration generated by SvelteKit:`)
+ );
+ console.warn(`{\n "extends": "${relative}"\n}`);
+ }
+}
+
+//
+const alias_regex = /^(.+?)(\/\*)?$/;
+//
+const value_regex = /^(.*?)((\/\*)|(\.\w+))?$/;
+
+/**
+ * Generates tsconfig path aliases from kit's aliases.
+ * Related to vite alias creation.
+ *
+ * @param {import('types').ValidatedKitConfig} config
+ */
+function get_tsconfig_paths(config) {
+ /** @param {string} file */
+ const config_relative = (file) => {
+ let relative_path = path.relative(config.outDir, file);
+ if (!relative_path.startsWith('..')) {
+ relative_path = './' + relative_path;
+ }
+ return posixify(relative_path);
+ };
+
+ const alias = { ...config.alias };
+ if (fs.existsSync(project_relative(config.files.lib))) {
+ alias['$lib'] = project_relative(config.files.lib);
+ }
+
+ /** @type {Record} */
+ const paths = {};
+
+ for (const [key, value] of Object.entries(alias)) {
+ const key_match = alias_regex.exec(key);
+ if (!key_match) throw new Error(`Invalid alias key: ${key}`);
+
+ const value_match = value_regex.exec(value);
+ if (!value_match) throw new Error(`Invalid alias value: ${value}`);
+
+ const rel_path = config_relative(remove_trailing_slashstar(value));
+ const slashstar = key_match[2];
+
+ if (slashstar) {
+ paths[key] = [rel_path + '/*'];
+ } else {
+ paths[key] = [rel_path];
+ const fileending = value_match[4];
+
+ if (!fileending && !(key + '/*' in alias)) {
+ paths[key + '/*'] = [rel_path + '/*'];
+ }
+ }
+ }
+
+ return paths;
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_types/index.js b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_types/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..420453333135062d4746b14ba9b29eef1cec14e1
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/core/sync/write_types/index.js
@@ -0,0 +1,877 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import MagicString from 'magic-string';
+import { posixify, rimraf, walk } from '../../../utils/filesystem.js';
+import { compact } from '../../../utils/array.js';
+import { ts } from '../ts.js';
+const remove_relative_parent_traversals = (/** @type {string} */ path) =>
+ path.replace(/\.\.\//g, '');
+const is_whitespace = (/** @type {string} */ char) => /\s/.test(char);
+
+/**
+ * @typedef {{
+ * file_name: string;
+ * modified: boolean;
+ * code: string;
+ * exports: any[];
+ * } | null} Proxy
+ *
+ * @typedef {{
+ * server: Proxy,
+ * universal: Proxy
+ * }} Proxies
+ *
+ * @typedef {Map} RoutesMap
+ */
+
+const cwd = process.cwd();
+
+/**
+ * Creates types for the whole manifest
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('types').ManifestData} manifest_data
+ */
+export function write_all_types(config, manifest_data) {
+ if (!ts) return;
+
+ const types_dir = `${config.kit.outDir}/types`;
+
+ // empty out files that no longer need to exist
+ const routes_dir = remove_relative_parent_traversals(
+ posixify(path.relative('.', config.kit.files.routes))
+ );
+ const expected_directories = new Set(
+ manifest_data.routes.map((route) => path.join(routes_dir, route.id))
+ );
+
+ if (fs.existsSync(types_dir)) {
+ for (const file of walk(types_dir)) {
+ const dir = path.dirname(file);
+ if (!expected_directories.has(dir)) {
+ rimraf(path.join(types_dir, file));
+ }
+ }
+ }
+
+ // Read/write meta data on each invocation, not once per node process,
+ // 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);
+ const meta_data = has_meta_data
+ ? /** @type {Record} */ (JSON.parse(fs.readFileSync(meta_data_file, 'utf-8')))
+ : {};
+ const routes_map = create_routes_map(manifest_data);
+ // For each directory, write $types.d.ts
+ for (const route of manifest_data.routes) {
+ if (!route.leaf && !route.layout && !route.endpoint) continue; // nothing to do
+
+ const outdir = path.join(config.kit.outDir, 'types', routes_dir, route.id);
+
+ // check if the types are out of date
+ /** @type {string[]} */
+ const input_files = [];
+
+ /** @type {import('types').PageNode | null} */
+ let node = route.leaf;
+ while (node) {
+ if (node.universal) input_files.push(node.universal);
+ if (node.server) input_files.push(node.server);
+ node = node.parent ?? null;
+ }
+
+ /** @type {import('types').PageNode | null} */
+ node = route.layout;
+ while (node) {
+ if (node.universal) input_files.push(node.universal);
+ if (node.server) input_files.push(node.server);
+ node = node.parent ?? null;
+ }
+
+ if (route.endpoint) {
+ input_files.push(route.endpoint.file);
+ }
+
+ try {
+ fs.mkdirSync(outdir, { recursive: true });
+ } catch {}
+
+ const output_files = compact(
+ fs.readdirSync(outdir).map((name) => {
+ const stats = fs.statSync(path.join(outdir, name));
+ if (stats.isDirectory()) return;
+ return {
+ name,
+ updated: stats.mtimeMs
+ };
+ })
+ );
+
+ const source_last_updated = Math.max(
+ // ctimeMs includes move operations whereas mtimeMs does not
+ ...input_files.map((file) => fs.statSync(file).ctimeMs)
+ );
+ const types_last_updated = Math.max(...output_files.map((file) => file.updated));
+
+ const should_generate =
+ // source files were generated more recently than the types
+ source_last_updated > types_last_updated ||
+ // no meta data file exists yet
+ !has_meta_data ||
+ // some file was deleted
+ !meta_data[route.id]?.every((file) => input_files.includes(file));
+
+ if (should_generate) {
+ // track which old files end up being surplus to requirements
+ const to_delete = new Set(output_files.map((file) => file.name));
+ update_types(config, routes_map, route, to_delete);
+ meta_data[route.id] = input_files;
+ }
+ }
+
+ fs.writeFileSync(meta_data_file, JSON.stringify(meta_data, null, '\t'));
+}
+
+/**
+ * Creates types related to the given file. This should only be called
+ * if the file in question was edited, not if it was created/deleted/moved.
+ * @param {import('types').ValidatedConfig} config
+ * @param {import('types').ManifestData} manifest_data
+ * @param {string} file
+ */
+export function write_types(config, manifest_data, file) {
+ if (!ts) return;
+
+ if (!path.basename(file).startsWith('+')) {
+ // Not a route file
+ return;
+ }
+
+ const id = '/' + posixify(path.relative(config.kit.files.routes, path.dirname(file)));
+
+ const route = manifest_data.routes.find((route) => route.id === id);
+ if (!route) return;
+ if (!route.leaf && !route.layout && !route.endpoint) return; // nothing to do
+
+ update_types(config, create_routes_map(manifest_data), route);
+}
+
+/**
+ * Collect all leafs into a leaf -> route map
+ * @param {import('types').ManifestData} manifest_data
+ */
+function create_routes_map(manifest_data) {
+ /** @type {RoutesMap} */
+ const map = new Map();
+ for (const route of manifest_data.routes) {
+ if (route.leaf) {
+ map.set(route.leaf, { route, proxies: { server: null, universal: null } });
+ }
+ }
+ return map;
+}
+
+/**
+ * Update types for a specific route
+ * @param {import('types').ValidatedConfig} config
+ * @param {RoutesMap} routes
+ * @param {import('types').RouteData} route
+ * @param {Set} [to_delete]
+ */
+function update_types(config, routes, route, to_delete = new Set()) {
+ const routes_dir = remove_relative_parent_traversals(
+ posixify(path.relative('.', config.kit.files.routes))
+ );
+ 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';"];
+
+ /** @type {string[]} */
+ const declarations = [];
+
+ /** @type {string[]} */
+ const exports = [];
+
+ // add 'Expand' helper
+ // Makes sure a type is "repackaged" and therefore more readable
+ declarations.push('type Expand = 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 extends (param : string) => param is (infer U extends string) ? U : string;'
+ );
+
+ declarations.push(
+ 'type RouteParams = ' + generate_params_type(route.params, outdir, config) + ';'
+ );
+
+ if (route.params.length > 0) {
+ exports.push(
+ 'export type EntryGenerator = () => Promise> | Array;'
+ );
+ }
+
+ declarations.push(`type RouteId = '${route.id}';`);
+
+ // These could also be placed in our public types, but it would bloat them unnecessarily and we may want to change these in the future
+ if (route.layout || route.leaf) {
+ declarations.push(
+ // If T extends the empty object, void is also allowed as a return type
+ 'type MaybeWithVoid = {} extends T ? T | void : T;',
+
+ // Returns the key of the object whose values are required.
+ 'export type RequiredKeys = { [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 = MaybeWithVoid> & Partial> & Record>',
+
+ // null & {} == null, we need to prevent that in some situations
+ 'type EnsureDefined = 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, A extends keyof U = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude]?: never } & U : never;',
+
+ // Re-export `Snapshot` from @sveltejs/kit — in future we could use this to infer from the return type of `snapshot.capture`
+ 'export type Snapshot = Kit.Snapshot;'
+ );
+ }
+
+ if (route.leaf) {
+ let route_info = routes.get(route.leaf);
+ if (!route_info) {
+ // This should be defined, but belts and braces
+ route_info = { route, proxies: { server: null, universal: null } };
+ routes.set(route.leaf, route_info);
+ }
+
+ const {
+ declarations: d,
+ exports: e,
+ proxies
+ } = process_node(route.leaf, outdir, true, route_info.proxies);
+
+ exports.push(...e);
+ declarations.push(...d);
+
+ if (proxies.server) {
+ route_info.proxies.server = proxies.server;
+ if (proxies.server?.modified) to_delete.delete(proxies.server.file_name);
+ }
+ if (proxies.universal) {
+ route_info.proxies.universal = proxies.universal;
+ if (proxies.universal?.modified) to_delete.delete(proxies.universal.file_name);
+ }
+
+ if (route.leaf.server) {
+ exports.push(
+ 'export type Action | void = Record | void> = Kit.Action'
+ );
+ exports.push(
+ 'export type Actions | void = Record | void> = Kit.Actions'
+ );
+ }
+
+ if (route.leaf.server) {
+ exports.push(
+ 'export type PageProps = { params: RouteParams; data: PageData; form: ActionData }'
+ );
+ } else {
+ exports.push('export type PageProps = { params: RouteParams; data: PageData }');
+ }
+ }
+
+ if (route.layout) {
+ let all_pages_have_load = true;
+ /** @type {import('types').RouteParam[]} */
+ const layout_params = [];
+ const ids = ['RouteId'];
+
+ route.layout.child_pages?.forEach((page) => {
+ const leaf = routes.get(page);
+ if (leaf) {
+ if (leaf.route.page) ids.push(`"${leaf.route.id}"`);
+
+ for (const param of leaf.route.params) {
+ // skip if already added
+ if (layout_params.some((p) => p.name === param.name)) continue;
+ layout_params.push({ ...param, optional: true });
+ }
+
+ ensureProxies(page, leaf.proxies);
+
+ if (
+ // Be defensive - if a proxy doesn't exist (because it couldn't be created), assume a load function exists.
+ // If we didn't and it's a false negative, the user could wrongfully get a type error on layouts.
+ (leaf.proxies.server && !leaf.proxies.server.exports.includes('load')) ||
+ (leaf.proxies.universal && !leaf.proxies.universal.exports.includes('load'))
+ ) {
+ all_pages_have_load = false;
+ }
+ }
+ if (!page.server && !page.universal) {
+ all_pages_have_load = false;
+ }
+ });
+
+ if (route.id === '/') {
+ // root layout is used for fallback error page, where ID can be null
+ ids.push('null');
+ }
+
+ declarations.push(`type LayoutRouteId = ${ids.join(' | ')}`);
+
+ declarations.push(
+ 'type LayoutParams = RouteParams & ' + generate_params_type(layout_params, outdir, config)
+ );
+
+ const {
+ exports: e,
+ declarations: d,
+ proxies
+ } = process_node(
+ route.layout,
+ outdir,
+ false,
+ { server: null, universal: null },
+ all_pages_have_load
+ );
+
+ exports.push(...e);
+ declarations.push(...d);
+
+ if (proxies.server?.modified) to_delete.delete(proxies.server.file_name);
+ if (proxies.universal?.modified) to_delete.delete(proxies.universal.file_name);
+
+ exports.push(
+ 'export type LayoutProps = { params: LayoutParams; data: LayoutData; children: import("svelte").Snippet }'
+ );
+ }
+
+ if (route.endpoint) {
+ exports.push('export type RequestHandler = Kit.RequestHandler;');
+ }
+
+ if (route.leaf?.server || route.layout?.server || route.endpoint) {
+ exports.push('export type RequestEvent = Kit.RequestEvent;');
+ }
+
+ const output = [imports.join('\n'), declarations.join('\n'), exports.join('\n')]
+ .filter(Boolean)
+ .join('\n\n');
+
+ fs.writeFileSync(`${outdir}/$types.d.ts`, output);
+ to_delete.delete('$types.d.ts');
+
+ for (const file of to_delete) {
+ fs.unlinkSync(path.join(outdir, file));
+ }
+}
+
+/**
+ * @param {import('types').PageNode} node
+ * @param {string} outdir
+ * @param {boolean} is_page
+ * @param {Proxies} proxies
+ * @param {boolean} [all_pages_have_load]
+ */
+function process_node(node, outdir, is_page, proxies, all_pages_have_load = true) {
+ const params = `${is_page ? 'Route' : 'Layout'}Params`;
+ const prefix = is_page ? 'Page' : 'Layout';
+
+ const route_id = is_page ? 'RouteId' : 'LayoutRouteId';
+
+ /** @type {string[]} */
+ const declarations = [];
+ /** @type {string[]} */
+ const exports = [];
+
+ /** @type {string} */
+ let server_data;
+ /** @type {string} */
+ let data;
+
+ ensureProxies(node, proxies);
+
+ if (node.server) {
+ const basename = path.basename(node.server);
+ const proxy = proxies.server;
+ if (proxy?.modified) {
+ fs.writeFileSync(`${outdir}/proxy${basename}`, proxy.code);
+ }
+
+ server_data = get_data_type(node.server, 'null', proxy, true);
+
+ const parent_type = `${prefix}ServerParentData`;
+
+ declarations.push(`type ${parent_type} = ${get_parent_type(node, 'LayoutServerData')};`);
+
+ // +page.js load present -> server can return all-optional data
+ const output_data_shape =
+ node.universal || (!is_page && all_pages_have_load)
+ ? 'Partial & Record | void'
+ : `OutputDataShape<${parent_type}>`;
+ exports.push(
+ `export type ${prefix}ServerLoad = Kit.ServerLoad<${params}, ${parent_type}, OutputData, ${route_id}>;`
+ );
+
+ exports.push(`export type ${prefix}ServerLoadEvent = Parameters<${prefix}ServerLoad>[0];`);
+
+ if (is_page) {
+ let type = 'unknown';
+ if (proxy && proxy.exports.includes('actions')) {
+ // If the file wasn't tweaked, we can use the return type of the original file.
+ // The advantage is that type updates are reflected without saving.
+ const from = proxy.modified
+ ? `./proxy${replace_ext_with_js(basename)}`
+ : path_to_original(outdir, node.server);
+
+ exports.push(
+ 'type ExcludeActionFailure = T extends Kit.ActionFailure ? never : T extends void ? never : T;',
+ 'type ActionsSuccess any>> = { [Key in keyof T]: ExcludeActionFailure>>; }[keyof T];',
+ 'type ExtractActionFailure = T extends Kit.ActionFailure ? X extends void ? never : X : never;',
+ 'type ActionsFailure any>> = { [Key in keyof T]: Exclude>>, void>; }[keyof T];',
+ `type ActionsExport = typeof import('${from}').actions`,
+ 'export type SubmitFunction = Kit.SubmitFunction>, Expand>>'
+ );
+
+ type = 'Expand> | null';
+ }
+ exports.push(`export type ActionData = ${type};`);
+ }
+ } else {
+ server_data = 'null';
+ }
+ exports.push(`export type ${prefix}ServerData = ${server_data};`);
+
+ const parent_type = `${prefix}ParentData`;
+ declarations.push(`type ${parent_type} = ${get_parent_type(node, 'LayoutData')};`);
+
+ if (node.universal) {
+ const proxy = proxies.universal;
+ if (proxy?.modified) {
+ fs.writeFileSync(`${outdir}/proxy${path.basename(node.universal)}`, proxy.code);
+ }
+
+ const type = get_data_type(
+ node.universal,
+ `${parent_type} & EnsureDefined<${prefix}ServerData>`,
+ proxy
+ );
+
+ data = `Expand & OptionalUnion>>`;
+
+ const output_data_shape =
+ !is_page && all_pages_have_load
+ ? 'Partial & Record | void'
+ : `OutputDataShape<${parent_type}>`;
+ exports.push(
+ `export type ${prefix}Load = Kit.Load<${params}, ${prefix}ServerData, ${parent_type}, OutputData, ${route_id}>;`
+ );
+
+ exports.push(`export type ${prefix}LoadEvent = Parameters<${prefix}Load>[0];`);
+ } else if (server_data === 'null') {
+ data = `Expand<${parent_type}>`;
+ } else {
+ data = `Expand & EnsureDefined<${prefix}ServerData>>`;
+ }
+
+ exports.push(`export type ${prefix}Data = ${data};`);
+
+ return { declarations, exports, proxies };
+
+ /**
+ * @param {string} file_path
+ * @param {string} fallback
+ * @param {Proxy} proxy
+ * @param {boolean} expand
+ */
+ function get_data_type(file_path, fallback, proxy, expand = false) {
+ if (proxy) {
+ if (proxy.exports.includes('load')) {
+ // If the file wasn't tweaked, we can use the return type of the original file.
+ // The advantage is that type updates are reflected without saving.
+ const from = proxy.modified
+ ? `./proxy${replace_ext_with_js(path.basename(file_path))}`
+ : path_to_original(outdir, file_path);
+ const type = `Kit.LoadProperties>>`;
+ return expand ? `Expand>>` : type;
+ } else {
+ return fallback;
+ }
+ } else {
+ return 'unknown';
+ }
+ }
+}
+
+/**
+ * This function populates the proxies object, if necessary and not already done.
+ * Proxies are used to tweak the code of a file before it's typechecked.
+ * They are needed in two places - when generating the types for a page or layout.
+ * To not do the same work twice, we generate the proxies once and pass them around.
+ *
+ * @param {import('types').PageNode} node
+ * @param {Proxies} proxies
+ */
+function ensureProxies(node, proxies) {
+ if (node.server && !proxies.server) {
+ proxies.server = createProxy(node.server, true);
+ }
+
+ if (node.universal && !proxies.universal) {
+ proxies.universal = createProxy(node.universal, false);
+ }
+}
+
+/**
+ * @param {string} file_path
+ * @param {boolean} is_server
+ * @returns {Proxy}
+ */
+function createProxy(file_path, is_server) {
+ const proxy = tweak_types(fs.readFileSync(file_path, 'utf8'), is_server);
+ if (proxy) {
+ return {
+ ...proxy,
+ file_name: `proxy${path.basename(file_path)}`
+ };
+ } else {
+ return null;
+ }
+}
+
+/**
+ * Get the parent type string by recursively looking up the parent layout and accumulate them to one type.
+ * @param {import('types').PageNode} node
+ * @param {string} type
+ */
+function get_parent_type(node, type) {
+ const parent_imports = [];
+
+ let parent = node.parent;
+
+ while (parent) {
+ const d = node.depth - parent.depth;
+ // unshift because we need it the other way round for the import string
+ parent_imports.unshift(
+ `${d === 0 ? '' : `import('${'../'.repeat(d)}${'$types.js'}').`}${type}`
+ );
+ parent = parent.parent;
+ }
+
+ let parent_str = `EnsureDefined<${parent_imports[0] || '{}'}>`;
+ for (let i = 1; i < parent_imports.length; i++) {
+ // Omit is necessary because a parent could have a property with the same key which would
+ // cause a type conflict. At runtime the child overwrites the parent property in this case,
+ // so reflect that in the type definition.
+ // EnsureDefined is necessary because {something: string} & null becomes null.
+ // Output types of server loads can be null but when passed in through the `parent` parameter they are the empty object instead.
+ parent_str = `Omit<${parent_str}, keyof ${parent_imports[i]}> & EnsureDefined<${parent_imports[i]}>`;
+ }
+ return parent_str;
+}
+
+/**
+ * @param {string} outdir
+ * @param {string} file_path
+ */
+function path_to_original(outdir, file_path) {
+ return posixify(path.relative(outdir, path.join(cwd, replace_ext_with_js(file_path))));
+}
+
+/**
+ * @param {string} file_path
+ */
+function replace_ext_with_js(file_path) {
+ // Another extension than `.js` (or nothing, but that fails with node16 moduleResolution)
+ // will result in TS failing to lookup the file
+ const ext = path.extname(file_path);
+ return file_path.slice(0, -ext.length) + '.js';
+}
+
+/**
+ * @param {import('types').RouteParam[]} params
+ * @param {string} outdir
+ * @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')));
+
+ return `{ ${params
+ .map(
+ (param) =>
+ `${param.name}${param.optional ? '?' : ''}: ${
+ param.matcher
+ ? `MatcherParam`
+ : 'string'
+ }${param.optional ? ' | undefined' : ''}`
+ )
+ .join('; ')} }`;
+}
+
+/**
+ * @param {string} content
+ * @param {boolean} is_server
+ * @returns {Omit, 'file_name'> | null}
+ */
+export function tweak_types(content, is_server) {
+ const names = new Set(is_server ? ['load', 'actions'] : ['load']);
+
+ try {
+ let modified = false;
+
+ const ast = ts.createSourceFile(
+ 'filename.ts',
+ content,
+ ts.ScriptTarget.Latest,
+ false,
+ ts.ScriptKind.TS
+ );
+
+ 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 (
+ ts.isExportDeclaration(node) &&
+ node.exportClause &&
+ ts.isNamedExports(node.exportClause)
+ ) {
+ node.exportClause.elements.forEach((element) => {
+ const exported = element.name;
+ if (names.has(element.name.text)) {
+ const local = element.propertyName || element.name;
+ exports.set(exported.text, local.text);
+ }
+ });
+ }
+
+ if (
+ ts.canHaveModifiers(node) &&
+ ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+ ) {
+ if (ts.isFunctionDeclaration(node) && node.name?.text && names.has(node.name?.text)) {
+ exports.set(node.name.text, node.name.text);
+ }
+
+ if (ts.isVariableStatement(node)) {
+ node.declarationList.declarations.forEach((declaration) => {
+ add_export(declaration.name);
+ });
+ }
+ }
+ });
+
+ /**
+ * @param {import('typescript').Node} node
+ * @param {import('typescript').Node} value
+ */
+ function replace_jsdoc_type_tags(node, value) {
+ let _modified = false;
+ // @ts-ignore
+ if (node.jsDoc) {
+ // @ts-ignore
+ for (const comment of node.jsDoc) {
+ for (const tag of comment.tags ?? []) {
+ if (ts.isJSDocTypeTag(tag)) {
+ const is_fn =
+ ts.isFunctionDeclaration(value) ||
+ ts.isFunctionExpression(value) ||
+ ts.isArrowFunction(value);
+
+ if (is_fn && value.parameters?.length > 0) {
+ const name = ts.isIdentifier(value.parameters[0].name)
+ ? value.parameters[0].name.text
+ : 'event';
+ code.overwrite(tag.tagName.pos, tag.tagName.end, 'param');
+ code.prependRight(tag.typeExpression.pos + 1, 'Parameters<');
+ code.appendLeft(tag.typeExpression.end - 1, '>[0]');
+ code.appendLeft(tag.typeExpression.end, ` ${name}`);
+ } else {
+ code.overwrite(tag.pos, tag.end, '');
+ }
+ _modified = true;
+ }
+ }
+ }
+ }
+ modified = modified || _modified;
+ return _modified;
+ }
+
+ ast.forEachChild((node) => {
+ if (ts.isFunctionDeclaration(node) && node.name?.text && node.name?.text === 'load') {
+ // remove JSDoc comment above `export function load ...`
+ replace_jsdoc_type_tags(node, node);
+ }
+
+ if (ts.isVariableStatement(node)) {
+ // remove JSDoc comment above `export const load = ...`
+ if (
+ ts.isIdentifier(node.declarationList.declarations[0].name) &&
+ names.has(node.declarationList.declarations[0].name.text) &&
+ node.declarationList.declarations[0].initializer
+ ) {
+ replace_jsdoc_type_tags(node, node.declarationList.declarations[0].initializer);
+ }
+
+ for (const declaration of node.declarationList.declarations) {
+ if (
+ ts.isIdentifier(declaration.name) &&
+ declaration.name.text === 'load' &&
+ declaration.initializer
+ ) {
+ // edge case — remove JSDoc comment above individual export
+ replace_jsdoc_type_tags(declaration, declaration.initializer);
+
+ // remove type from `export const load: Load ...`
+ if (declaration.type) {
+ let a = declaration.type.pos;
+ const b = declaration.type.end;
+ while (is_whitespace(content[a])) a += 1;
+
+ const type = content.slice(a, b);
+ code.remove(declaration.name.end, declaration.type.end);
+
+ const rhs = declaration.initializer;
+
+ if (
+ rhs &&
+ (ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+ rhs.parameters.length
+ ) {
+ const arg = rhs.parameters[0];
+ const add_parens = content[arg.pos - 1] !== '(';
+
+ if (add_parens) code.prependRight(arg.pos, '(');
+
+ if (arg && !arg.type) {
+ code.appendLeft(
+ arg.name.end,
+ `: Parameters<${type}>[0]` + (add_parens ? ')' : '')
+ );
+ } else {
+ // prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
+ code.append(`;null as any as ${type};`);
+ }
+ } else {
+ // prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
+ code.append(`;null as any as ${type};`);
+ }
+
+ modified = true;
+ }
+ } else if (
+ is_server &&
+ ts.isIdentifier(declaration.name) &&
+ declaration.name?.text === 'actions' &&
+ declaration.initializer
+ ) {
+ // remove JSDoc comment from `export const actions = ..`
+ const removed = replace_jsdoc_type_tags(node, declaration.initializer);
+ // ... and move type to each individual action
+ if (removed) {
+ const rhs = declaration.initializer;
+ if (ts.isObjectLiteralExpression(rhs)) {
+ for (const prop of rhs.properties) {
+ if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+ const rhs = prop.initializer;
+ const replaced = replace_jsdoc_type_tags(prop, rhs);
+ if (
+ !replaced &&
+ rhs &&
+ (ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+ rhs.parameters?.[0]
+ ) {
+ const name = ts.isIdentifier(rhs.parameters[0].name)
+ ? rhs.parameters[0].name.text
+ : 'event';
+ code.prependRight(
+ rhs.pos,
+ `/** @param {import('./$types').RequestEvent} ${name} */ `
+ );
+ }
+ }
+ }
+ }
+ }
+
+ // remove type from `export const actions: Actions ...`
+ if (declaration.type) {
+ let a = declaration.type.pos;
+ const b = declaration.type.end;
+ while (is_whitespace(content[a])) a += 1;
+
+ const type = content.slice(a, b);
+ code.remove(declaration.name.end, declaration.type.end);
+ code.append(`;null as any as ${type};`);
+ modified = true;
+
+ // ... and move type to each individual action
+ const rhs = declaration.initializer;
+ if (ts.isObjectLiteralExpression(rhs)) {
+ for (const prop of rhs.properties) {
+ if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+ const rhs = prop.initializer;
+
+ if (
+ rhs &&
+ (ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+ rhs.parameters.length
+ ) {
+ const arg = rhs.parameters[0];
+ const add_parens = content[arg.pos - 1] !== '(';
+
+ if (add_parens) code.prependRight(arg.pos, '(');
+
+ if (arg && !arg.type) {
+ code.appendLeft(
+ arg.name.end,
+ ": import('./$types').RequestEvent" + (add_parens ? ')' : '')
+ );
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ });
+
+ if (modified) {
+ // Ignore all type errors so they don't show up twice when svelte-check runs
+ // Account for possible @ts-check which would overwrite @ts-nocheck
+ if (code.original.startsWith('// @ts-check')) {
+ code.prependLeft('// @ts-check'.length, '\n// @ts-nocheck\n');
+ } else {
+ code.prepend('// @ts-nocheck\n');
+ }
+ }
+
+ return {
+ modified,
+ code: code.toString(),
+ exports: Array.from(exports.keys())
+ };
+ } catch {
+ return null;
+ }
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/core/utils.js b/tools/ui/node_modules/@sveltejs/kit/src/core/utils.js
new file mode 100644
index 0000000000000000000000000000000000000000..3bbcdea712ff97e792265d64763a1caa17f2a160
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/core/utils.js
@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import colors from 'kleur';
+import { posixify, to_fs } from '../utils/filesystem.js';
+import { noop } from '../utils/functions.js';
+
+/**
+ * Resolved path of the `runtime` directory
+ *
+ * TODO Windows issue:
+ * Vite or sth else somehow sets the driver letter inconsistently to lower or upper case depending on the run environment.
+ * In playwright debug mode run through VS Code this a root-to-lowercase conversion is needed in order for the tests to run.
+ * If we do this conversion in other cases it has the opposite effect though and fails.
+ */
+export const runtime_directory = posixify(fileURLToPath(new URL('../runtime', import.meta.url)));
+
+/**
+ * This allows us to import SvelteKit internals that aren't exposed via `pkg.exports` in a
+ * way that works whether `@sveltejs/kit` is installed inside the project's `node_modules`
+ * or in a workspace root
+ */
+export const runtime_base = runtime_directory.startsWith(process.cwd())
+ ? `/${path.relative('.', runtime_directory)}`
+ : to_fs(runtime_directory);
+
+/** @param {{ verbose: boolean }} opts */
+export function logger({ verbose }) {
+ /** @type {import('types').Logger} */
+ const log = (msg) => console.log(msg.replace(/^/gm, ' '));
+
+ /** @param {string} msg */
+ const err = (msg) => console.error(msg.replace(/^/gm, ' '));
+
+ log.success = (msg) => log(colors.green(`✔ ${msg}`));
+ log.error = (msg) => err(colors.bold().red(msg));
+ log.warn = (msg) => log(colors.bold().yellow(msg));
+
+ log.minor = verbose ? (msg) => log(colors.grey(msg)) : noop;
+ log.info = verbose ? log : noop;
+
+ return log;
+}
+
+/** @param {import('types').ManifestData} manifest_data */
+export function get_mime_lookup(manifest_data) {
+ /** @type {Record} */
+ const mime = {};
+
+ manifest_data.assets.forEach((asset) => {
+ if (asset.type) {
+ const ext = path.extname(asset.file);
+ mime[ext] = asset.type;
+ }
+ });
+
+ return mime;
+}
+
+/**
+ * @param {string} dir
+ * @param {(file: string) => boolean} [filter]
+ */
+export function list_files(dir, filter) {
+ /** @type {string[]} */
+ const files = [];
+
+ /** @param {string} current */
+ function walk(current) {
+ for (const file of fs.readdirSync(path.resolve(dir, current))) {
+ const child = path.posix.join(current, file);
+ if (fs.statSync(path.resolve(dir, child)).isDirectory()) {
+ walk(child);
+ } else {
+ if (!filter || filter(child)) {
+ files.push(child);
+ }
+ }
+ }
+ }
+
+ if (fs.existsSync(dir)) walk('');
+
+ return files;
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/env/index.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/env/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..1f3e591e4b2095f76855393af3bf2b5b264b4bf4
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/env/index.js
@@ -0,0 +1,12 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+
+/**
+ * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
+ * which are made available via `$app/env/public` and `$app/env/private`.
+ * @template {Record>} T
+ * @param {T} variables
+ * @returns {T}
+ */
+export function defineEnvVars(variables) {
+ return variables;
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/index.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..460c07b366c87ba5490a5bacf2829e8a79bc3665
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/index.js
@@ -0,0 +1,16 @@
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+
+export { sequence } from './sequence.js';
+
+/**
+ * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
+ * which are made available via `$app/env/public` and `$app/env/private`.
+ * @template {Record>} T
+ * @param {T} variables
+ * @returns {T}
+ * @deprecated Import `defineEnvVars` from `@sveltejs/kit/env` instead
+ */
+export function defineEnvVars(variables) {
+ console.warn(`\`defineEnvVars\` has moved — import it from \`@sveltejs/kit/env\` instead`);
+ return variables;
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/sequence.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/sequence.js
new file mode 100644
index 0000000000000000000000000000000000000000..3668c500cebb19d78761db7f460143826cf220ac
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/hooks/sequence.js
@@ -0,0 +1,145 @@
+/** @import { Handle, RequestEvent, ResolveOptions } from '@sveltejs/kit' */
+/** @import { MaybePromise } from 'types' */
+import {
+ merge_tracing,
+ get_request_store,
+ with_request_store
+} from '@sveltejs/kit/internal/server';
+
+/**
+ * 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');
+ * return true;
+ * }
+ * });
+ * 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');
+ * return true;
+ * },
+ * filterSerializedResponseHeaders: () => {
+ * // this one wins as it's the first defined in the chain
+ * console.log('second filterSerializedResponseHeaders');
+ * return true;
+ * }
+ * });
+ * 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 {...Handle} handlers The chain of `handle` functions
+ * @returns {Handle}
+ */
+export function sequence(...handlers) {
+ const length = handlers.length;
+ if (!length) return ({ event, resolve }) => resolve(event);
+
+ return ({ event, resolve }) => {
+ const { state } = get_request_store();
+ return apply_handle(0, event, {});
+
+ /**
+ * @param {number} i
+ * @param {RequestEvent} event
+ * @param {ResolveOptions | undefined} parent_options
+ * @returns {MaybePromise}
+ */
+ function apply_handle(i, event, parent_options) {
+ const handle = handlers[i];
+
+ return state.tracing.record_span({
+ name: `sveltekit.handle.sequenced.${handle.name ? handle.name : i}`,
+ attributes: {},
+ fn: async (current) => {
+ const traced_event = merge_tracing(event, current);
+ return await with_request_store({ event: traced_event, state }, () =>
+ handle({
+ event: traced_event,
+ resolve: (event, options) => {
+ /** @type {ResolveOptions['transformPageChunk']} */
+ const transformPageChunk = async ({ html, done }) => {
+ if (options?.transformPageChunk) {
+ html = (await options.transformPageChunk({ html, done })) ?? '';
+ }
+
+ if (parent_options?.transformPageChunk) {
+ html = (await parent_options.transformPageChunk({ html, done })) ?? '';
+ }
+
+ return html;
+ };
+
+ /** @type {ResolveOptions['filterSerializedResponseHeaders']} */
+ const filterSerializedResponseHeaders =
+ parent_options?.filterSerializedResponseHeaders ??
+ options?.filterSerializedResponseHeaders;
+
+ /** @type {ResolveOptions['preload']} */
+ const preload = parent_options?.preload ?? options?.preload;
+
+ return i < length - 1
+ ? apply_handle(i + 1, event, {
+ transformPageChunk,
+ filterSerializedResponseHeaders,
+ preload
+ })
+ : resolve(event, {
+ transformPageChunk,
+ filterSerializedResponseHeaders,
+ preload
+ });
+ }
+ })
+ );
+ }
+ });
+ }
+ };
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/index.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6e2b7c465ff80d481fc5dfa69a081497faca529
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/index.js
@@ -0,0 +1,308 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+import { HttpError, Redirect, ActionFailure, ValidationError } from './internal/index.js';
+import { BROWSER, DEV } from 'esm-env';
+import {
+ add_data_suffix,
+ add_resolution_suffix,
+ has_data_suffix,
+ has_resolution_suffix,
+ strip_data_suffix,
+ strip_resolution_suffix
+} from '../runtime/pathname.js';
+import { text_encoder } from '../runtime/utils.js';
+
+export { VERSION } from '../version.js';
+
+// TODO 3.0: remove these types as they are not used anymore (we can't remove them yet because that would be a breaking change)
+/**
+ * @template {number} TNumber
+ * @template {any[]} [TArray=[]]
+ * @typedef {TNumber extends TArray['length'] ? TArray[number] : LessThan} LessThan
+ */
+
+/**
+ * @template {number} TStart
+ * @template {number} TEnd
+ * @typedef {Exclude, LessThan>} NumericRange
+ */
+
+// 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
+
+// we have to repeat the JSDoc because the display for function overloads is broken
+// see https://github.com/microsoft/TypeScript/issues/55056
+
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this 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 {App.Error} body An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
+ * @overload
+ * @param {number} status
+ * @param {App.Error} body
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this 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.
+ * @overload
+ * @param {number} status
+ * @param {{ message: string } extends App.Error ? App.Error | string | undefined : never} [body]
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+/**
+ * Throws an error with a HTTP status code and an optional message.
+ * When called during request handling, this 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.
+ * @return {never}
+ * @throws {HttpError} This error instructs SvelteKit to initiate HTTP error handling.
+ * @throws {Error} If the provided status is invalid (not between 400 and 599).
+ */
+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`);
+ }
+
+ throw new HttpError(status, body);
+}
+
+/**
+ * Checks whether this is an error thrown by {@link error}.
+ * @template {number} T
+ * @param {unknown} e
+ * @param {T} [status] The status to filter for.
+ * @return {e is (HttpError & { status: T extends undefined ? never : T })}
+ */
+export function isHttpError(e, status) {
+ if (!(e instanceof HttpError)) return false;
+ return !status || e.status === status;
+}
+
+/**
+ * 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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages)
+ *
+ * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number)} 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 | URL} location The location to redirect to.
+ * @throws {Redirect} This error instructs SvelteKit to redirect to the specified location.
+ * @throws {Error} If the provided status is invalid or the location cannot be used as a header value.
+ * @return {never}
+ */
+export function redirect(status, location) {
+ if ((!BROWSER || DEV) && (isNaN(status) || status < 300 || status > 308)) {
+ throw new Error('Invalid status code');
+ }
+
+ throw new Redirect(
+ // @ts-ignore
+ status,
+ location.toString()
+ );
+}
+
+/**
+ * Checks whether this is a redirect thrown by {@link redirect}.
+ * @param {unknown} e The object to check.
+ * @return {e is Redirect}
+ */
+export function isRedirect(e) {
+ return e instanceof Redirect;
+}
+
+/**
+ * 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
+ const body = JSON.stringify(data);
+
+ // we can't just do `text(JSON.stringify(data), init)` because
+ // it will set a default `content-type` header. duplicated code
+ // means less duplicated work
+ const headers = new Headers(init?.headers);
+ if (!headers.has('content-length')) {
+ headers.set('content-length', text_encoder.encode(body).byteLength.toString());
+ }
+
+ if (!headers.has('content-type')) {
+ headers.set('content-type', 'application/json');
+ }
+
+ return new Response(body, {
+ ...init,
+ headers
+ });
+}
+
+/**
+ * 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')) {
+ const encoded = text_encoder.encode(body);
+ headers.set('content-length', encoded.byteLength.toString());
+ return new Response(encoded, {
+ ...init,
+ headers
+ });
+ }
+
+ return new Response(body, {
+ ...init,
+ headers
+ });
+}
+
+/**
+ * Create an `ActionFailure` object. Call when form submission fails.
+ * @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.
+ * @overload
+ * @param {number} status
+ * @returns {import('./public.js').ActionFailure}
+ */
+/**
+ * Create an `ActionFailure` object. Call when form submission fails.
+ * @template [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)
+ * @overload
+ * @param {number} status
+ * @param {T} data
+ * @returns {import('./public.js').ActionFailure}
+ */
+/**
+ * Create an `ActionFailure` object. Call when form submission fails.
+ * @param {number} status
+ * @param {any} [data]
+ * @returns {import('./public.js').ActionFailure}
+ */
+export function fail(status, data) {
+ // @ts-expect-error unique symbol missing
+ return new ActionFailure(status, data);
+}
+
+/**
+ * Checks whether this is an action failure thrown by {@link fail}.
+ * @param {unknown} e The object to check.
+ * @return {e is import('./public.js').ActionFailure}
+ */
+export function isActionFailure(e) {
+ return e instanceof ActionFailure;
+}
+
+/**
+ * Use this to throw a validation error to imperatively fail form validation.
+ * Can be used in combination with `issue` passed to form actions to create field-specific issues.
+ *
+ * @example
+ * ```ts
+ * import { invalid } from '@sveltejs/kit';
+ * import { form } from '$app/server';
+ * import { tryLogin } from '$lib/server/auth';
+ * import * as v from 'valibot';
+ *
+ * export const login = form(
+ * v.object({ name: v.string(), _password: v.string() }),
+ * async ({ name, _password }) => {
+ * const success = tryLogin(name, _password);
+ * if (!success) {
+ * invalid('Incorrect username or password');
+ * }
+ *
+ * // ...
+ * }
+ * );
+ * ```
+ * @param {...(StandardSchemaV1.Issue | string)} issues
+ * @returns {never}
+ * @since 2.47.3
+ */
+export function invalid(...issues) {
+ throw new ValidationError(
+ issues.map((issue) => (typeof issue === 'string' ? { message: issue } : issue))
+ );
+}
+
+/**
+ * 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}
+ * @since 2.47.3
+ */
+export function isValidationError(e) {
+ return e instanceof ValidationError;
+}
+
+/**
+ * Strips possible SvelteKit-internal suffixes and trailing slashes from the URL pathname.
+ * Returns the normalized URL as well as a method for adding the potential suffix back
+ * based on a new pathname (possibly including search) or URL.
+ * ```js
+ * import { normalizeUrl } from '@sveltejs/kit';
+ *
+ * const { url, denormalize } = normalizeUrl('/blog/post/__data.json');
+ * console.log(url.pathname); // /blog/post
+ * console.log(denormalize('/blog/post/a')); // /blog/post/a/__data.json
+ * ```
+ * @param {URL | string} url
+ * @returns {{ url: URL, wasNormalized: boolean, denormalize: (url?: string | URL) => URL }}
+ * @since 2.18.0
+ */
+export function normalizeUrl(url) {
+ url = new URL(url, 'a://a');
+
+ const is_route_resolution = has_resolution_suffix(url.pathname);
+ const is_data_request = has_data_suffix(url.pathname);
+ const has_trailing_slash = url.pathname !== '/' && url.pathname.endsWith('/');
+
+ if (is_route_resolution) {
+ url.pathname = strip_resolution_suffix(url.pathname);
+ } else if (is_data_request) {
+ url.pathname = strip_data_suffix(url.pathname);
+ } else if (has_trailing_slash) {
+ url.pathname = url.pathname.slice(0, -1);
+ }
+
+ return {
+ url,
+ wasNormalized: is_data_request || is_route_resolution || has_trailing_slash,
+ denormalize: (new_url = url) => {
+ new_url = new URL(new_url, url);
+ if (is_route_resolution) {
+ new_url.pathname = add_resolution_suffix(new_url.pathname);
+ } else if (is_data_request) {
+ new_url.pathname = add_data_suffix(new_url.pathname);
+ } else if (has_trailing_slash && !new_url.pathname.endsWith('/')) {
+ new_url.pathname += '/';
+ }
+ return new_url;
+ }
+ };
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/env.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/env.js
new file mode 100644
index 0000000000000000000000000000000000000000..b34a8636ef749629355f5f5cf24cf6f84c557d69
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/env.js
@@ -0,0 +1,71 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { EnvVarConfig } from '@sveltejs/kit' */
+
+import { stackless } from '../../utils/error.js';
+
+const MISSING = {
+ message: `Value is missing. If it is optional, add a Standard Schema validator declaring it as such.`
+};
+
+const BAD_VALIDATOR = {
+ message: 'Variable was configured with a validator that does not implement Standard Schema'
+};
+
+const ASYNC_VALIDATOR = {
+ message: 'Variable uses an async validator, which is not supported'
+};
+
+/**
+ * @param {Record | undefined>} variables
+ * @param {string | undefined} value
+ * @param {string} name
+ * @param {Record} issues
+ * @returns
+ */
+export function validate(variables, value, name, issues) {
+ const config = variables[name] ?? {};
+ const validator = config.schema;
+
+ if (!validator) {
+ if (!value) issues[name] = [MISSING];
+ return value;
+ }
+
+ if (!validator['~standard']) {
+ issues[name] = [BAD_VALIDATOR];
+ return;
+ }
+
+ const result = validator['~standard'].validate(value);
+
+ if (result instanceof Promise) {
+ issues[name] = [ASYNC_VALIDATOR];
+ return;
+ }
+
+ if (result.issues) {
+ issues[name] = [...result.issues];
+ return;
+ }
+
+ return result.value;
+}
+
+/**
+ * @param {Record} issues
+ */
+export function handle_issues(issues) {
+ const entries = Object.entries(issues);
+
+ if (entries.length === 0) {
+ return;
+ }
+
+ let message = 'Invalid environment variables\n';
+
+ for (const [name, issues] of entries) {
+ message += `\n${name}\n${issues.map((issue) => ` - ${issue.message}`).join('\n')}\n`;
+ }
+
+ throw stackless(message);
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/event.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/event.js
new file mode 100644
index 0000000000000000000000000000000000000000..9d658494e1be2b3accd73610fc02698998d6dd10
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/event.js
@@ -0,0 +1,85 @@
+/** @import { RequestEvent } from '@sveltejs/kit' */
+/** @import { RequestStore } from 'types' */
+/** @import { AsyncLocalStorage } from 'node:async_hooks' */
+
+import { IN_WEBCONTAINER } from '../../runtime/server/constants.js';
+
+/** @type {RequestStore | null} */
+let sync_store = null;
+
+/** @type {AsyncLocalStorage | null} */
+let als;
+
+import('node:async_hooks')
+ .then((hooks) => (als = new hooks.AsyncLocalStorage()))
+ .catch(() => {
+ // can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
+ // this isn't behind `supports` because it's basically just StackBlitz (i.e.
+ // in-browser usage) that doesn't support it AFAICT
+ });
+
+/**
+ * Returns the current `RequestEvent`. Can be used inside server hooks, server `load` functions, actions, and endpoints (and functions called by them).
+ *
+ * In environments without [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html#class-asynclocalstorage), this must be called synchronously (i.e. not after an `await`).
+ * @since 2.20.0
+ *
+ * @returns {RequestEvent}
+ */
+export function getRequestEvent() {
+ const event = try_get_request_store()?.event;
+
+ if (!event) {
+ let message =
+ 'Can only read the current request event inside functions invoked during `handle`, such as server `load` functions, actions, endpoints, and other server hooks.';
+
+ if (!als) {
+ message +=
+ ' In environments without `AsyncLocalStorage`, the event must be read synchronously, not after an `await`.';
+ }
+
+ throw new Error(message);
+ }
+
+ return event;
+}
+
+export function get_request_store() {
+ const result = try_get_request_store();
+ if (!result) {
+ let message = 'Could not get the request store.';
+
+ if (als) {
+ message += ' This is an internal error.';
+ } else {
+ message +=
+ ' In environments without `AsyncLocalStorage`, the request store (used by e.g. remote functions) must be accessed synchronously, not after an `await`.' +
+ ' If it was accessed synchronously then this is an internal error.';
+ }
+
+ throw new Error(message);
+ }
+ return result;
+}
+
+export function try_get_request_store() {
+ return sync_store ?? als?.getStore() ?? null;
+}
+
+/**
+ * @template T
+ * @param {RequestStore | null} store
+ * @param {() => T} fn
+ */
+export function with_request_store(store, fn) {
+ try {
+ sync_store = store;
+ return als ? als.run(store, fn) : fn();
+ } finally {
+ // Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
+ // and handle only one request at a time in `src/runtime/server/index.js`.
+ if (!IN_WEBCONTAINER) {
+ sync_store = null;
+ }
+ }
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/index.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb9589c368d486ceec3820a5de92f72431ef8e0f
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/index.js
@@ -0,0 +1,90 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+export class HttpError {
+ /**
+ * @param {number} status
+ * @param {{message: string} extends App.Error ? (App.Error | string | undefined) : App.Error} body
+ */
+ constructor(status, body) {
+ this.status = status;
+ if (typeof body === 'string') {
+ this.body = { message: body };
+ } else if (body) {
+ this.body = body;
+ } else {
+ this.body = { message: `Error: ${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';
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/remote-functions.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/remote-functions.js
new file mode 100644
index 0000000000000000000000000000000000000000..f7da7b41742d661928f03c7ac1a260fd8bf4a2ec
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/remote-functions.js
@@ -0,0 +1,28 @@
+/** @import { RemoteInternals } from 'types' */
+
+/** @type {RemoteInternals['type'][]} */
+const types = ['command', 'form', 'prerender', 'query', 'query_batch', 'query_live'];
+
+/**
+ * @param {Record} module
+ * @param {string} file
+ * @param {string} hash
+ */
+export function init_remote_functions(module, file, hash) {
+ if (module.default) {
+ throw new Error(
+ `Cannot export \`default\` from a remote module (${file}) — please use named exports instead`
+ );
+ }
+
+ for (const [name, fn] of Object.entries(module)) {
+ if (!types.includes(fn?.__?.type)) {
+ throw new Error(
+ `\`${name}\` exported from ${file} is invalid — all exports from this file must be remote functions`
+ );
+ }
+
+ fn.__.id = `${hash}/${name}`;
+ fn.__.name = name;
+ }
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/server.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/server.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed425062637fe3d74ea038d5bb2a685674e6c739
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/server.js
@@ -0,0 +1,22 @@
+/**
+ * @template {{ tracing: { enabled: boolean, root: import('@opentelemetry/api').Span, current: import('@opentelemetry/api').Span } }} T
+ * @param {T} event_like
+ * @param {import('@opentelemetry/api').Span} current
+ * @returns {T}
+ */
+export function merge_tracing(event_like, current) {
+ return {
+ ...event_like,
+ tracing: {
+ ...event_like.tracing,
+ current
+ }
+ };
+}
+
+export {
+ with_request_store,
+ getRequestEvent,
+ get_request_store,
+ try_get_request_store
+} from './event.js';
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/types.d.ts b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/types.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..040ed7928a07f4a74bd8b89a7d1ea2e01653f9a7
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/internal/types.d.ts
@@ -0,0 +1,3 @@
+// We re-export this so we can use it in the `$app/env/*` module declarations
+// without the app needing to depend on this package
+export { StandardSchemaV1 } from '@standard-schema/spec';
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/node/index.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/node/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..87851e0c821c7a305071d75eb09c80ae6fbc21ed
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/node/index.js
@@ -0,0 +1,243 @@
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { SvelteKitError } from '../internal/index.js';
+import { noop } from '../../utils/functions.js';
+import { get_set_cookies } from '../../utils/http.js';
+
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {number} [body_size_limit]
+ */
+function get_raw_body(req, body_size_limit) {
+ const h = req.headers;
+
+ if (!h['content-type']) {
+ return null;
+ }
+
+ const content_length = Number(h['content-length']);
+ const has_content_length = Number.isFinite(content_length);
+
+ // check if no request body
+ if (
+ (req.httpVersionMajor === 1 && !has_content_length && h['transfer-encoding'] == null) ||
+ content_length === 0
+ ) {
+ return null;
+ }
+
+ if (req.destroyed) {
+ const readable = new ReadableStream();
+ void readable.cancel();
+ return readable;
+ }
+
+ let size = 0;
+ let cancelled = false;
+
+ return new ReadableStream({
+ start(controller) {
+ if (body_size_limit !== undefined && has_content_length && content_length > body_size_limit) {
+ let message = `Content-length of ${content_length} exceeds limit of ${body_size_limit} bytes.`;
+
+ if (body_size_limit === 0) {
+ // https://github.com/sveltejs/kit/pull/11589
+ // TODO this exists to aid migration — remove in a future version
+ message += ' To disable body size limits, specify Infinity rather than 0.';
+ }
+
+ const error = new SvelteKitError(413, 'Payload Too Large', message);
+
+ controller.error(error);
+ return;
+ }
+
+ req.on('error', (error) => {
+ cancelled = true;
+ controller.error(error);
+ });
+
+ req.on('end', () => {
+ if (cancelled) return;
+ controller.close();
+ });
+
+ req.on('data', (chunk) => {
+ if (cancelled) return;
+
+ size += chunk.length;
+
+ if (body_size_limit !== undefined && size > body_size_limit) {
+ cancelled = true;
+
+ const message = `request body size exceeded BODY_SIZE_LIMIT of ${body_size_limit}`;
+
+ const error = new SvelteKitError(413, 'Payload Too Large', message);
+ controller.error(error);
+
+ return;
+ }
+
+ if (has_content_length && size > content_length) {
+ cancelled = true;
+
+ const message = `request body size exceeded content-length of ${content_length}`;
+
+ const error = new SvelteKitError(413, 'Payload Too Large', message);
+ controller.error(error);
+
+ return;
+ }
+
+ controller.enqueue(chunk);
+
+ if (controller.desiredSize === null || controller.desiredSize <= 0) {
+ req.pause();
+ }
+ });
+ },
+
+ pull() {
+ req.resume();
+ },
+
+ cancel(reason) {
+ cancelled = true;
+ req.destroy(reason);
+ }
+ });
+}
+
+/**
+ * @param {{
+ * request: import('http').IncomingMessage;
+ * base: string;
+ * bodySizeLimit?: number;
+ * }} options
+ * @returns {Promise}
+ */
+// TODO 3.0 make the signature synchronous?
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function getRequest({ request, base, bodySizeLimit }) {
+ let headers = /** @type {Record} */ (request.headers);
+ if (request.httpVersionMajor >= 2) {
+ // the Request constructor rejects headers with ':' in the name
+ headers = Object.assign({}, headers);
+ // https://www.rfc-editor.org/rfc/rfc9113.html#section-8.3.1-2.3.5
+ if (headers[':authority']) {
+ headers.host = headers[':authority'];
+ }
+ delete headers[':authority'];
+ delete headers[':method'];
+ delete headers[':path'];
+ delete headers[':scheme'];
+ }
+
+ // TODO: Whenever Node >=22 is minimum supported version, we can use `request.readableAborted`
+ // @see https://github.com/nodejs/node/blob/5cf3c3e24c7257a0c6192ed8ef71efec8ddac22b/lib/internal/streams/readable.js#L1443-L1453
+ const controller = new AbortController();
+ let errored = false;
+ let end_emitted = false;
+ request.once('error', () => (errored = true));
+ request.once('end', () => (end_emitted = true));
+ request.once('close', () => {
+ if ((errored || request.destroyed) && !end_emitted) {
+ controller.abort();
+ }
+ });
+
+ return new Request(base + request.url, {
+ // @ts-expect-error
+ duplex: 'half',
+ method: request.method,
+ headers: Object.entries(headers),
+ signal: controller.signal,
+ body:
+ request.method === 'GET' || request.method === 'HEAD'
+ ? undefined
+ : get_raw_body(request, bodySizeLimit)
+ });
+}
+
+/**
+ * @param {import('http').ServerResponse} res
+ * @param {Response} response
+ * @returns {Promise}
+ */
+// TODO 3.0 make the signature synchronous?
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function setResponse(res, response) {
+ for (const [key, value] of response.headers) {
+ try {
+ res.setHeader(key, key === 'set-cookie' ? get_set_cookies(response.headers) : value);
+ } catch (error) {
+ res.getHeaderNames().forEach((name) => res.removeHeader(name));
+ res.writeHead(500).end(String(error));
+ return;
+ }
+ }
+
+ res.writeHead(response.status);
+
+ if (!response.body) {
+ res.end();
+ return;
+ }
+
+ if (response.body.locked) {
+ res.end(
+ 'Fatal error: Response body is locked. ' +
+ "This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
+ );
+ return;
+ }
+
+ const reader = response.body.getReader();
+
+ if (res.destroyed) {
+ void reader.cancel();
+ return;
+ }
+
+ const cancel = (/** @type {Error|undefined} */ error) => {
+ res.off('close', cancel);
+ res.off('error', cancel);
+
+ // If the reader has already been interrupted with an error earlier,
+ // then it will appear here, it is useless, but it needs to be catch.
+ reader.cancel(error).catch(noop);
+ if (error) res.destroy(error);
+ };
+
+ res.on('close', cancel);
+ res.on('error', cancel);
+
+ void next();
+ async function next() {
+ try {
+ for (;;) {
+ const { done, value } = await reader.read();
+
+ if (done) break;
+
+ if (!res.write(value)) {
+ res.once('drain', next);
+ return;
+ }
+ }
+ res.end();
+ } catch (error) {
+ cancel(error instanceof Error ? error : new Error(String(error)));
+ }
+ }
+}
+
+/**
+ * Converts a file on disk to a readable stream
+ * @param {string} file
+ * @returns {ReadableStream}
+ * @since 2.4.0
+ */
+export function createReadableStream(file) {
+ return /** @type {ReadableStream} */ (Readable.toWeb(createReadStream(file)));
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/node/polyfills.js b/tools/ui/node_modules/@sveltejs/kit/src/exports/node/polyfills.js
new file mode 100644
index 0000000000000000000000000000000000000000..347c68cea2e93c8d184d2ba8f5b9583ee1686b5c
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/node/polyfills.js
@@ -0,0 +1,30 @@
+import buffer from 'node:buffer';
+import { webcrypto as crypto } from 'node:crypto';
+
+// `buffer.File` was added in Node 18.13.0 while the `File` global was added in Node 20.0.0
+const File = /** @type {import('node:buffer') & { File?: File}} */ (buffer).File;
+
+/** @type {Record} */
+const globals = {
+ crypto,
+ File
+};
+
+// exported for dev/preview and node environments
+/**
+ * Make various web APIs available as globals:
+ * - `crypto`
+ * - `File`
+ */
+export function installPolyfills() {
+ for (const name in globals) {
+ if (name in globalThis) continue;
+
+ Object.defineProperty(globalThis, name, {
+ enumerable: true,
+ configurable: true,
+ writable: true,
+ value: globals[name]
+ });
+ }
+}
diff --git a/tools/ui/node_modules/@sveltejs/kit/src/exports/public.d.ts b/tools/ui/node_modules/@sveltejs/kit/src/exports/public.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..80fd1b82b4d6f6c445d3b7d818eeff130967bbbe
--- /dev/null
+++ b/tools/ui/node_modules/@sveltejs/kit/src/exports/public.d.ts
@@ -0,0 +1,2400 @@
+import 'svelte'; // pick up `declare module "*.svelte"`
+import 'vite/client'; // pick up `declare module "*.jpg"`, etc.
+import '../types/ambient.js';
+
+import {
+ AdapterEntry,
+ CspDirectives,
+ HttpMethod,
+ Logger,
+ MaybePromise,
+ Prerendered,
+ PrerenderEntryGeneratorMismatchHandlerValue,
+ PrerenderHttpErrorHandlerValue,
+ PrerenderInvalidUrlHandlerValue,
+ PrerenderMissingIdHandlerValue,
+ PrerenderUnseenRoutesHandlerValue,
+ PrerenderOption,
+ RequestOptions,
+ RouteSegment,
+ DeepPartial,
+ IsAny
+} from '../types/private.js';
+import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
+import { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import {
+ RouteId as AppRouteId,
+ LayoutParams as AppLayoutParams,
+ ResolvedPathname
+} from '$app/types';
+
+export { PrerenderOption } from '../types/private.js';
+
+// @ts-ignore this is an optional peer dependency so could be missing. Written like this so dts-buddy preserves the ts-ignore
+type Span = import('@opentelemetry/api').Span;
+
+/**
+ * [Adapters](https://svelte.dev/docs/kit/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.
+ */
+export interface Adapter {
+ /**
+ * The name of the adapter, using for logging. Will typically correspond to the package name.
+ */
+ name: string;
+ /**
+ * This function is called after SvelteKit has built your app.
+ * @param builder An object provided by SvelteKit that contains methods for adapting the app
+ */
+ adapt: (builder: Builder) => MaybePromise;
+ /**
+ * Checks called during dev and build to determine whether specific features will work in production with this adapter.
+ */
+ supports?: {
+ /**
+ * Test support for `read` from `$app/server`.
+ * @param details.config The merged adapter-specific route config exported from the route with `export const config`
+ */
+ read?: (details: { config: any; route: { id: string } }) => boolean;
+
+ /**
+ * Test support for `instrumentation.server.js`. To pass, the adapter must support running `instrumentation.server.js` prior to the application code.
+ * @since 2.31.0
+ */
+ instrumentation?: () => boolean;
+ };
+ /**
+ * Creates an `Emulator`, which allows the adapter to influence the environment
+ * during dev, build and prerendering.
+ */
+ emulate?: () => MaybePromise;
+}
+
+export type LoadProperties | void> = input extends void
+ ? undefined // needs to be undefined, because void will break intellisense
+ : input extends Record
+ ? input
+ : unknown;
+
+export type AwaitedActions any>> = OptionalUnion<
+ {
+ [Key in keyof T]: UnpackValidationError>>;
+ }[keyof 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, // not unknown, else interfaces don't satisfy this constraint
+ A extends keyof U = U extends U ? keyof U : never
+> = U extends unknown ? { [P in Exclude]?: never } & U : never;
+
+declare const uniqueSymbol: unique symbol;
+
+export interface ActionFailure {
+ status: number;
+ data: T;
+ [uniqueSymbol]: true; // necessary or else UnpackValidationError could wrongly unpack objects with the same shape as ActionFailure
+}
+
+type UnpackValidationError =
+ T extends ActionFailure
+ ? X
+ : T extends void
+ ? undefined // needs to be undefined, because void will corrupt union type
+ : T;
+
+/**
+ * This object is passed to the `adapt` function of adapters.
+ * It contains various methods and properties that are useful for adapting the app.
+ */
+export interface Builder {
+ /** Print messages to the console. `log.info` and `log.minor` are silent unless Vite's `logLevel` is `info`. */
+ log: Logger;
+ /** Remove `dir` and all its contents. */
+ rimraf: (dir: string) => void;
+ /** Create `dir` and any required parent directories. */
+ mkdirp: (dir: string) => void;
+
+ /** The fully resolved Svelte config. */
+ config: ValidatedConfig;
+ /** Information about prerendered pages and assets, if any. */
+ prerendered: Prerendered;
+ /** An array of all routes (including prerendered) */
+ routes: RouteDefinition[];
+
+ // TODO 3.0 remove this method
+ /**
+ * Create separate functions that map to one or more routes of your app.
+ * @param fn A function that groups a set of routes into an entry point
+ * @deprecated Use `builder.routes` instead
+ */
+ createEntries: (fn: (route: RouteDefinition) => AdapterEntry) => Promise;
+
+ /**
+ * Find all the assets imported by server files belonging to `routes`
+ */
+ findServerAssets: (routes: RouteDefinition[]) => string[];
+
+ /**
+ * Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps.
+ */
+ generateFallback: (dest: string) => Promise;
+
+ /**
+ * Generate a module exposing build-time environment variables as `$env/dynamic/public` or `$app/env/public` if the app uses it.
+ */
+ generateEnvModule: () => void;
+
+ /**
+ * Generate a server-side manifest to initialise the SvelteKit [server](https://svelte.dev/docs/kit/@sveltejs-kit#Server) with.
+ * @param opts a relative path to the base directory of the app and optionally in which format (esm or cjs) the manifest should be generated
+ */
+ generateManifest: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string;
+
+ /**
+ * Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`.
+ * @param name path to the file, relative to the build directory
+ */
+ getBuildDirectory: (name: string) => string;
+ /** Get the fully resolved path to the directory containing client-side assets, including the contents of your `static` directory. */
+ getClientDirectory: () => string;
+ /** Get the fully resolved path to the directory containing server-side code. */
+ getServerDirectory: () => string;
+ /** Get the application path including any configured `base` path, e.g. `my-base-path/_app`. */
+ getAppPath: () => string;
+
+ /**
+ * Write client assets to `dest`.
+ * @param dest the destination folder
+ * @returns an array of files written to `dest`
+ */
+ writeClient: (dest: string) => string[];
+ /**
+ * Write prerendered files to `dest`.
+ * @param dest the destination folder
+ * @returns an array of files written to `dest`
+ */
+ writePrerendered: (dest: string) => string[];
+ /**
+ * Write server-side code to `dest`.
+ * @param dest the destination folder
+ * @returns an array of files written to `dest`
+ */
+ writeServer: (dest: string) => string[];
+ /**
+ * Copy a file or directory.
+ * @param from the source file or directory
+ * @param to the destination file or directory
+ * @param opts.filter a function to determine whether a file or directory should be copied
+ * @param opts.replace a map of strings to replace
+ * @returns an array of files that were copied
+ */
+ copy: (
+ from: string,
+ to: string,
+ opts?: {
+ filter?(basename: string): boolean;
+ replace?: Record;
+ }
+ ) => string[];
+
+ /**
+ * Check if the server instrumentation file exists.
+ * @returns true if the server instrumentation file exists, false otherwise
+ * @since 2.31.0
+ */
+ hasServerInstrumentationFile: () => boolean;
+
+ /**
+ * 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.
+ *
+ * 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.
+ *
+ * @param options an object containing the following properties:
+ * @param options.entrypoint the path to the entrypoint to trace.
+ * @param options.instrumentation the path to the instrumentation file.
+ * @param options.start the name of the start file. This is what `entrypoint` will be renamed to.
+ * @param options.module configuration for the resulting entrypoint module.
+ * @param options.module.exports
+ * @param options.module.generateText a function that receives the relative paths to the instrumentation and start files, and generates the text of the module to be traced. If not provided, the default implementation will be used, which uses top-level await.
+ * @since 2.31.0
+ */
+ instrument: (args: {
+ entrypoint: string;
+ instrumentation: string;
+ start?: string;
+ module?:
+ | {
+ exports: string[];
+ }
+ | {
+ generateText: (args: { instrumentation: string; start: string }) => string;
+ };
+ }) => void;
+
+ /**
+ * Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals.
+ * @param {string} directory The directory containing the files to be compressed
+ */
+ compress: (directory: string) => Promise;
+}
+
+/**
+ * An extension of [`vite-plugin-svelte`'s options](https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/config.md#svelte-options).
+ */
+export interface Config extends SvelteConfig {
+ /**
+ * SvelteKit options.
+ *
+ * @see https://svelte.dev/docs/kit/configuration
+ */
+ kit?: KitConfig;
+ /** Any additional options required by tooling that integrates with Svelte. */
+ [key: string]: any;
+}
+
+export interface Cookies {
+ /**
+ * Gets a cookie that was previously set with `cookies.set`, or from the request headers.
+ * @param name the name of the cookie
+ * @param opts the options, passed directly to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)
+ */
+ get: (name: string, opts?: import('cookie').CookieParseOptions) => string | undefined;
+
+ /**
+ * Gets all cookies that were previously set with `cookies.set`, or from the request headers.
+ * @param opts the options, passed directly to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)
+ */
+ getAll: (opts?: import('cookie').CookieParseOptions) => Array<{ name: string; value: string }>;
+
+ /**
+ * 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` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`.
+ *
+ * You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children
+ * @param name the name of the cookie
+ * @param value the cookie value
+ * @param opts the options, passed directly to `cookie.serialize`. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+ */
+ set: (
+ name: string,
+ value: string,
+ opts: import('cookie').CookieSerializeOptions & { path: string }
+ ) => void;
+
+ /**
+ * Deletes a cookie by setting its value to an empty string and setting the expiry date in the past.
+ *
+ * You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children
+ * @param name the name of the cookie
+ * @param opts the options, passed directly to `cookie.serialize`. The `path` must match the path of the cookie you want to delete. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+ */
+ delete: (name: string, opts: import('cookie').CookieSerializeOptions & { path: string }) => void;
+
+ /**
+ * Serialize a cookie name-value pair into a `Set-Cookie` header string, but don't apply it to the response.
+ *
+ * The `httpOnly` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`.
+ *
+ * You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children
+ *
+ * @param name the name of the cookie
+ * @param value the cookie value
+ * @param opts the options, passed directly to `cookie.serialize`. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)
+ */
+ serialize: (
+ name: string,
+ value: string,
+ opts: import('cookie').CookieSerializeOptions & { path: string }
+ ) => string;
+}
+
+/**
+ * A collection of functions that influence the environment during dev, build and prerendering
+ */
+export interface Emulator {
+ /**
+ * A function that is called with the current route `config` and `prerender` option
+ * and returns an `App.Platform` object
+ */
+ platform?(details: { config: any; prerender: PrerenderOption }): MaybePromise;
+}
+
+export interface KitConfig {
+ /**
+ * Your [adapter](https://svelte.dev/docs/kit/adapters) is run when executing `vite build`. It determines how the output is converted for different platforms.
+ * @default undefined
+ */
+ adapter?: Adapter;
+ /**
+ * An object containing zero or more aliases used to replace values in `import` statements. These aliases are automatically passed to Vite and TypeScript.
+ *
+ * ```js
+ * /// file: svelte.config.js
+ * /// type: import('@sveltejs/kit').Config
+ * const config = {
+ * kit: {
+ * alias: {
+ * // this will match a file
+ * 'my-file': 'path/to/my-file.js',
+ *
+ * // this will match a directory and its contents
+ * // (`my-directory/x` resolves to `path/to/my-directory/x`)
+ * 'my-directory': 'path/to/my-directory',
+ *
+ * // an alias ending /* will only match
+ * // the contents of a directory, not the directory itself
+ * 'my-directory/*': 'path/to/my-directory/*'
+ * }
+ * }
+ * };
+ * ```
+ *
+ * > [!NOTE] You will need to run `npm run dev` to have SvelteKit automatically generate the required alias configuration in `jsconfig.json` or `tsconfig.json`.
+ * @default {}
+ */
+ alias?: Record;
+ /**
+ * The directory where SvelteKit keeps its stuff, including static assets (such as JS and CSS) and internally-used routes.
+ *
+ * If `paths.assets` is specified, there will be two app directories — `${paths.assets}/${appDir}` and `${paths.base}/${appDir}`.
+ * @default "_app"
+ */
+ appDir?: string;
+ /**
+ * [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy) configuration. CSP helps to protect your users against cross-site scripting (XSS) attacks, by limiting the places resources can be loaded from. For example, a configuration like this...
+ *
+ * ```js
+ * /// file: svelte.config.js
+ * /// type: import('@sveltejs/kit').Config
+ * const config = {
+ * kit: {
+ * csp: {
+ * directives: {
+ * 'script-src': ['self']
+ * },
+ * // must be specified with either the `report-uri` or `report-to` directives, or both
+ * reportOnly: {
+ * 'script-src': ['self'],
+ * 'report-uri': ['/']
+ * }
+ * }
+ * }
+ * };
+ *
+ * export default config;
+ * ```
+ *
+ * ...would prevent scripts loading from external sites. SvelteKit will augment the specified directives with nonces or hashes (depending on `mode`) for any inline styles and scripts it generates.
+ *
+ * To add a nonce for scripts and links manually included in `src/app.html`, you may use the placeholder `%sveltekit.nonce%` (for example `
+ *
+ *
+ *
+ *
+ *
+ * ```
+ * @default 'split'
+ * @since 2.13.0
+ */
+ bundleStrategy?: 'split' | 'single' | 'inline';
+ };
+ paths?: {
+ /**
+ * An absolute path that your app's files are served from. This is useful if your files are served from a storage bucket of some kind.
+ * @default ""
+ */
+ assets?: '' | `http://${string}` | `https://${string}`;
+ /**
+ * A root-relative path that must start, but not end with `/` (e.g. `/base-path`), unless it is the empty string. This specifies where your app is served from and allows the app to live on a non-root path. Note that you need to prepend all your root-relative links with the base value or they will point to the root of your domain, not your `base` (this is how the browser works). You can use [`base` from `$app/paths`](https://svelte.dev/docs/kit/$app-paths#base) for that: `Link`. If you find yourself writing this often, it may make sense to extract this into a reusable component.
+ * @default ""
+ */
+ base?: '' | `/${string}`;
+ /**
+ * Whether to use relative asset paths.
+ *
+ * If `true`, `base` and `assets` imported from `$app/paths` will be replaced with relative asset paths during server-side rendering, resulting in more portable HTML.
+ * If `false`, `%sveltekit.assets%` and references to build artifacts will always be root-relative paths, unless `paths.assets` is an external URL
+ *
+ * [Single-page app](https://svelte.dev/docs/kit/single-page-apps) fallback pages will always use absolute paths, regardless of this setting.
+ *
+ * If your app uses a `` element, you should set this to `false`, otherwise asset URLs will incorrectly be resolved against the `` URL rather than the current page.
+ *
+ * In 1.0, `undefined` was a valid value, which was set by default. In that case, if `paths.assets` was not external, SvelteKit would replace `%sveltekit.assets%` with a relative path and use relative paths to reference build artifacts, but `base` and `assets` imported from `$app/paths` would be as specified in your config.
+ *
+ * @default true
+ * @since 1.9.0
+ */
+ relative?: boolean;
+ };
+ /**
+ * See [Prerendering](https://svelte.dev/docs/kit/page-options#prerender).
+ */
+ prerender?: {
+ /**
+ * How many pages can be prerendered simultaneously. JS is single-threaded, but in cases where prerendering performance is network-bound (for example loading content from a remote CMS) this can speed things up by processing other tasks while waiting on the network response.
+ * @default 1
+ */
+ concurrency?: number;
+ /**
+ * Whether SvelteKit should find pages to prerender by following links from `entries`.
+ * @default true
+ */
+ crawl?: boolean;
+ /**
+ * An array of pages to prerender, or start crawling from (if `crawl: true`). The `*` string includes all routes containing no required `[parameters]` with optional parameters included as being empty (since SvelteKit doesn't know what value any parameters should have).
+ * @default ["*"]
+ */
+ entries?: Array<'*' | `/${string}`>;
+ /**
+ * How to respond to HTTP errors encountered while prerendering the app.
+ *
+ * - `'fail'` — fail the build
+ * - `'ignore'` - silently ignore the failure and continue
+ * - `'warn'` — continue, but print a warning
+ * - `(details) => void` — a custom error handler that takes a `details` object with `status`, `path`, `referrer`, `referenceType` and `message` properties. If you `throw` from this function, the build will fail
+ *
+ * ```js
+ * /// file: svelte.config.js
+ * /// type: import('@sveltejs/kit').Config
+ * const config = {
+ * kit: {
+ * prerender: {
+ * handleHttpError: ({ path, referrer, message }) => {
+ * // ignore deliberate link to shiny 404 page
+ * if (path === '/not-found' && referrer === '/blog/how-we-built-our-404-page') {
+ * return;
+ * }
+ *
+ * // otherwise fail the build
+ * throw new Error(message);
+ * }
+ * }
+ * }
+ * };
+ * ```
+ *
+ * @default "fail"
+ * @since 1.15.7
+ */
+ handleHttpError?: PrerenderHttpErrorHandlerValue;
+ /**
+ * How to respond when hash links from one prerendered page to another don't correspond to an `id` on the destination page.
+ *
+ * - `'fail'` — fail the build
+ * - `'ignore'` - silently ignore the failure and continue
+ * - `'warn'` — continue, but print a warning
+ * - `(details) => void` — a custom error handler that takes a `details` object with `path`, `id`, `referrers` and `message` properties. If you `throw` from this function, the build will fail
+ *
+ * @default "fail"
+ * @since 1.15.7
+ */
+ handleMissingId?: PrerenderMissingIdHandlerValue;
+ /**
+ * How to respond when an entry generated by the `entries` export doesn't match the route it was generated from.
+ *
+ * - `'fail'` — fail the build
+ * - `'ignore'` - silently ignore the failure and continue
+ * - `'warn'` — continue, but print a warning
+ * - `(details) => void` — a custom error handler that takes a `details` object with `generatedFromId`, `entry`, `matchedId` and `message` properties. If you `throw` from this function, the build will fail
+ *
+ * @default "fail"
+ * @since 1.16.0
+ */
+ handleEntryGeneratorMismatch?: PrerenderEntryGeneratorMismatchHandlerValue;
+ /**
+ * How to respond when a route is marked as prerenderable but has not been prerendered.
+ *
+ * - `'fail'` — fail the build
+ * - `'ignore'` - silently ignore the failure and continue
+ * - `'warn'` — continue, but print a warning
+ * - `(details) => void` — a custom error handler that takes a `details` object with a `routes` property which contains all routes that haven't been prerendered. If you `throw` from this function, the build will fail
+ *
+ * The default behavior is to fail the build. This may be undesirable when you know that some of your routes may never be reached under certain
+ * circumstances such as a CMS not returning data for a specific area, resulting in certain routes never being reached.
+ *
+ * @default "fail"
+ * @since 2.16.0
+ */
+ handleUnseenRoutes?: PrerenderUnseenRoutesHandlerValue;
+ /**
+ * How to respond when SvelteKit encounters a URL it cannot parse while crawling prerendered HTML (for example, an AT Protocol URL such as `at://did:plc:...`).
+ *
+ * - `'fail'` — fail the build
+ * - `'ignore'` - silently ignore the failure and continue
+ * - `'warn'` — continue, but print a warning
+ * - `(details) => void` — a custom error handler that takes a `details` object with `href`, `referrer` and `message` properties. If you `throw` from this function, the build will fail
+ *
+ * @default "fail"
+ * @since 2.67.0
+ */
+ handleInvalidUrl?: PrerenderInvalidUrlHandlerValue;
+ /**
+ * The value of `url.origin` during prerendering; useful if it is included in rendered content.
+ * @default "http://sveltekit-prerender"
+ */
+ origin?: string;
+ };
+ router?: {
+ /**
+ * What type of client-side router to use.
+ * - `'pathname'` is the default and means the current URL pathname determines the route
+ * - `'hash'` means the route is determined by `location.hash`. In this case, SSR and prerendering are disabled. This is only recommended if `pathname` is not an option, for example because you don't control the webserver where your app is deployed.
+ * It comes with some caveats: you can't use server-side rendering (or indeed any server logic), and you have to make sure that the links in your app all start with #/, or they won't work. Beyond that, everything works exactly like a normal SvelteKit app.
+ *
+ * @default "pathname"
+ * @since 2.14.0
+ */
+ type?: 'pathname' | 'hash';
+ /**
+ * How to determine which route to load when navigating to a new page.
+ *
+ * By default, SvelteKit will serve a route manifest to the browser.
+ * When navigating, this manifest is used (along with the `reroute` hook, if it exists) to determine which components to load and which `load` functions to run.
+ * Because everything happens on the client, this decision can be made immediately. The drawback is that the manifest needs to be
+ * loaded and parsed before the first navigation can happen, which may have an impact if your app contains many routes.
+ *
+ * Alternatively, SvelteKit can determine the route on the server. This means that for every navigation to a path that has not yet been visited, the server will be asked to determine the route.
+ * This has several advantages:
+ * - The client does not need to load the routing manifest upfront, which can lead to faster initial page loads
+ * - The list of routes is hidden from public view
+ * - The server has an opportunity to intercept each navigation (for example through a middleware), enabling (for example) A/B testing opaque to SvelteKit
+
+ * The drawback is that for unvisited paths, resolution will take slightly longer (though this is mitigated by [preloading](https://svelte.dev/docs/kit/link-options#data-sveltekit-preload-data)).
+ *
+ * > [!NOTE] When using server-side route resolution and prerendering, the resolution is prerendered along with the route itself.
+ *
+ * @default "client"
+ * @since 2.17.0
+ */
+ resolution?: 'client' | 'server';
+ };
+ serviceWorker?: {
+ /**
+ * Determine which files in your `static` directory will be available in `$service-worker.files`.
+ * @default (filename) => !/\.DS_Store/.test(filename)
+ */
+ files?: (file: string) => boolean;
+ } & (
+ | {
+ /**
+ * Whether to automatically register the service worker, if it exists.
+ * @default true
+ */
+ register: true;
+ /**
+ * Options for serviceWorker.register("...", options);
+ */
+ options?: RegistrationOptions;
+ }
+ | {
+ /**
+ * Whether to automatically register the service worker, if it exists.
+ * @default true
+ */
+ register?: false;
+ }
+ );
+ typescript?: {
+ /**
+ * A function that allows you to edit the generated `tsconfig.json`. You can mutate the config (recommended) or return a new one.
+ * This is useful for extending a shared `tsconfig.json` in a monorepo root, for example.
+ *
+ * Note that any paths configured here should be relative to the generated config file, which is written to `.svelte-kit/tsconfig.json`.
+ *
+ * @default (config) => config
+ * @since 1.3.0
+ */
+ config?: (config: Record) => Record | void;
+ };
+ /**
+ * Client-side navigation can be buggy if you deploy a new version of your app while people are using it. If the code for the new page is already loaded, it may have stale content; if it isn't, the app's route manifest may point to a JavaScript file that no longer exists.
+ * SvelteKit helps you solve this problem through version management.
+ * If SvelteKit encounters an error while loading the page and detects that a new version has been deployed (using the `name` specified here, which defaults to a timestamp of the build) it will fall back to traditional full-page navigation.
+ * Not all navigations will result in an error though, for example if the JavaScript for the next page is already loaded. If you still want to force a full-page navigation in these cases, use techniques such as setting the `pollInterval` and then using `beforeNavigate`:
+ * ```html
+ * /// file: +layout.svelte
+ *
+ * ```
+ *
+ * If you set `pollInterval` to a non-zero value, SvelteKit will poll for new versions in the background and set the value of [`updated.current`](https://svelte.dev/docs/kit/$app-state#updated) `true` when it detects one.
+ */
+ version?: {
+ /**
+ * The current app version string. If specified, this must be deterministic (e.g. a commit ref rather than `Math.random()` or `Date.now().toString()`), otherwise defaults to a timestamp of the build.
+ *
+ * For example, to use the current commit hash, you could do use `git rev-parse HEAD`:
+ *
+ * ```js
+ * /// file: svelte.config.js
+ * import * as child_process from 'node:child_process';
+ *
+ * export default {
+ * kit: {
+ * version: {
+ * name: child_process.execSync('git rev-parse HEAD').toString().trim()
+ * }
+ * }
+ * };
+ * ```
+ */
+ name?: string;
+ /**
+ * The interval in milliseconds to poll for version changes. If this is `0`, no polling occurs.
+ * @default 0
+ */
+ pollInterval?: number;
+ };
+}
+
+/**
+ * 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) => MaybePromise;
+}) => MaybePromise;
+
+/**
+ * The server-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while responding to a request.
+ *
+ * If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event.
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleServerError = (input: {
+ error: unknown;
+ event: RequestEvent;
+ status: number;
+ message: string;
+}) => MaybePromise;
+
+/**
+ * The [`handleValidationError`](https://svelte.dev/docs/kit/hooks#handleValidationError) hook runs when the argument to a remote function fails validation.
+ *
+ * It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.
+ */
+export type HandleValidationError =
+ (input: { issues: Issue[]; event: RequestEvent }) => MaybePromise;
+
+/**
+ * The client-side [`handleError`](https://svelte.dev/docs/kit/hooks#handleError) hook runs when an unexpected error is thrown while navigating.
+ *
+ * If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event.
+ * Make sure that this function _never_ throws an error.
+ */
+export type HandleClientError = (input: {
+ error: unknown;
+ event: NavigationEvent;
+ status: number;
+ message: string;
+}) => MaybePromise;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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';
+ *
+ * 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;
+
+/**
+ * A member of the [`transport`](https://svelte.dev/docs/kit/hooks#transport) hook.
+ */
+export interface Transporter<
+ T = any,
+ U = Exclude
+> {
+ encode: (value: T) => false | U;
+ decode: (data: U) => T;
+}
+
+/**
+ * The generic form of `PageLoad` and `LayoutLoad`. You should import those from `./$types` (see [generated types](https://svelte.dev/docs/kit/types#Generated-types))
+ * rather than using `Load` directly.
+ */
+export type Load<
+ Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+ InputData extends Record | null = Record | null,
+ ParentData extends Record = Record,
+ OutputData extends Record | void = Record | void,
+ RouteId extends AppRouteId | null = AppRouteId | null
+> = (event: LoadEvent) => MaybePromise;
+
+/**
+ * The generic form of `PageLoadEvent` and `LayoutLoadEvent`. You should import those from `./$types` (see [generated types](https://svelte.dev/docs/kit/types#Generated-types))
+ * rather than using `LoadEvent` directly.
+ */
+export interface LoadEvent<
+ Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+ Data extends Record | null = Record | null,
+ ParentData extends Record = Record,
+ RouteId extends AppRouteId | null = AppRouteId | null
+> extends NavigationEvent {
+ /**
+ * `fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features:
+ *
+ * - It can be used to make credentialed requests on the server, as it inherits the `cookie` and `authorization` headers for the page request.
+ * - It can make relative requests on the server (ordinarily, `fetch` requires a URL with an origin when used in a server context).
+ * - Internal requests (e.g. for `+server.js` routes) go directly to the handler function when running on the server, without the overhead of an HTTP call.
+ * - During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into the `text` and `json` methods of the `Response` object. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](https://svelte.dev/docs/kit/hooks#handle)
+ * - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request.
+ *
+ * You can learn more about making credentialed requests with cookies [here](https://svelte.dev/docs/kit/load#Cookies)
+ */
+ fetch: typeof fetch;
+ /**
+ * Contains the data returned by the route's server `load` function (in `+layout.server.js` or `+page.server.js`), if any.
+ */
+ data: Data;
+ /**
+ * If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example:
+ *
+ * ```js
+ * /// file: src/routes/blog/+page.js
+ * export async function load({ fetch, setHeaders }) {
+ * const url = `https://cms.example.com/articles.json`;
+ * const response = await fetch(url);
+ *
+ * setHeaders({
+ * age: response.headers.get('age'),
+ * 'cache-control': response.headers.get('cache-control')
+ * });
+ *
+ * return response.json();
+ * }
+ * ```
+ *
+ * Setting the same header multiple times (even in separate `load` functions) is an error — you can only set a given header once.
+ *
+ * You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](https://svelte.dev/docs/kit/@sveltejs-kit#Cookies) API in a server-only `load` function instead.
+ *
+ * `setHeaders` has no effect when a `load` function runs in the browser.
+ */
+ setHeaders: (headers: Record) => void;
+ /**
+ * `await parent()` returns data from parent `+layout.js` `load` functions.
+ * Implicitly, a missing `+layout.js` is treated as a `({ data }) => data` function, meaning that it will return and forward data from parent `+layout.server.js` files.
+ *
+ * Be careful not to introduce accidental waterfalls when using `await parent()`. If for example you only want to merge parent data into the returned output, call it _after_ fetching your other data.
+ */
+ parent: () => Promise;
+ /**
+ * This function declares that the `load` function has a _dependency_ on one or more URLs or custom identifiers, which can subsequently be used with [`invalidate()`](https://svelte.dev/docs/kit/$app-navigation#invalidate) to cause `load` to rerun.
+ *
+ * Most of the time you won't need this, as `fetch` calls `depends` on your behalf — it's only necessary if you're using a custom API client that bypasses `fetch`.
+ *
+ * URLs can be absolute or relative to the page being loaded, and must be [encoded](https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding).
+ *
+ * Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the [URI specification](https://www.rfc-editor.org/rfc/rfc3986.html).
+ *
+ * The following example shows how to use `depends` to register a dependency on a custom identifier, which is `invalidate`d after a button click, making the `load` function rerun.
+ *
+ * ```js
+ * /// file: src/routes/+page.js
+ * let count = 0;
+ * export async function load({ depends }) {
+ * depends('increase:count');
+ *
+ * return { count: count++ };
+ * }
+ * ```
+ *
+ * ```html
+ * /// file: src/routes/+page.svelte
+ *
+ *
+ *
{data.count}
+ *
+ * ```
+ */
+ depends: (...deps: Array<`${string}:${string}`>) => void;
+ /**
+ * Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example:
+ *
+ * ```js
+ * /// file: src/routes/+page.server.js
+ * export async function load({ untrack, url }) {
+ * // Untrack url.pathname so that path changes don't trigger a rerun
+ * if (untrack(() => url.pathname === '/')) {
+ * return { message: 'Welcome!' };
+ * }
+ * }
+ * ```
+ */
+ untrack: (fn: () => T) => T;
+
+ /**
+ * Access to spans for tracing. If tracing is not enabled or the function is being run in the browser, these spans will do nothing.
+ * @since 2.31.0
+ */
+ tracing: {
+ /** Whether tracing is enabled. */
+ enabled: boolean;
+ /** The root span for the request. This span is named `sveltekit.handle.root`. */
+ root: Span;
+ /** The span associated with the current `load` function. */
+ current: Span;
+ };
+}
+
+export interface NavigationEvent<
+ Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+ RouteId extends AppRouteId | null = AppRouteId | null
+> {
+ /**
+ * The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object
+ */
+ params: Params;
+ /**
+ * Info about the current route
+ */
+ route: {
+ /**
+ * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+ */
+ id: RouteId;
+ };
+ /**
+ * The URL of the current page
+ */
+ url: URL;
+}
+
+/**
+ * Information about the target of a specific navigation.
+ */
+export interface NavigationTarget<
+ Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>,
+ RouteId extends AppRouteId | null = AppRouteId | null
+> {
+ /**
+ * Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.
+ * Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).
+ */
+ params: Params | null;
+ /**
+ * Info about the target route
+ */
+ route: {
+ /**
+ * The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.
+ */
+ id: RouteId | null;
+ };
+ /**
+ * The URL that is navigated to
+ */
+ url: URL;
+ /**
+ * The scroll position associated with this navigation.
+ *
+ * For the `from` target, this is the scroll position at the moment of navigation.
+ *
+ * For the `to` target, this represents the scroll position that will be or was restored:
+ * - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button)
+ * and will be `null` for other navigation types, since the final scroll position isn't known
+ * ahead of time.
+ * - In `afterNavigate`, this is always the scroll position that was applied after the navigation
+ * completed.
+ */
+ scroll: { x: number; y: number } | null;
+}
+
+/**
+ * - `enter`: The app has hydrated/started
+ * - `form`: The user submitted a `