@vigla/kit 0.0.0-stage → 0.1.1

package/src/sync/route-paths.ts

@@ -0,0 +1,59 @@
+import { decodeEscape, invalidParam, routeSegments } from '../shared/routing/index.ts';
+import type { Route } from '../types/internal/routes.ts';
+import type { SyncErrors } from './errors.ts';
+
+export function validateRoute(id: string, e: SyncErrors): void {
+	const literal = id.replace(
+		/\[([ux])\+([^\]]+)\]/gi,
+		(whole: string, kind: string, code: string) => {
+			if (whole !== whole.toLowerCase()) e.route_escape_uppercase({ id });
+			if (!/^[0-9a-f]+$/.test(code)) e.route_escape_invalid({ id });
+			if (kind === 'x' && code.length !== 2) e.route_escape_hex_length({ id });
+			if (kind === 'u' && (code.length < 4 || code.length > 6))
+				e.route_escape_unicode_length({ id });
+			return decodeEscape(code);
+		}
+	);
+	if (literal.includes('][')) e.route_params_adjacent({ id });
+	if ((id.match(/\[/g)?.length ?? 0) !== (id.match(/\]/g)?.length ?? 0))
+		e.route_unbalanced_brackets({ id });
+	if (id.includes('#')) e.route_hash_character({ id, suggestion: id.replaceAll('#', '[x+23]') });
+	if (/\[\.\.\.[\w-]+(?:=[\w-]+)?\]\/\[\[/.test(id)) e.route_optional_after_rest({ id });
+	if (id.includes('[[...')) e.route_optional_rest({ id });
+	const param = invalidParam(id);
+	if (param !== undefined) e.route_param_invalid({ id, param });
+}
+
+export function validateConflicts(routes: readonly Route[], e: SyncErrors): void {
+	const seen = new Map<string, string>();
+	for (const route of routes) {
+		if (route.leaf === null && !route.endpoint) continue;
+		const normalized = routeSegments(route.id)
+			.join('/')
+			.replace(/\[[ux]\+([0-9a-f]+)\]/g, (_, code: string) =>
+				decodeEscape(code).replaceAll('/', '%2f')
+			)
+			.replace(
+				/\[(?:(\[)|(\.\.\.))?([^\]=]+)(?:=([^\]]+))?\]\]?/g,
+				(_, optional: string, rest: string, _name: string, matcher: string) =>
+					`<${optional ? '?' : ''}${rest ?? ''}${matcher ? '=' + matcher : '*'}>`
+			);
+		let keys = [normalized];
+		if (!/<\?.+?>$/.test(normalized)) {
+			const pieces = normalized.split(/<\?(.+?)>/g);
+			keys = [pieces[0]!];
+			for (let index = 1; index < pieces.length; index += 2) {
+				keys = keys.flatMap((prefix) => [
+					prefix + pieces[index + 1]!,
+					prefix + `<${pieces[index]!}>` + pieces[index + 1]!
+				]);
+			}
+		}
+		for (const value of keys) {
+			const key = value.replace(/\/{2,}/g, '/').replace(/^\/|\/$/g, '');
+			const first = seen.get(key);
+			if (first !== undefined && first !== route.id) e.route_conflict({ first, second: route.id });
+			seen.set(key, route.id);
+		}
+	}
+}

package/src/sync/route-types.ts

@@ -0,0 +1,183 @@
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ValidatedConfig } from '../types/builder.ts';
+import type { PageNode, Route, RouteParam, RouteTree } from '../types/internal/routes.ts';
+import { parameterType } from './app-types.ts';
+import { importPath, relativeFile, writeChanged } from './files.ts';
+import { createProxy, type TypeProxy } from './proxy.ts';
+
+const helpers = [
+	'type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;',
+	'type Defined<T> = T extends null | undefined ? {} : T;',
+	'type Merge<A, B> = Expand<Omit<A, keyof Defined<B>> & Defined<B>>;',
+	'type OptionalUnion<U extends Record<string, any>, K extends PropertyKey = U extends U ? keyof U : never> = U extends unknown ? { [P in Exclude<K, keyof U>]?: never } & U : never;',
+	'export type RequiredKeys<T> = { [K in keyof T]-?: {} extends { [P in K]: T[K] } ? never : K; }[keyof T];',
+	'type Output<T> = Omit<App.PageData, RequiredKeys<T>> & Partial<Pick<App.PageData, keyof T & keyof App.PageData>> & Record<string, any>;',
+	'type WithVoid<T> = {} extends T ? T | void : T;',
+	'export type Snapshot<T = any> = Kit.Snapshot<T>;',
+	'export type ErrorProps = { error: App.Error };'
+].join('\n');
+
+export function writeRouteTypes(
+	config: ValidatedConfig,
+	tree: RouteTree,
+	root: string,
+	name: string
+): void {
+	const routesDir = relativeFile(root, config.files.routes).replace(/\.\.\//g, '');
+	const base = join(config.outDir, 'types');
+	const output = (route: Route): string => join(base, routesDir, route.id.slice(1));
+	const owners = new Map<number, Route>();
+	for (const route of tree.routes)
+		for (const index of [route.layout, route.leaf]) if (index !== null) owners.set(index, route);
+	const files = new Set<string>();
+	const proxies = new Map<string, TypeProxy | null>();
+	const proxy = (file: string | undefined, route: Route): TypeProxy | null => {
+		if (!file) return null;
+		const key = file + ':' + route.id;
+		if (!proxies.has(key)) proxies.set(key, createProxy(file, root, output(route)));
+		const result = proxies.get(key)!;
+		if (result?.file) files.add(result.file);
+		return result;
+	};
+	const parentType = (node: PageNode, route: Route, kind: string): string => {
+		const ancestors: string[] = [];
+		let parent = node.parent;
+		while (parent !== null) {
+			const owner = owners.get(parent)!;
+			const reference =
+				owner === route
+					? kind
+					: `import(${JSON.stringify(importPath(output(route), join(output(owner), '$types.js')))}).${kind}`;
+			ancestors.unshift(reference);
+			parent = tree.nodes[parent]!.parent;
+		}
+		return ancestors.reduce((type, next) => `Merge<${type}, ${next}>`, '{}');
+	};
+	const dataType = (result: TypeProxy | null, fallback: string): string =>
+		!result
+			? 'unknown'
+			: result.exports.has('load')
+				? `Kit.LoadProperties<Awaited<ReturnType<typeof import(${JSON.stringify(result.module)}).load>>>`
+				: fallback;
+	for (const route of tree.routes) {
+		if (route.leaf === null && route.layout === null && !route.endpoint) continue;
+		const lines = [
+			`import type * as Kit from ${JSON.stringify(name)};`,
+			helpers,
+			`type RouteId = ${JSON.stringify(route.id)};`,
+			`type RouteParams = ${parameterType(route.params, output(route), root, tree.params, name)};`
+		];
+		if (route.params.length)
+			lines.push('export type EntryGenerator = () => RouteParams[] | Promise<RouteParams[]>;');
+		const nodeTypes = (index: number, page: boolean, allLoads: boolean): void => {
+			const node = tree.nodes[index]!;
+			const prefix = page ? 'Page' : 'Layout';
+			const params = page ? 'RouteParams' : 'LayoutParams';
+			const id = page ? 'RouteId' : 'LayoutRouteId';
+			const server = proxy(node.server, route);
+			const universal = proxy(node.universal, route);
+			lines.push(
+				`type ${prefix}ServerParentData = ${parentType(node, route, 'LayoutServerData')};`
+			);
+			lines.push(`type ${prefix}ParentData = ${parentType(node, route, 'LayoutData')};`);
+			const serverData = node.server ? dataType(server, 'null') : 'null';
+			lines.push(
+				`export type ${prefix}ServerData = ${serverData === 'null' ? 'null' : `Expand<OptionalUnion<Defined<${serverData}>>>`};`
+			);
+			if (node.server) {
+				const shape =
+					node.universal || (!page && allLoads)
+						? 'Partial<App.PageData> & Record<string, any> | void'
+						: `WithVoid<Output<${prefix}ServerParentData>>`;
+				lines.push(
+					`export type ${prefix}ServerLoad<T extends ${shape} = ${shape}> = Kit.ServerLoad<${params}, ${prefix}ServerParentData, T, ${id}>;`
+				);
+				lines.push(`export type ${prefix}ServerLoadEvent = Parameters<${prefix}ServerLoad>[0];`);
+			}
+			let own = `${prefix}ServerData`;
+			if (node.universal) {
+				own = dataType(universal, `Merge<${prefix}ParentData, ${prefix}ServerData>`);
+				const shape =
+					!page && allLoads
+						? 'Partial<App.PageData> & Record<string, any> | void'
+						: `WithVoid<Output<${prefix}ParentData>>`;
+				lines.push(
+					`export type ${prefix}Load<T extends ${shape} = ${shape}> = Kit.Load<${params}, ${prefix}ServerData, ${prefix}ParentData, T, ${id}>;`
+				);
+				lines.push(`export type ${prefix}LoadEvent = Parameters<${prefix}Load>[0];`);
+			}
+			lines.push(
+				`export type ${prefix}Data = Merge<${prefix}ParentData, OptionalUnion<Defined<${own}>>>;`
+			);
+			if (page && node.server) {
+				if (server?.exports.has('actions')) {
+					lines.push(
+						`type ActionsExport = typeof import(${JSON.stringify(server.module)}).actions;`
+					);
+					lines.push('export type ActionData = Expand<Kit.AwaitedActions<ActionsExport>> | null;');
+					lines.push('type Success<T> = T extends Kit.ActionFailure<any> | void ? never : T;');
+					lines.push('type Failure<T> = T extends Kit.ActionFailure<infer U> ? U : never;');
+					lines.push('type Results = Awaited<ReturnType<ActionsExport[keyof ActionsExport]>>;');
+					lines.push(
+						"export type SubmitFunction = import('$app/forms').SubmitFunction<Expand<Success<Results>>, Expand<Failure<Results>>>;"
+					);
+				} else lines.push('export type ActionData = unknown;');
+				lines.push(
+					'export type Action<T extends Record<string, any> | void = Record<string, any> | void> = Kit.Action<RouteParams, T, RouteId>;'
+				);
+				lines.push(
+					'export type Actions<T extends Record<string, any> | void = Record<string, any> | void> = Kit.Actions<RouteParams, T, RouteId>;'
+				);
+			}
+		};
+		if (route.leaf !== null) {
+			nodeTypes(route.leaf, true, true);
+			lines.push(
+				`export type PageProps = { params: RouteParams; data: PageData${tree.nodes[route.leaf]!.server ? '; form: ActionData' : ''} };`
+			);
+		}
+		if (route.layout !== null) {
+			const children = tree.routes.filter((child) => child.page?.layouts.includes(route.layout!));
+			const params: RouteParam[] = [...route.params];
+			for (const child of children)
+				params.push(...child.params.map((param) => ({ ...param, optional: true })));
+			lines.push(
+				`type LayoutParams = ${parameterType(params, output(route), root, tree.params, name)};`
+			);
+			lines.push(
+				`type LayoutRouteId = ${[...new Set(children.map((child) => JSON.stringify(child.id)))].concat(route.id === '/' ? ['null'] : []).join(' | ') || 'never'};`
+			);
+			const allLoads = children.every((child) => {
+				const leaf = tree.nodes[child.leaf!]!;
+				if (!leaf.server && !leaf.universal) return false;
+				return (
+					(!leaf.server || proxy(leaf.server, child)?.exports.has('load')) &&
+					(!leaf.universal || proxy(leaf.universal, child)?.exports.has('load'))
+				);
+			});
+			nodeTypes(route.layout, false, allLoads);
+			lines.push(
+				'export type LayoutProps = { params: LayoutParams; data: LayoutData; children: (...args: any[]) => any };'
+			);
+		}
+		if (route.endpoint)
+			lines.push('export type RequestHandler = Kit.RequestHandler<RouteParams, RouteId>;');
+		if (
+			route.endpoint ||
+			(route.leaf !== null && tree.nodes[route.leaf]!.server) ||
+			(route.layout !== null && tree.nodes[route.layout]!.server)
+		)
+			lines.push('export type RequestEvent = Kit.RequestEvent<RouteParams, RouteId>;');
+		const destination = join(output(route), '$types.d.ts');
+		writeChanged(destination, lines.join('\n') + '\n');
+		files.add(destination);
+	}
+	const metadata = join(base, 'generated-files.json');
+	if (existsSync(metadata)) {
+		const previous = JSON.parse(readFileSync(metadata, 'utf8')) as string[];
+		for (const file of previous)
+			if (!files.has(file) && file.startsWith(base + '/')) rmSync(file, { force: true });
+	}
+	writeChanged(metadata, JSON.stringify([...files].sort()));
+}

package/src/sync/typescript.ts

@@ -0,0 +1,269 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import type { ValidatedConfig } from '../types/builder.ts';
+import { ConfigErrors } from '../config/errors.ts';
+import type { Diagnostics } from '../shared/diagnostics.ts';
+import { filesUnder, posix, relativeFile, writeChanged } from './files.ts';
+import { SyncErrors } from './errors.ts';
+
+interface CompilerOptions {
+	paths?: Record<string, string[]>;
+	rootDirs?: string[];
+	types?: string[];
+	[key: string]: unknown;
+}
+interface ProjectConfig {
+	extends?: string | string[];
+	compilerOptions?: CompilerOptions;
+	include?: string[];
+	exclude?: string[];
+	[key: string]: unknown;
+}
+const required = { verbatimModuleSyntax: true, isolatedModules: true };
+const recommended = {
+	allowJs: true,
+	checkJs: true,
+	forceConsistentCasingInFileNames: true,
+	resolveJsonModule: true,
+	moduleDetection: 'force',
+	moduleResolution: 'bundler',
+	allowImportingTsExtensions: true,
+	module: 'esnext',
+	target: 'esnext',
+	skipLibCheck: true,
+	esModuleInterop: true,
+	noEmit: true
+};
+
+function parseConfig(file: string, errors: SyncErrors): ProjectConfig {
+	const source = readFileSync(file, 'utf8');
+	let clean = '';
+	let state: 'string' | 'line' | 'block' | null = null;
+	for (let i = 0; i < source.length; i++) {
+		const char = source[i]!;
+		const pair = source.slice(i, i + 2);
+		if (state === 'string') {
+			clean += char;
+			if (char === '\\') clean += source[++i] ?? '';
+			else if (char === '"') state = null;
+		} else if (state === 'line') {
+			clean += char === '\n' ? '\n' : ' ';
+			if (char === '\n') state = null;
+		} else if (state === 'block') {
+			if (pair === '*/') {
+				clean += '  ';
+				i++;
+				state = null;
+			} else clean += char === '\n' ? '\n' : ' ';
+		} else if (pair === '//' || pair === '/*') {
+			state = pair === '//' ? 'line' : 'block';
+			clean += '  ';
+			i++;
+		} else {
+			clean += char;
+			if (char === '"') state = 'string';
+		}
+	}
+	const characters = clean.split('');
+	let quoted = false;
+	for (let i = 0; i < characters.length; i++) {
+		if (quoted && characters[i] === '\\') {
+			i++;
+			continue;
+		}
+		if (characters[i] === '"') {
+			quoted = !quoted;
+			continue;
+		}
+		if (!quoted && characters[i] === ',' && /^\s*[}\]]/.test(clean.slice(i + 1)))
+			characters[i] = ' ';
+	}
+	clean = characters.join('');
+	try {
+		return JSON.parse(clean) as ProjectConfig;
+	} catch (failure) {
+		try {
+			errors.tsconfig_parse_failed({
+				details: failure instanceof Error ? failure.message : String(failure)
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				const message = failure instanceof Error ? failure.message : '';
+				const lineColumn = /line (\d+) column (\d+)/.exec(message);
+				const position = Number(/position (\d+)/.exec(message)?.[1] ?? 0);
+				const prefix = clean.slice(0, position);
+				const line = lineColumn?.[1] ?? String(prefix.split('\n').length);
+				const column = lineColumn?.[2] ?? String(position - prefix.lastIndexOf('\n'));
+				error.stack = `${error.message}\n    at ${relativeFile(process.cwd(), file)}:${line}:${column}`;
+			}
+			throw error;
+		}
+	}
+}
+
+const sourceFile = /\.[cm]?[jt]sx?$/;
+function pattern(glob: string): RegExp {
+	const source = posix(glob).replace(/^\.\//, '').replace(/\/$/, '');
+	let expression = '';
+	for (let i = 0; i < source.length; i++) {
+		if (source.startsWith('**/', i)) {
+			expression += '(?:[^/]*/)*';
+			i += 2;
+		} else if (source.startsWith('**', i)) {
+			expression += '.*';
+			i++;
+		} else if (source[i] === '*') expression += '[^/]*';
+		else if (source[i] === '?') expression += '[^/]';
+		else expression += source[i]!.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+	}
+	return new RegExp(`^${expression}(?:/.*)?$`);
+}
+function matches(globs: string[], name: string): boolean {
+	return globs.some((glob) => pattern(glob).test(name));
+}
+
+function pathAliases(
+	config: ValidatedConfig,
+	root: string,
+	d: Diagnostics
+): Record<string, string[]> {
+	const e: ConfigErrors = new ConfigErrors(d);
+	const paths: Record<string, string[]> = {};
+	for (const [key, value] of Object.entries(config.alias)) {
+		if (!/^.+?(?:\/\*)?$/.test(key)) e.config_alias_key_invalid({ key });
+		if (!/^.+?(?:\/\*|\.\w+)?$/.test(value)) e.config_alias_value_invalid({ value });
+		const target = resolve(root, value.replace(/\/\*$/, ''));
+		paths[key] = [target + (key.endsWith('/*') ? '/*' : '')];
+		if (!key.endsWith('/*') && !/\.\w+$/.test(value) && !Object.hasOwn(config.alias, key + '/*'))
+			paths[key + '/*'] = [target + '/*'];
+	}
+	return paths;
+}
+
+const listFormat = new Intl.ListFormat('en-gb', { type: 'conjunction' });
+function quotedList(items: string[]): string {
+	return listFormat.format(items.map((item) => JSON.stringify(item)));
+}
+function tsconfig_extends_missing(d: Diagnostics, file: string, example: ProjectConfig): void {
+	d.warn(
+		'tsconfig_extends_missing',
+		`\`${file}\` should extend ${d.identity.product}'s built-in configuration:\n${JSON.stringify(example, null, '  ')}`
+	);
+}
+function tsconfig_invalid(d: Diagnostics, file: string, issues: string[]): void {
+	d.warn(
+		'tsconfig_invalid',
+		`Found issues while validating \`${file}\`:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`
+	);
+}
+
+export function writeTsconfig(config: ValidatedConfig, root: string, d: Diagnostics): void {
+	const paths = pathAliases(config, root, d);
+	const types = ['$app/types'];
+	const compilerOptions: CompilerOptions = {
+		paths,
+		rootDirs: [root, join(config.outDir, 'types')],
+		types,
+		lib: ['ESNext', 'DOM', 'DOM.Iterable'],
+		...required,
+		...recommended
+	};
+	const write = (
+		id: string,
+		options: CompilerOptions,
+		transform?: ValidatedConfig['typescript']['config']
+	): ProjectConfig => {
+		const file = join(root, 'node_modules', id + '.json');
+		const normalized: ProjectConfig = {
+			compilerOptions: {
+				...options,
+				paths: Object.fromEntries(
+					Object.entries(options.paths ?? {}).map(([key, values]) => [
+						key,
+						values.map((value) => relativeFile(dirname(file), value))
+					])
+				),
+				rootDirs: options.rootDirs?.map((value) => relativeFile(dirname(file), value))
+			}
+		};
+		const result = transform?.(normalized) ?? normalized;
+		writeChanged(file, JSON.stringify(result, null, '\t'));
+		return result;
+	};
+	const parent = write('$app/tsconfig', compilerOptions, config.typescript.config);
+	const worker = write('$app/tsconfig/service-worker', {
+		paths,
+		types,
+		lib: ['ESNext', 'WebWorker'],
+		...required,
+		...recommended
+	});
+	const validate = (
+		directory: string,
+		id: string,
+		exclusions: string[],
+		example: ProjectConfig,
+		base: ProjectConfig
+	): void => {
+		const file = ['tsconfig.json', 'jsconfig.json']
+			.map((name) => join(directory, name))
+			.find(existsSync);
+		if (!file) return;
+		const parsed = parseConfig(file, new SyncErrors(d));
+		const bases = typeof parsed.extends === 'string' ? [parsed.extends] : (parsed.extends ?? []);
+		if (!bases.includes(id)) {
+			tsconfig_extends_missing(d, relativeFile(root, file), example);
+			return;
+		}
+		const options = { ...base.compilerOptions, ...parsed.compilerOptions };
+		const issues: string[] = [];
+		if (options.types && !options.types.includes('$app/types'))
+			issues.push('"types" was overwritten. It must include "$app/types"');
+		if (parsed.compilerOptions?.paths) {
+			const mismatch = Object.entries(paths).filter(
+				([key, expected]) =>
+					JSON.stringify(options.paths![key]?.map((value) => resolve(directory, value))) !==
+					JSON.stringify(expected)
+			);
+			if (mismatch.length)
+				issues.push(
+					`"paths" was overwritten. Imports from ${quotedList([...new Set(mismatch.map(([key]) => key.replace(/\/\*$/, '')))])} may not typecheck`
+				);
+		}
+		const included: string[] = [];
+		for (const exclusion of exclusions) {
+			const found = filesUnder(dirname(exclusion)).some((path) => {
+				if (!sourceFile.test(path)) return false;
+				if (
+					path !== exclusion &&
+					!path.startsWith(exclusion + '/') &&
+					!path.startsWith(exclusion + '.')
+				)
+					return false;
+				const name = relativeFile(directory, path);
+				return matches(parsed.include ?? ['**/*'], name) && !matches(parsed.exclude ?? [], name);
+			});
+			if (found) included.push(relativeFile(directory, exclusion));
+		}
+		if (included.length)
+			issues.push(`${quotedList(included)} should be added to the "exclude" array`);
+		for (const key of Object.keys(required))
+			if (options[key] !== true)
+				issues.push(`${JSON.stringify(key)} was overwritten. It should be true`);
+		if (issues.length) tsconfig_invalid(d, relativeFile(root, file), issues);
+	};
+	validate(
+		root,
+		'$app/tsconfig',
+		[config.files.serviceWorker],
+		{ extends: '$app/tsconfig', include: ['src', 'test', '*'], exclude: ['src/service-worker'] },
+		parent
+	);
+	validate(
+		config.files.serviceWorker,
+		'$app/tsconfig/service-worker',
+		[],
+		{ extends: '$app/tsconfig/service-worker' },
+		worker
+	);
+}

package/src/sync/warnings.ts

@@ -0,0 +1,26 @@
+import type { Diagnostics } from '../shared/diagnostics.ts';
+
+interface FileSuggestion {
+	file: string;
+	corrected: string;
+}
+
+export class SyncWarnings {
+	private readonly d: Diagnostics;
+	constructor(d: Diagnostics) {
+		this.d = d;
+	}
+	route_file_prefix_missing({ file, corrected }: FileSuggestion): void {
+		this.d.warn(
+			'route_file_prefix_missing',
+			`Missing route file prefix. Did you mean ${corrected}? at ${file}`
+		);
+	}
+	file_name_misspelled({
+		file,
+		corrected,
+		description
+	}: FileSuggestion & { description: string }): void {
+		this.d.warn('file_name_misspelled', `${description}. Did you mean ${corrected}? at ${file}`);
+	}
+}

package/src/types/adapter.ts

@@ -0,0 +1,4 @@
+import type { MaybePromise } from './value.ts';
+
+export type RerouteNext = (url: URL) => MaybePromise<Response>;
+export declare function applyReroute(response: Response, next: RerouteNext): MaybePromise<Response>;

package/src/types/builder.ts

@@ -0,0 +1,147 @@
+import type { Plugin } from 'vite';
+import type { GetRequest, SetResponse } from './node.ts';
+import type { Config } from './config.ts';
+import type { Identity } from './identity.ts';
+import type { MaybePromise } from './value.ts';
+
+export interface AdapterSupportInput {
+	config: Record<string, any>;
+	route: { id: string };
+}
+export interface AdapterSupport {
+	read?: (details: AdapterSupportInput) => boolean;
+	instrumentation?: () => boolean;
+}
+export interface AdapterVitePlugins {
+	pre?: Plugin[];
+	post?: Plugin[];
+}
+export interface AdapterViteConfig {
+	getRequest?: GetRequest;
+	setResponse?: SetResponse;
+	plugins?: Plugin[] | AdapterVitePlugins;
+}
+export interface AdapterContext {
+	config: ValidatedConfig;
+}
+export interface Adapter {
+	name: string;
+	adapt(builder: Builder): MaybePromise<void>;
+	supports?: AdapterSupport;
+	emulate?: () => MaybePromise<Emulator>;
+	vite?: AdapterViteConfig | ((context: AdapterContext) => AdapterViteConfig);
+}
+export interface EmulationInput {
+	config: any;
+	prerender: PrerenderOption;
+}
+export interface Emulator {
+	platform?(details: EmulationInput): MaybePromise<App.Platform>;
+}
+export type PrerenderOption = boolean | 'auto';
+export type HttpMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'QUERY';
+export interface RouteSegment {
+	content: string;
+	dynamic: boolean;
+	rest: boolean;
+}
+export interface RouteDefinition<Config = any> {
+	id: string;
+	api: { methods: (HttpMethod | '*')[] };
+	page: { methods: ('GET' | 'POST')[] };
+	pattern: RegExp;
+	prerender: PrerenderOption;
+	segments: RouteSegment[];
+	methods: (HttpMethod | '*')[];
+	config: Config;
+}
+export interface Logger {
+	(message: string): void;
+	success(message: string): void;
+	error(message: string): void;
+	warn(message: string): void;
+	minor(message: string): void;
+	info(message: string): void;
+	err(message: string): void;
+	prettyError(error: unknown, caller?: string): void;
+}
+export interface PrerenderedPage {
+	file: string;
+}
+export interface PrerenderedAsset {
+	type: string;
+}
+export interface PrerenderedRedirect {
+	status: number;
+	location: string;
+}
+export interface Prerendered {
+	pages: Map<string, PrerenderedPage>;
+	assets: Map<string, PrerenderedAsset>;
+	redirects: Map<string, PrerenderedRedirect>;
+	paths: string[];
+}
+export type RecursiveRequired<T> = {
+	[K in keyof T]-?: Extract<T[K], Function | (`${string}:` & {})> extends never
+		? RecursiveRequired<T[K]>
+		: T[K];
+};
+export type ValidatedConfig = RecursiveRequired<Omit<Config, 'preprocess' | 'adapter'>> & {
+	adapter: Adapter & { vite?: AdapterViteConfig };
+	preprocess: Config['preprocess'];
+};
+export interface ServerInstanceOptions {
+	routes?: RouteDefinition[];
+	serverDirectory?: string;
+}
+export interface InitializerOptions {
+	outputDirectory: string;
+	environment?: string;
+	serverDirectory?: string;
+}
+export interface CopyOptions {
+	filter?(basename: string): boolean;
+	replace?: Record<string, string>;
+}
+export interface InstrumentPaths {
+	instrumentation: string;
+	start: string;
+	initializer: string;
+}
+export type InstrumentModule =
+	| { exports: string[] }
+	| { generateText(paths: InstrumentPaths): string };
+export interface InstrumentOptions {
+	entrypoint: string;
+	instrumentation: string;
+	start?: string;
+	initializer: string;
+	module?: InstrumentModule;
+}
+export interface Builder {
+	identity: Identity;
+	log: Logger;
+	rimraf(directory: string): void;
+	mkdirp(directory: string): void;
+	config: ValidatedConfig;
+	prerendered: Prerendered;
+	routes: RouteDefinition[];
+	manifest: typeof import('$app/manifest');
+	mimeTypes: Record<string, string>;
+	findServerAssets(routes: RouteDefinition[]): string[];
+	generateFallback(destination: string): Promise<void>;
+	generateEnvModule(): void;
+	getBuildDirectory(name: string): string;
+	getClientDirectory(): string;
+	getServerDirectory(): string;
+	getAppPath(): string;
+	generateServerInstance(destination: string, options?: ServerInstanceOptions): void;
+	writeClient(destination: string): string[];
+	writePrerendered(destination: string): string[];
+	writeServer(destination: string): string[];
+	createInstrumentationInitializer(options: InitializerOptions): string;
+	copy(from: string, to: string, options?: CopyOptions): string[];
+	hasServerInstrumentationFile(): boolean;
+	instrument(options: InstrumentOptions): void;
+	compress(directory: string): Promise<string[]>;
+}