@vigla/kit 0.0.0-stage → 0.1.0

package/src/config/errors.ts

@@ -0,0 +1,231 @@
+import type { Diagnostics } from '../shared/diagnostics.ts';
+
+interface KeyPath {
+	keypath: string;
+}
+interface Extension extends KeyPath {
+	extension: string;
+}
+interface Origin extends KeyPath {
+	input: string;
+}
+interface Unexpected extends KeyPath {
+	suggestion?: string;
+}
+
+export class ConfigErrors {
+	private readonly d: Diagnostics;
+	constructor(d: Diagnostics) {
+		this.d = d;
+	}
+	config_not_object(): never {
+		return this.d.raise(
+			'config_not_object',
+			`The ${this.d.identity.product} options from the Vite config must be an object`,
+			this.config_not_object
+		);
+	}
+	config_expected_object({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_object',
+			`\`${keypath}\` should be an object`,
+			this.config_expected_object
+		);
+	}
+	config_expected_string({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_string',
+			`\`${keypath}\` should be a string, if specified`,
+			this.config_expected_string
+		);
+	}
+	config_expected_string_array({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_string_array',
+			`\`${keypath}\` should be an array of strings, if specified`,
+			this.config_expected_string_array
+		);
+	}
+	config_expected_number({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_number',
+			`\`${keypath}\` should be a number, if specified`,
+			this.config_expected_number
+		);
+	}
+	config_expected_boolean({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_boolean',
+			`\`${keypath}\` should be true or false, if specified`,
+			this.config_expected_boolean
+		);
+	}
+	config_expected_function({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_function',
+			`\`${keypath}\` should be a function, if specified`,
+			this.config_expected_function
+		);
+	}
+	config_expected_positive_integer({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_expected_positive_integer',
+			`\`${keypath}\` should be a positive integer, if specified`,
+			this.config_expected_positive_integer
+		);
+	}
+	config_expected_one_of({ keypath, options }: KeyPath & { options: string }): never {
+		return this.d.raise(
+			'config_expected_one_of',
+			`\`${keypath}\` should be ${options}`,
+			this.config_expected_one_of
+		);
+	}
+	config_unexpected_option({ keypath, suggestion }: Unexpected): never {
+		return this.d.raise(
+			'config_unexpected_option',
+			`Unexpected option \`${keypath}\`${suggestion ? ` (did you mean \`${suggestion}\`?)` : ''}`,
+			this.config_unexpected_option
+		);
+	}
+	config_empty_string({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_empty_string',
+			`\`${keypath}\` cannot be empty`,
+			this.config_empty_string
+		);
+	}
+	config_app_dir_slash({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_app_dir_slash',
+			`\`${keypath}\` cannot start or end with \`'/'\``,
+			this.config_app_dir_slash
+		);
+	}
+	config_extension_missing_dot({ keypath, extension }: Extension): never {
+		return this.d.raise(
+			'config_extension_missing_dot',
+			`Each member of ${keypath} must start with \`'.'\` — saw \`'${extension}'\``,
+			this.config_extension_missing_dot
+		);
+	}
+	config_extension_invalid({ extension }: { extension: string }): never {
+		return this.d.raise(
+			'config_extension_invalid',
+			`File extensions must be alphanumeric — saw \`'${extension}'\``,
+			this.config_extension_invalid
+		);
+	}
+	config_invalid_adapter({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_invalid_adapter',
+			`The ${this.d.identity.product} Vite plugin \`${keypath}\` should be an object with an \`adapt\` method`,
+			this.config_invalid_adapter
+		);
+	}
+	config_invalid_prerender_handler({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_invalid_prerender_handler',
+			`\`${keypath}\` should be \`'fail'\`, \`'warn'\`, \`'ignore'\` or a custom function`,
+			this.config_invalid_prerender_handler
+		);
+	}
+	config_paths_base_invalid({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_paths_base_invalid',
+			`\`${keypath}\` option must either be the empty string or a root-relative path that starts but doesn't end with \`'/'\``,
+			this.config_paths_base_invalid
+		);
+	}
+	config_paths_assets_not_absolute({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_paths_assets_not_absolute',
+			`\`${keypath}\` option must be an absolute path, if specified`,
+			this.config_paths_assets_not_absolute
+		);
+	}
+	config_paths_assets_trailing_slash({ keypath }: KeyPath): never {
+		return this.d.raise(
+			'config_paths_assets_trailing_slash',
+			`\`${keypath}\` option must not end with \`'/'\``,
+			this.config_paths_assets_trailing_slash
+		);
+	}
+	config_origin_invalid({ keypath, input }: Origin): never {
+		return this.d.raise(
+			'config_origin_invalid',
+			`\`${keypath}\` must be a valid origin (e.g. 'https://my-site.com'). \`'${input}'\` could not be parsed as a URL`,
+			this.config_origin_invalid
+		);
+	}
+	config_origin_protocol({ keypath, protocol }: KeyPath & { protocol: string }): never {
+		return this.d.raise(
+			'config_origin_protocol',
+			`\`${keypath}\` must be a valid origin — only 'http' and 'https' protocols are supported, received '${protocol}'`,
+			this.config_origin_protocol
+		);
+	}
+	config_origin_has_path({ keypath, input, origin }: Origin & { origin: string }): never {
+		return this.d.raise(
+			'config_origin_has_path',
+			`\`${keypath}\` must be a valid origin — received \`'${input}'\` which contains a path, query, or hash. Use the bare origin \`'${origin}'\` instead`,
+			this.config_origin_has_path
+		);
+	}
+	config_prerender_entry_invalid({ keypath, entry }: KeyPath & { entry: string }): never {
+		return this.d.raise(
+			'config_prerender_entry_invalid',
+			`Each member of \`${keypath}\` must be either \`'*'\` or an absolute path beginning with \`'/'\` — saw \`'${entry}'\``,
+			this.config_prerender_entry_invalid
+		);
+	}
+	config_server_resolution_hash(): never {
+		return this.d.raise(
+			'config_server_resolution_hash',
+			"The `router.resolution` option cannot be `'server'` if `router.type` is `'hash'`",
+			this.config_server_resolution_hash
+		);
+	}
+	config_server_resolution_bundle_strategy(): never {
+		return this.d.raise(
+			'config_server_resolution_bundle_strategy',
+			"The `router.resolution` option cannot be `'server'` if `output.bundleStrategy` is `'inline'` or `'single'`",
+			this.config_server_resolution_bundle_strategy
+		);
+	}
+	config_csp_trusted_types_missing(): never {
+		return this.d.raise(
+			'config_csp_trusted_types_missing',
+			`The \`csp.directives['trusted-types']\` option must include \`'${this.d.identity.name}-trusted-url'\` when \`serviceWorker.register\` is \`true\``,
+			this.config_csp_trusted_types_missing
+		);
+	}
+	app_template_missing({ file }: { file: string }): never {
+		return this.d.raise(
+			'app_template_missing',
+			`${file} does not exist`,
+			this.app_template_missing
+		);
+	}
+	app_template_tag_missing({ file, tag }: { file: string; tag: string }): never {
+		return this.d.raise(
+			'app_template_tag_missing',
+			`${file} is missing \`${tag}\``,
+			this.app_template_tag_missing
+		);
+	}
+	config_alias_key_invalid({ key }: { key: string }): never {
+		return this.d.raise(
+			'config_alias_key_invalid',
+			`Invalid alias key: \`${key}\``,
+			this.config_alias_key_invalid
+		);
+	}
+	config_alias_value_invalid({ value }: { value: string }): never {
+		return this.d.raise(
+			'config_alias_value_invalid',
+			`Invalid alias value: \`${value}\``,
+			this.config_alias_value_invalid
+		);
+	}
+}

package/src/config/file.ts

@@ -0,0 +1,61 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { Alias, ResolvedConfig } from 'vite';
+import type { ValidatedConfig } from '../types/builder.ts';
+import type { Identity } from '../types/identity.ts';
+import { diagnostics } from '../shared/diagnostics.ts';
+import { resolveConfig, validateConfig } from './index.ts';
+
+export interface FileConfig {
+	config: ValidatedConfig;
+	identity: Identity;
+	vite: ResolvedConfig;
+	api: typeof import('vite');
+}
+
+export async function importVite(root: string): Promise<typeof import('vite')> {
+	const require = createRequire(path.join(root, 'package.json'));
+	return import(pathToFileURL(require.resolve('vite')).href);
+}
+
+export async function loadConfig(
+	root: string,
+	fallback: Identity,
+	file?: string,
+	mode = process.env.MODE ?? 'production'
+): Promise<FileConfig> {
+	const api = await importVite(root);
+	const vite = await api.resolveConfig({ root, configFile: file }, 'build', mode);
+	const setup = vite.plugins.find((plugin) => plugin.name === 'kit:setup')?.api;
+	if (setup) return { api, vite, config: setup.options, identity: setup.identity };
+	const d = diagnostics(fallback);
+	return {
+		api,
+		vite,
+		config: resolveConfig(validateConfig({}, d), vite.root, d),
+		identity: fallback
+	};
+}
+
+export function configAliases(config: ValidatedConfig, root: string): Alias[] {
+	return Object.entries(config.alias).map(([key, value]) => {
+		const replacement = path
+			.resolve(root, value.replaceAll('\\', '/').replace(/\/\*$/, ''))
+			.replaceAll('\\', '/');
+		if (key.endsWith('/*')) {
+			return {
+				find: new RegExp(`^${escapePattern(key.slice(0, -2))}/(.+)$`),
+				replacement: `${replacement}/$1`
+			};
+		}
+		return {
+			find: `${key}/*` in config.alias ? new RegExp(`^${escapePattern(key)}$`) : key,
+			replacement
+		};
+	});
+}
+
+function escapePattern(text: string): string {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/config/index.ts

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import type { Config } from '../types/config.ts';
+import type { ValidatedConfig } from '../types/builder.ts';
+import type { Diagnostics } from '../shared/diagnostics.ts';
+import { configSchema } from './schema.ts';
+import { ConfigErrors } from './errors.ts';
+
+export interface SplitConfig {
+	config: Config;
+	plugin: Record<string, unknown>;
+}
+
+export function splitConfig(input: Config, d: Diagnostics): SplitConfig {
+	const { schema, experimental } = configSchema(new ConfigErrors(d));
+	const config: Record<string, unknown> = {};
+	const plugin: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(input)) {
+		if (key !== 'experimental') {
+			(Object.hasOwn(schema, key) ? config : plugin)[key] = value;
+			continue;
+		}
+		const flags = (value ?? {}) as Record<string, unknown>;
+		for (const [flag, setting] of Object.entries(flags)) {
+			const target = Object.hasOwn(experimental, flag) ? config : plugin;
+			const group = (target.experimental ??= {}) as Record<string, unknown>;
+			group[flag] = setting;
+		}
+	}
+	return { config: config as Config, plugin };
+}
+
+export function validateConfig(input: unknown, d: Diagnostics): ValidatedConfig {
+	const e: ConfigErrors = new ConfigErrors(d);
+	try {
+		if (!input || typeof input !== 'object' || Array.isArray(input)) e.config_not_object();
+		const config = configSchema(e).parseOptions(input, 'config') as ValidatedConfig;
+		config.outDir ??= d.identity.outDir;
+		const files = config.files;
+		files.hooks.client ??= join(files.src, 'hooks.client');
+		files.hooks.server ??= join(files.src, 'hooks.server');
+		files.hooks.universal ??= join(files.src, 'hooks');
+		files.params ??= join(files.src, 'params');
+		files.routes ??= join(files.src, 'routes');
+		files.serviceWorker ??= join(files.src, 'service-worker');
+		files.appTemplate ??= join(files.src, 'app.html');
+		files.errorTemplate ??= join(files.src, 'error.html');
+		if (config.router.resolution === 'server') {
+			if (config.router.type === 'hash') e.config_server_resolution_hash();
+			if (config.output.bundleStrategy !== 'split') e.config_server_resolution_bundle_strategy();
+		}
+		if (typeof config.adapter?.vite === 'function') {
+			config.adapter = { ...config.adapter, vite: config.adapter.vite({ config }) };
+		}
+		return config;
+	} catch (error) {
+		console.log(`\n${error instanceof Error ? error.message : String(error)}\n`);
+		const failure = new Error(`Failed to load ${d.identity.product} options from Vite config`);
+		failure.stack = '';
+		throw failure;
+	}
+}
+
+function hasEntry(file: string, extensions: readonly string[]): boolean {
+	const candidates = [
+		file,
+		...extensions.map((extension) => file + extension),
+		...extensions.map((extension) => join(file, 'index' + extension))
+	];
+	return candidates.some((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+}
+
+export function resolveConfig(
+	config: ValidatedConfig,
+	root: string,
+	d: Diagnostics
+): ValidatedConfig {
+	const files = config.files;
+	const resolved: ValidatedConfig = {
+		...config,
+		outDir: resolve(root, config.outDir),
+		env: { ...config.env, dir: resolve(root, config.env.dir) },
+		files: {
+			...files,
+			src: resolve(root, files.src),
+			assets: resolve(root, files.assets),
+			params: resolve(root, files.params),
+			routes: resolve(root, files.routes),
+			serviceWorker: resolve(root, files.serviceWorker),
+			appTemplate: resolve(root, files.appTemplate),
+			errorTemplate: resolve(root, files.errorTemplate),
+			hooks: {
+				client: resolve(root, files.hooks.client),
+				server: resolve(root, files.hooks.server),
+				universal: resolve(root, files.hooks.universal)
+			}
+		}
+	};
+	const directives = resolved.csp.directives;
+	if (
+		directives['require-trusted-types-for']?.includes('script') &&
+		resolved.serviceWorker.register &&
+		hasEntry(resolved.files.serviceWorker, resolved.moduleExtensions) &&
+		!directives['trusted-types']?.includes(`${d.identity.name}-trusted-url`)
+	)
+		new ConfigErrors(d).config_csp_trusted_types_missing();
+	return resolved;
+}
+
+export function loadErrorPage(config: ValidatedConfig, d: Diagnostics): string {
+	if (existsSync(config.files.errorTemplate))
+		return readFileSync(config.files.errorTemplate, 'utf8');
+	const name = d.identity.name;
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>%${name}.error.message%</title><style>body{display:flex;align-items:center;justify-content:center;height:100vh;margin:0;font-family:system-ui,sans-serif}.error{display:flex;align-items:center;gap:1rem}.status{font-size:3rem;font-weight:200}.message{border-left:1px solid #ccc;padding-left:1rem}.message h1{font-size:1em;font-weight:400;margin:0}</style></head><body><div class="error"><span class="status">%${name}.status%</span><div class="message"><h1>%${name}.error.message%</h1></div></div></body></html>`;
+}
+
+export function loadTemplate(root: string, config: ValidatedConfig, d: Diagnostics): string {
+	const e: ConfigErrors = new ConfigErrors(d);
+	const file = relative(root, config.files.appTemplate);
+	if (!existsSync(config.files.appTemplate)) e.app_template_missing({ file });
+	const template = readFileSync(config.files.appTemplate, 'utf8');
+	for (const tag of [`%${d.identity.name}.head%`, `%${d.identity.name}.body%`]) {
+		if (!template.includes(tag)) e.app_template_tag_missing({ file, tag });
+	}
+	return template;
+}

package/src/config/schema.ts

@@ -0,0 +1,246 @@
+import type { ConfigErrors } from './errors.ts';
+
+type Validator = (input: unknown, keypath: string) => any;
+type Schema = Record<string, Validator>;
+
+export interface ConfigSchema {
+	experimental: Schema;
+	schema: Schema;
+	parseOptions: Validator;
+}
+
+export function configSchema(e: ConfigErrors): ConfigSchema {
+	function fallback(value: unknown, parse: Validator): Validator {
+		return (input, path) => (input === undefined ? structuredClone(value) : parse(input, path));
+	}
+	function object(schema: Schema, open = false): Validator {
+		return (input, keypath) => {
+			if (input != null && (typeof input !== 'object' || Array.isArray(input)))
+				e.config_expected_object({ keypath });
+			const source = (input ?? {}) as Record<string, unknown>;
+			const output: Record<string, unknown> = {};
+			for (const key of Object.keys(source)) {
+				if (Object.hasOwn(schema, key)) continue;
+				if (!open) e.config_unexpected_option({ keypath: `${keypath}.${key}` });
+				if (source[key] !== undefined) output[key] = source[key];
+			}
+			for (const [key, parse] of Object.entries(schema))
+				output[key] = parse(source[key], `${keypath}.${key}`);
+			return output;
+		};
+	}
+	function string(value: string | undefined = undefined): Validator {
+		return fallback(value, (input, keypath) => {
+			if (typeof input !== 'string') e.config_expected_string({ keypath });
+			return input;
+		});
+	}
+	function strings(value?: string[]): Validator {
+		return fallback(value, (input, keypath) => {
+			if (!Array.isArray(input) || input.some((item) => typeof item !== 'string'))
+				e.config_expected_string_array({ keypath });
+			return [...input];
+		});
+	}
+	function bool(value: boolean): Validator {
+		return fallback(value, (input, keypath) => {
+			if (typeof input !== 'boolean') e.config_expected_boolean({ keypath });
+			return input;
+		});
+	}
+	function number(value: number): Validator {
+		return fallback(value, (input, keypath) => {
+			if (typeof input !== 'number') e.config_expected_number({ keypath });
+			return input;
+		});
+	}
+	function choice(values: string[]): Validator {
+		return fallback(values[0], (input, keypath) => {
+			if (!values.includes(input as string))
+				e.config_expected_one_of({
+					keypath,
+					options: `${values.length > 2 ? 'one of' : 'either'} ${values.map((v) => `"${v}"`).join(' or ')}`
+				});
+			return input;
+		});
+	}
+	const passthrough: Validator = (input) => input;
+	const directives: Schema = Object.fromEntries(
+		[
+			'child-src',
+			'default-src',
+			'frame-src',
+			'worker-src',
+			'connect-src',
+			'font-src',
+			'img-src',
+			'manifest-src',
+			'media-src',
+			'object-src',
+			'prefetch-src',
+			'script-src',
+			'script-src-elem',
+			'script-src-attr',
+			'style-src',
+			'style-src-elem',
+			'style-src-attr',
+			'base-uri',
+			'sandbox',
+			'form-action',
+			'frame-ancestors',
+			'navigate-to',
+			'report-uri',
+			'report-to',
+			'require-trusted-types-for',
+			'trusted-types',
+			'require-sri-for',
+			'plugin-types',
+			'referrer'
+		].map((key) => [key, strings()])
+	);
+	directives['upgrade-insecure-requests'] = bool(false);
+	directives['block-all-mixed-content'] = bool(false);
+	const handler = fallback(undefined, (input, keypath) => {
+		if (typeof input !== 'function' && !['fail', 'warn', 'ignore'].includes(input as string))
+			e.config_invalid_prerender_handler({ keypath });
+		return input;
+	});
+
+	const experimental = {
+		remoteFunctions: bool(true),
+		forkPreloads: bool(false)
+	};
+	const schema: Schema = {
+		adapter: fallback(undefined, (input, keypath) => {
+			if (
+				!input ||
+				typeof input !== 'object' ||
+				!('adapt' in input) ||
+				typeof input.adapt !== 'function'
+			)
+				e.config_invalid_adapter({ keypath });
+			return input;
+		}),
+		alias: fallback({}, (input, keypath) => {
+			if (!input || typeof input !== 'object' || Array.isArray(input))
+				e.config_expected_object({ keypath });
+			for (const [key, value] of Object.entries(input)) string()(value, `${keypath}.${key}`);
+			return { ...input };
+		}),
+		appDir: fallback('_app', (input, keypath) => {
+			const value = string()(input, keypath) as string;
+			if (!value) e.config_empty_string({ keypath });
+			if (value.startsWith('/') || value.endsWith('/')) e.config_app_dir_slash({ keypath });
+			return value;
+		}),
+		compilerOptions: passthrough,
+		csp: object({
+			mode: choice(['auto', 'hash', 'nonce']),
+			directives: object(directives),
+			reportOnly: object(directives)
+		}),
+		csrf: object({ trustedOrigins: strings([]) }),
+		embedded: bool(false),
+		env: object({ dir: string('') }),
+		experimental: object(experimental, true),
+		extensions: fallback([], (input, keypath) => {
+			const values = strings()(input, keypath) as string[];
+			for (const extension of values) {
+				if (!extension.startsWith('.')) e.config_extension_missing_dot({ keypath, extension });
+				if (!/^(\.[a-z0-9]+)+$/i.test(extension)) e.config_extension_invalid({ extension });
+			}
+			return values;
+		}),
+		files: object({
+			src: string('src'),
+			assets: string('static'),
+			hooks: object({ client: string(), server: string(), universal: string() }),
+			params: string(),
+			routes: string(),
+			serviceWorker: string(),
+			appTemplate: string(),
+			errorTemplate: string()
+		}),
+		inlineStyleThreshold: number(0),
+		moduleExtensions: strings(['.js', '.ts']),
+		outDir: string(),
+		output: object({
+			linkHeaderPreload: bool(false),
+			bundleStrategy: choice(['split', 'single', 'inline'])
+		}),
+		paths: object({
+			base: fallback('', (input, keypath) => {
+				const value = string()(input, keypath) as string;
+				if (value && (!value.startsWith('/') || value.endsWith('/')))
+					e.config_paths_base_invalid({ keypath });
+				return value;
+			}),
+			assets: fallback('', (input, keypath) => {
+				const value = string()(input, keypath) as string;
+				if (value && !/^[a-z]+:\/\//.test(value)) e.config_paths_assets_not_absolute({ keypath });
+				if (value.endsWith('/')) e.config_paths_assets_trailing_slash({ keypath });
+				return value;
+			}),
+			origin: fallback(undefined, (input, keypath) => {
+				const value = string()(input, keypath) as string;
+				let url: URL;
+				try {
+					url = new URL(value);
+				} catch {
+					return e.config_origin_invalid({ keypath, input: value });
+				}
+				if (url.protocol !== 'http:' && url.protocol !== 'https:')
+					e.config_origin_protocol({ keypath, protocol: url.protocol });
+				if (value !== url.origin)
+					e.config_origin_has_path({ keypath, input: value, origin: url.origin });
+				return url.origin;
+			}),
+			relative: bool(true)
+		}),
+		preprocess: passthrough,
+		prerender: object({
+			concurrency: fallback(1, (input, keypath) => {
+				if (typeof input !== 'number' || !Number.isInteger(input) || input < 1)
+					e.config_expected_positive_integer({ keypath });
+				return input;
+			}),
+			crawl: bool(true),
+			entries: fallback(['*'], (input, keypath) => {
+				const values = strings()(input, keypath) as string[];
+				for (const entry of values)
+					if (entry !== '*' && !entry.startsWith('/'))
+						e.config_prerender_entry_invalid({ keypath, entry });
+				return values;
+			}),
+			handleHttpError: handler,
+			handleMissingId: handler,
+			handleEntryGeneratorMismatch: handler,
+			handleUnseenRoutes: handler,
+			handleInvalidUrl: handler
+		}),
+		router: object({
+			type: choice(['pathname', 'hash']),
+			resolution: choice(['client', 'server'])
+		}),
+		serviceWorker: object({
+			register: bool(true),
+			options: (input, keypath) =>
+				input === undefined ? undefined : object({}, true)(input, keypath)
+		}),
+		tracing: object({ server: bool(false) }),
+		typescript: object({
+			config: (input, keypath) => {
+				if (input === undefined) return (value: unknown) => value;
+				if (typeof input !== 'function') e.config_expected_function({ keypath });
+				return input;
+			}
+		}),
+		version: object({
+			name: (input, path) => string(Date.now().toString())(input, path),
+			pollInterval: number(3_600_000)
+		})
+	};
+
+	const parseOptions = object(schema, true);
+	return { experimental, schema, parseOptions };
+}

package/src/entries/adapter.ts

@@ -0,0 +1,4 @@
+import { identity } from '../shared/identity.ts';
+import { rerouter } from './reroute.ts';
+
+export const applyReroute = rerouter(identity);

package/src/entries/app/env/client.ts

@@ -0,0 +1,4 @@
+export { DEV as dev } from 'esm-env';
+export { version } from '../../../client/payload.ts';
+export const browser = true;
+export const building = false;

package/src/entries/app/env/private/server.ts

@@ -0,0 +1 @@
+export { privateEnv as env } from '../../../../server/environment.ts';

package/src/entries/app/env/public/server.ts

@@ -0,0 +1 @@
+export { publicEnv as env } from '../../../../server/environment.ts';

package/src/entries/app/env/server.ts

@@ -0,0 +1,3 @@
+export { DEV as dev } from 'esm-env';
+export { version, building, prerendering } from '../../../server/environment.ts';
+export const browser = false;

package/src/entries/app/forms/client.ts

@@ -0,0 +1,2 @@
+export { applyAction, deserialize, enhance } from '../../../client/forms.ts';
+export type { ActionResult, SubmitFunction } from '../../../types/forms.ts';