@vigla/kit 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,129 @@
 {
-  "name": "@vigla/kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@vigla/kit",
+	"version": "0.1.1",
+	"type": "module",
+	"files": [
+		"dist",
+		"src",
+		"types"
+	],
+	"bin": {
+		"vigla-kit": "./dist/sync/bin.js"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"default": "./dist/entries/index.js"
+		},
+		"./package.json": "./package.json",
+		"./internal/client": "./dist/entries/internal/client.js",
+		"./internal/payload": "./dist/entries/internal/payload.js",
+		"./internal/server": "./dist/entries/internal/server.js",
+		"./adapter": {
+			"types": "./dist/types/adapter.d.ts",
+			"default": "./dist/entries/adapter.js"
+		},
+		"./env": {
+			"types": "./dist/types/env.d.ts",
+			"default": "./dist/entries/env.js"
+		},
+		"./hooks": {
+			"types": "./dist/types/hooks.d.ts",
+			"default": "./dist/entries/hooks.js"
+		},
+		"./node": "./dist/node/index.js",
+		"./params": {
+			"types": "./dist/types/params.d.ts",
+			"default": "./dist/entries/params.js"
+		},
+		"./vite": {
+			"types": "./dist/types/config.d.ts",
+			"default": "./dist/vite/index.js"
+		},
+		"./internal/env": "./dist/entries/internal/env.js",
+		"./internal/identity": "./dist/entries/internal/identity.js",
+		"./internal/restore": "./dist/entries/internal/restore.js",
+		"./internal/sequence": "./dist/entries/internal/sequence.js",
+		"./internal/shallow": {
+			"workerd": "./dist/entries/internal/shallow/server.js",
+			"browser": "./dist/entries/internal/shallow/client.js",
+			"default": "./dist/entries/internal/shallow/server.js"
+		},
+		"./internal/node": "./dist/node/static.js",
+		"./cli": "./dist/sync/cli.js"
+	},
+	"imports": {
+		"#internal/origin": {
+			"workerd": "./dist/server/origin.js",
+			"browser": "./dist/client/origin.js",
+			"default": "./dist/server/origin.js"
+		},
+		"#types/*": "./dist/types/*.js",
+		"#app/env": {
+			"workerd": "./dist/entries/app/env/server.js",
+			"browser": "./dist/entries/app/env/client.js",
+			"default": "./dist/entries/app/env/server.js"
+		},
+		"#app/forms": {
+			"workerd": "./dist/entries/app/forms/server.js",
+			"browser": "./dist/entries/app/forms/client.js",
+			"default": "./dist/entries/app/forms/server.js"
+		},
+		"#app/navigation": {
+			"workerd": "./dist/entries/app/navigation/server.js",
+			"browser": "./dist/entries/app/navigation/client.js",
+			"default": "./dist/entries/app/navigation/server.js"
+		},
+		"#app/paths": {
+			"workerd": "./dist/entries/app/paths/server.js",
+			"browser": "./dist/entries/app/paths/client.js",
+			"default": "./dist/entries/app/paths/server.js"
+		},
+		"#app/service-worker": {
+			"browser": "./dist/entries/app/service-worker/client.js"
+		},
+		"#app/state": {
+			"workerd": "./dist/entries/app/state/server.js",
+			"browser": "./dist/entries/app/state/client.js",
+			"default": "./dist/entries/app/state/server.js"
+		},
+		"#app/server": {
+			"workerd": "./dist/entries/app/server/server.js",
+			"default": "./dist/entries/app/server/server.js"
+		},
+		"#app/env/public": {
+			"workerd": "./dist/entries/app/env/public/server.js",
+			"default": "./dist/entries/app/env/public/server.js"
+		},
+		"#app/env/private": {
+			"workerd": "./dist/entries/app/env/private/server.js",
+			"default": "./dist/entries/app/env/private/server.js"
+		},
+		"#env/dynamic/public": {
+			"workerd": "./dist/entries/env/dynamic/public/server.js",
+			"browser": "./dist/entries/env/dynamic/public/client.js",
+			"default": "./dist/entries/env/dynamic/public/server.js"
+		},
+		"#env/dynamic/private": {
+			"workerd": "./dist/entries/env/dynamic/private/server.js",
+			"default": "./dist/entries/env/dynamic/private/server.js"
+		}
+	},
+	"dependencies": {
+		"@jridgewell/remapping": "^2.3.5",
+		"@opentelemetry/api": "^1.9.1",
+		"@standard-schema/spec": "^1.1.0",
+		"@types/estree": "^1.0.9",
+		"@vigla/vite-plugin": "0.1.1",
+		"cookie": "^2.0.1",
+		"devalue": "^5.9.4",
+		"esm-env": "^1.2.2",
+		"magic-string": "^0.30.21",
+		"mrmime": "^2.0.1",
+		"parse5": "^8.0.1",
+		"vigla": "0.1.0"
+	},
+	"peerDependencies": {
+		"vite": "^8.0.12"
+	}
+}

package/src/build/analysis.ts

@@ -0,0 +1,134 @@
+import { resolveRoute } from '../shared/routing/index.ts';
+import { invalid_export } from '../shared/errors.ts';
+import type { HttpMethod, PrerenderOption } from '../types/builder.ts';
+import type { PageNode, ServerManifest } from '../types/internal/server.ts';
+import type { Analysis, RemoteMetadata, RouteMetadata } from './types.ts';
+import type { Diagnostics } from '../shared/diagnostics.ts';
+import { BuildMessages } from './messages.ts';
+import type { AnalysisSources } from './jobs.ts';
+
+const endpointMethods: HttpMethod[] = [
+	'GET',
+	'HEAD',
+	'POST',
+	'PUT',
+	'PATCH',
+	'DELETE',
+	'OPTIONS',
+	'QUERY'
+];
+const bodyMethods: HttpMethod[] = ['POST', 'PUT', 'PATCH', 'DELETE', 'QUERY'];
+const common = ['load', 'ssr', 'csr', 'prerender', 'trailingSlash', 'config'];
+
+export async function analyse(
+	manifest: ServerManifest,
+	hash: boolean,
+	sources: AnalysisSources,
+	d: Diagnostics
+): Promise<Analysis> {
+	const e: BuildMessages = new BuildMessages(d);
+	const exportsOf = (module: object | undefined, valid: string[], file?: string): void => {
+		if (!module) return;
+		for (const key of Object.keys(module))
+			if (!key.startsWith('_') && !valid.includes(key))
+				invalid_export({ key, exports: valid.join(', '), file }, d);
+	};
+	const result: Analysis = { nodes: [], routes: new Map(), remotes: new Map(), environment: {} };
+	const nodes = await Promise.all(manifest.nodes.map((load) => load()));
+	for (const node of nodes) {
+		result.nodes[node.index] = {
+			hasServerLoad: node.server?.load !== undefined || node.server?.trailingSlash !== undefined,
+			hasUniversalLoad: node.universal?.load !== undefined
+		};
+		if (hash && node.universal) {
+			const options = Object.keys(node.universal).filter((key) => key !== 'load');
+			if (options.length)
+				e.router_hash_page_options({ file: node.universal_id ?? '', options: options.join(', ') });
+		}
+	}
+	const names = new Set(
+		manifest.routes.flatMap((route) =>
+			route.params.flatMap((param) => (param.matcher ? [param.matcher] : []))
+		)
+	);
+	if (names.size) {
+		const matchers = await manifest.matchers();
+		if (!matchers || typeof matchers !== 'object')
+			e.params_export_missing({ file: sources.params ?? '' });
+		for (const name of names)
+			if (!Object.hasOwn(matchers, name))
+				e.param_matcher_missing({ name, file: sources.params ?? undefined });
+	}
+	for (const route of manifest.routes) {
+		const chain: PageNode[] = route.page
+			? [...route.page.layouts, route.page.leaf].flatMap((index) =>
+					index === undefined ? [] : [nodes[index]!]
+				)
+			: [];
+		let pagePrerender: PrerenderOption = false;
+		let pageConfig: Record<string, any> = {};
+		for (const node of chain) {
+			const leaf = node.index === route.page?.leaf;
+			exportsOf(node.universal, [...common, ...(leaf ? ['entries'] : [])], node.universal_id);
+			exportsOf(node.server, [...common, ...(leaf ? ['entries', 'actions'] : [])], node.server_id);
+			pagePrerender = node.universal?.prerender ?? node.server?.prerender ?? pagePrerender;
+			pageConfig = { ...pageConfig, ...node.server?.config, ...node.universal?.config };
+		}
+		const leaf = chain.at(-1);
+		const endpoint = route.endpoint ? await route.endpoint() : null;
+		const endpointPrerender = endpoint?.prerender ?? false;
+		const apiMethods: Array<HttpMethod | '*'> = endpoint
+			? endpointMethods.filter((method) => method in endpoint)
+			: [];
+		if (endpoint?.fallback) apiMethods.push('*');
+		exportsOf(
+			endpoint ?? undefined,
+			[...endpointMethods, 'fallback', 'prerender', 'trailingSlash', 'config', 'entries'],
+			route.endpoint_id
+		);
+		if (
+			endpointPrerender &&
+			(endpoint?.fallback || bodyMethods.some((method) => endpoint?.[method]))
+		)
+			e.prerender_endpoint_methods({ id: route.id, methods: bodyMethods.join(', ') });
+		if (pagePrerender && endpointPrerender)
+			e.route_prerender_page_and_endpoint({
+				id: route.id,
+				file: sources.endpoints[route.id] ?? '+server.js',
+				extension: sources.extension
+			});
+		if (route.page && endpoint?.config) {
+			for (const key of Object.keys({ ...pageConfig, ...endpoint.config }))
+				if (JSON.stringify(pageConfig[key]) !== JSON.stringify(endpoint.config[key]))
+					e.route_config_mismatch({ id: route.id });
+		}
+		const pageMethods: Array<'GET' | 'POST'> = route.page
+			? ['GET', ...(leaf?.server?.actions ? ['POST' as const] : [])]
+			: [];
+		const generator = leaf?.universal?.entries ?? leaf?.server?.entries ?? endpoint?.entries;
+		const metadata: RouteMetadata = {
+			config: route.page ? pageConfig : (endpoint?.config ?? {}),
+			methods: [...new Set([...pageMethods, ...apiMethods])],
+			page: { methods: pageMethods },
+			api: { methods: apiMethods },
+			prerender: route.page ? pagePrerender : endpointPrerender,
+			entries: generator
+				? (await generator()).map((params) => resolveRoute(route.id, params))
+				: undefined
+		};
+		result.routes.set(route.id, metadata);
+	}
+	for (const [id, load] of Object.entries(manifest.remotes)) {
+		const { default: functions } = await load();
+		const exports = new Map<string, RemoteMetadata>();
+		for (const [name, value] of Object.entries(functions)) {
+			const internals = value.__;
+			exports.set(name, {
+				type: internals.type,
+				dynamic: internals.type !== 'prerender' || !!internals.dynamic
+			});
+		}
+		result.remotes.set(id, exports);
+	}
+	return result;
+}

package/src/build/builder.ts

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { lookup } from '../shared/mime.ts';
+import { uneval } from 'devalue';
+import type { Builder, Logger, RouteDefinition } from '../types/builder.ts';
+import { compress, copy, remove, specifier, walk, write } from './files.ts';
+import { initializer, instrument } from './instrument.ts';
+import { manifestSource, serverAssets } from './manifest.ts';
+import { BuildMessages } from './messages.ts';
+import type { BuildContext } from './types.ts';
+import { renderFallback } from './worker.ts';
+
+export function createLogger(verbose = true): Logger {
+	const log = (message: string) => console.log(message);
+	const detail = (message: string) => {
+		if (verbose) console.log(message);
+	};
+	return Object.assign(log, {
+		success: log,
+		error: (message: string) => console.error(message),
+		warn: (message: string) => console.warn(message),
+		minor: detail,
+		info: detail,
+		err: (message: string) => console.error(message),
+		prettyError: (error: unknown, caller?: string) => console.error(caller ?? '', error)
+	});
+}
+
+export function createBuilder(context: BuildContext): Builder {
+	const { config, tree, analysis, artifacts, prerendered } = context;
+	const e: BuildMessages = new BuildMessages(context.diagnostics);
+	const output = path.join(config.outDir, 'output');
+	const routes: RouteDefinition[] = tree.routes
+		.filter((route) => route.page || route.endpoint)
+		.map((route) => {
+			const metadata = analysis.routes.get(route.id)!;
+			return {
+				id: route.id,
+				api: metadata.api,
+				page: metadata.page,
+				segments: route.id
+					.split('/')
+					.filter((segment) => segment && !/^\(.+\)$/.test(segment))
+					.map((content) => ({
+						content,
+						dynamic: content.includes('['),
+						rest: content.includes('[...')
+					})),
+				pattern: route.pattern,
+				prerender: context.prerenderMap.get(route.id) ?? false,
+				methods: metadata.methods,
+				config: metadata.config
+			};
+		});
+	const manifest = {
+		...context.manifest,
+		assets: [
+			...context.manifest.assets,
+			...(artifacts.serviceWorker ? [{ path: artifacts.serviceWorker }] : [])
+		]
+	};
+	const serverDirectory = path.join(output, 'server');
+	const builder: Builder = {
+		identity: context.identity,
+		config,
+		log: context.log,
+		routes,
+		prerendered,
+		manifest,
+		rimraf: remove,
+		mkdirp(directory) {
+			mkdirSync(directory, { recursive: true });
+		},
+		copy,
+		compress,
+		get mimeTypes() {
+			const types = Object.fromEntries(
+				tree.assets
+					.filter((asset) => asset.type)
+					.map((asset) => [path.extname(asset.file), asset.type!])
+			);
+			const files = [
+				...serverAssets(
+					context,
+					tree.routes.filter((route) => context.prerenderMap.get(route.id) !== true)
+				),
+				...walk(path.join(output, 'client')),
+				...walk(path.join(output, 'prerendered'))
+			];
+			for (const file of files) {
+				const extension = path.extname(file);
+				if (extension) types[extension] ??= lookup(file) ?? '';
+			}
+			return types;
+		},
+		findServerAssets(selected) {
+			return serverAssets(
+				context,
+				selected.map((route) => tree.routes.find((candidate) => candidate.id === route.id)!)
+			);
+		},
+		async generateFallback(destination) {
+			const html = await renderFallback(context);
+			if (existsSync(destination)) e.adapter_fallback_overwrites({ file: destination });
+			write(destination, html);
+		},
+		generateEnvModule() {
+			if (artifacts.client?.uses_env_dynamic_public)
+				write(
+					path.join(output, 'prerendered/dependencies', config.appDir, 'env.js'),
+					`export const env = ${uneval(analysis.environment)};`
+				);
+		},
+		generateServerInstance(destination, options = {}) {
+			const directory = options.serverDirectory ?? serverDirectory;
+			const relative = specifier(path.dirname(destination), directory);
+			const selected = options.routes
+				? options.routes.map((route) => tree.routes.find((candidate) => candidate.id === route.id)!)
+				: tree.routes.filter((route) => context.prerenderMap.get(route.id) !== true);
+			write(
+				destination,
+				`import { create_server } from ${JSON.stringify(relative + '/index.js')};\nconst manifest = ${manifestSource({ context, routes: selected, relativePath: relative })};\nexport const server = create_server(manifest);\n`
+			);
+		},
+		getBuildDirectory(name) {
+			return path.join(config.outDir, name);
+		},
+		getClientDirectory() {
+			return path.join(output, 'client');
+		},
+		getServerDirectory() {
+			return serverDirectory;
+		},
+		getAppPath() {
+			return [config.paths.base.slice(1), config.appDir].filter(Boolean).join('/');
+		},
+		writeClient(destination) {
+			return copy(path.join(output, 'client'), destination, { filter: (name) => name !== '.vite' });
+		},
+		writeServer(destination) {
+			return copy(serverDirectory, destination);
+		},
+		writePrerendered(destination) {
+			return ['pages', 'dependencies', 'data'].flatMap((directory) =>
+				copy(path.join(output, 'prerendered', directory), destination)
+			);
+		},
+		createInstrumentationInitializer(options) {
+			return initializer(options, serverDirectory);
+		},
+		hasServerInstrumentationFile() {
+			return existsSync(path.join(serverDirectory, 'instrumentation.server.js'));
+		},
+		instrument(options) {
+			instrument(options, e);
+		}
+	};
+	return builder;
+}

package/src/build/crawl.ts

@@ -0,0 +1,101 @@
+import { parse, parseFragment, type DefaultTreeAdapterTypes } from 'parse5';
+
+export interface CrawlResult {
+	ids: string[];
+	hrefs: string[];
+	invalid: string[];
+}
+const metaNames = new Set([
+	'og:url',
+	'og:image',
+	'og:image:url',
+	'og:image:secure_url',
+	'og:video',
+	'og:video:url',
+	'og:video:secure_url',
+	'og:audio',
+	'og:audio:url',
+	'og:audio:secure_url',
+	'twitter:image'
+]);
+const internalOrigin = 'http://crawl.invalid';
+
+export function decode(text: string): string {
+	const fragment = parseFragment(text.replaceAll('<', '&lt;'));
+	return fragment.childNodes
+		.map((node) => (node.nodeName === '#text' && 'value' in node ? node.value : ''))
+		.join('');
+}
+
+function candidates(value: string): string[] {
+	const urls: string[] = [];
+	let offset = 0;
+	while (offset < value.length) {
+		while (/[\s,]/.test(value[offset] ?? '') && offset < value.length) offset++;
+		const start = offset;
+		while (offset < value.length && !/\s/.test(value[offset]!)) offset++;
+		const token = value.slice(start, offset);
+		if (!token) break;
+		urls.push(token.replace(/,+$/, ''));
+		if (token.endsWith(',')) continue;
+		let parentheses = 0;
+		while (offset < value.length) {
+			const char = value[offset++]!;
+			if (char === '(') parentheses++;
+			if (char === ')') parentheses--;
+			if (char === ',' && !parentheses) break;
+		}
+	}
+	return urls;
+}
+
+export function crawl(html: string, base: string): CrawlResult {
+	const result: CrawlResult = { ids: [], hrefs: [], invalid: [] };
+	const elements: DefaultTreeAdapterTypes.Element[] = [];
+	function visit(node: DefaultTreeAdapterTypes.Node): void {
+		if ('tagName' in node) {
+			if (node.tagName === 'script' || node.tagName === 'style') return;
+			if (node.sourceCodeLocation) elements.push(node);
+			if (node.tagName === 'template') visit((node as DefaultTreeAdapterTypes.Template).content);
+		}
+		if ('childNodes' in node) node.childNodes.forEach(visit);
+	}
+	visit(parse(html, { sourceCodeLocationInfo: true }));
+	elements.sort((a, b) => a.sourceCodeLocation!.startOffset - b.sourceCodeLocation!.startOffset);
+	let currentBase = new URL(base, internalOrigin);
+	const resolve = (value: string) => {
+		if (value.startsWith('//')) return value;
+		const url = new URL(value, currentBase);
+		return url.origin === internalOrigin ? url.pathname + url.search + url.hash : url.href;
+	};
+	const push = (value: string) => {
+		try {
+			result.hrefs.push(resolve(value));
+		} catch {
+			result.invalid.push(value);
+		}
+	};
+	for (const element of elements) {
+		const attrs = Object.fromEntries(element.attrs.map(({ name, value }) => [name, value]));
+		if (attrs.href) {
+			if (element.tagName === 'base') {
+				try {
+					currentBase = new URL(attrs.href, currentBase);
+				} catch {
+					result.invalid.push(attrs.href);
+				}
+			} else if (!/\bexternal\b/i.test(attrs.rel ?? '')) push(attrs.href);
+		}
+		if (attrs.id) result.ids.push(decodeURI(attrs.id));
+		if (attrs.name && element.tagName === 'a') result.ids.push(decodeURI(attrs.name));
+		if (attrs.src) push(attrs.src);
+		if (attrs.srcset) candidates(attrs.srcset).forEach(push);
+		if (
+			element.tagName === 'meta' &&
+			attrs.content &&
+			metaNames.has(attrs.name ?? attrs.property ?? '')
+		)
+			push(attrs.content);
+	}
+	return result;
+}

package/src/build/features.ts

@@ -0,0 +1,51 @@
+import { BuildMessages } from './messages.ts';
+import type { BuildContext } from './types.ts';
+
+export type TrackedFeatures = Map<string, string[]>;
+
+const marker = /globalThis\.__VIGLA_TRACK__\?\.\(['"](.+?)['"]\)/g;
+
+export function trackFeatures(code: string, file: string, tracked: TrackedFeatures): string | null {
+	if (!code.includes('__VIGLA_TRACK__')) return null;
+	return code.replace(marker, (_, label: string) => {
+		const labels = tracked.get(file) ?? [];
+		labels.push(label);
+		tracked.set(file, labels);
+		return `/* track ${label} */`;
+	});
+}
+
+function featuresOf(context: BuildContext, tracked: TrackedFeatures, entries: string[]): string[] {
+	const features = new Set<string>();
+	const visited = new Set<string>();
+	const visit = (file: string): void => {
+		if (visited.has(file)) return;
+		visited.add(file);
+		for (const feature of tracked.get(file) ?? []) features.add(feature);
+		for (const imported of context.artifacts.chunks[file]?.imports ?? []) visit(imported);
+	};
+	entries.forEach(visit);
+	return [...features];
+}
+
+export function checkFeatures(context: BuildContext, tracked: TrackedFeatures): void {
+	const adapter = context.config.adapter;
+	if (!adapter || !tracked.size) return;
+	const e = new BuildMessages(context.diagnostics);
+	for (const route of context.tree.routes) {
+		const metadata = context.analysis.routes.get(route.id);
+		if (!metadata || metadata.prerender === true) continue;
+		const files = [
+			...(route.page ? [...route.page.layouts, route.page.leaf] : []).flatMap((index) => {
+				const server = index === undefined ? undefined : context.artifacts.nodes[index]?.server;
+				return server ? [server] : [];
+			}),
+			...(context.artifacts.endpoints[route.id] ? [context.artifacts.endpoints[route.id]!] : [])
+		];
+		if (
+			featuresOf(context, tracked, files).includes('$app/server:read') &&
+			!adapter.supports?.read?.({ route: { id: route.id }, config: metadata.config })
+		)
+			e.adapter_read_unsupported({ route: route.id, adapter: adapter.name });
+	}
+}

package/src/build/files.ts

@@ -0,0 +1,97 @@
+import {
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	writeFileSync
+} from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { brotliCompress, gzip, constants } from 'node:zlib';
+import type { CopyOptions } from '../types/builder.ts';
+
+export function posix(file: string): string {
+	return file.replaceAll('\\', '/');
+}
+export function specifier(from: string, to: string): string {
+	const relative = posix(path.relative(from, to));
+	return relative.startsWith('./') || relative.startsWith('../') ? relative : './' + relative;
+}
+export function write(file: string, source: string | Uint8Array): void {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, source);
+}
+export function walk(directory: string): string[] {
+	if (!existsSync(directory)) return [];
+	return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+		const file = path.join(directory, entry.name);
+		return entry.isDirectory()
+			? walk(file).map((child) => posix(path.join(entry.name, child)))
+			: [entry.name];
+	});
+}
+export function copy(source: string, destination: string, options: CopyOptions = {}): string[] {
+	if (!existsSync(source)) return [];
+	const files: string[] = [];
+	function visit(from: string, to: string, relative: string): void {
+		if (options.filter && !options.filter(path.basename(from))) return;
+		if (statSync(from).isDirectory()) {
+			mkdirSync(to, { recursive: true });
+			for (const name of readdirSync(from))
+				visit(path.join(from, name), path.join(to, name), path.join(relative, name));
+			return;
+		}
+		mkdirSync(path.dirname(to), { recursive: true });
+		if (options.replace) {
+			let content = readFileSync(from, 'utf8');
+			for (const [key, value] of Object.entries(options.replace))
+				content = content.replaceAll(key, value);
+			writeFileSync(to, content);
+		} else copyFileSync(from, to);
+		files.push(posix(relative || path.basename(from)));
+	}
+	visit(source, destination, '');
+	return files;
+}
+export function remove(directory: string): void {
+	rmSync(directory, { force: true, recursive: true });
+}
+
+const gzipAsync = promisify(gzip);
+const brotliAsync = promisify(brotliCompress);
+const compressible = new Set([
+	'.html',
+	'.js',
+	'.mjs',
+	'.json',
+	'.css',
+	'.svg',
+	'.xml',
+	'.wasm',
+	'.txt',
+	'.md',
+	'.mdx'
+]);
+
+export async function compress(directory: string): Promise<string[]> {
+	const files = walk(directory).filter((file) => compressible.has(path.extname(file)));
+	let next = 0;
+	await Promise.all(
+		Array.from({ length: Math.min(16, files.length) }, async () => {
+			while (next < files.length) {
+				const file = path.join(directory, files[next++]!);
+				const contents = readFileSync(file);
+				const [gz, br] = await Promise.all([
+					gzipAsync(contents, { level: constants.Z_BEST_COMPRESSION }),
+					brotliAsync(contents)
+				]);
+				writeFileSync(file + '.gz', gz);
+				writeFileSync(file + '.br', br);
+			}
+		})
+	);
+	return files;
+}

package/src/build/index.ts

@@ -0,0 +1,6 @@
+export { createBuilder, createLogger } from './builder.ts';
+export { manifestSource, serverAssets, writeNodes } from './manifest.ts';
+export { checkFeatures, trackFeatures, type TrackedFeatures } from './features.ts';
+export { analyseBuild, prerenderBuild } from './worker.ts';
+export { copy, posix, specifier, walk, write } from './files.ts';
+export type * from './types.ts';