@torpor/build 0.4.14 → 1.0.0

package/src/run/runDev.ts

@@ -1,26 +1,67 @@
 import estorpor from "@torpor/unplugin/esbuild";
 import torpor from "@torpor/unplugin/vite";
 import { configDotenv } from "dotenv";
-import { promises as fs } from "node:fs";
+import { readFileSync } from "node:fs";
 import path from "node:path";
-import { createServer as createViteServer } from "vite";
-import { serverError } from "../response.ts";
-import Server from "../server/Server.ts";
-import connectMiddleware from "../server/connect/connectMiddleware.ts";
+import {
+	type AliasOptions,
+	createServer as createViteServer,
+	type Plugin,
+	type ViteDevServer,
+} from "vite";
 import Site from "../site/Site.ts";
+import {
+	checkApiCallSource,
+	checkApiCalls,
+	checkRoute,
+	checkRoutes,
+	createApiCallCheck,
+	type RouteCheckIssue,
+	reportRouteIssues,
+} from "../site/checkRoutes";
 import manifest from "../site/manifest.ts";
-import prepareTemplate from "./prepareTemplate.ts";
+import { checkLayoutSlot, checkLayoutSlots } from "../site/checkLayoutSlots";
+import { LAYOUT_ROUTE } from "../types/RouteType";
+import tsconfigAliases, { type AliasEntry } from "../utils/tsconfigAliases";
+import { addTorporPackageConfig } from "../utils/torporPackages";
+import devPlugin from "./devPlugin.ts";
+import { clearStaleDepCache } from "./depCache";
+import { reportStaleTorpCopies } from "./staleTorpCopies";
 
 export default async function runDev(site: Site): Promise<void> {
-	const server = new Server();
-
-	// Create the Vite server in middleware mode and configure the app type as
-	// "custom", disabling Vite's own HTML serving logic so the parent server
-	// can take control
+	// Create the Vite dev server. Unlike the previous middleware-mode setup, we
+	// let Vite own the HTTP server (so HMR/websockets work natively) and let the
+	// adapter's `dev()` plugin(s) handle SSR via configureServer.
 	const config = structuredClone(site.viteConfig ?? {});
-	config.server = { middlewareMode: true };
 	config.appType = "custom";
-	config.plugins = [manifest(site, true), torpor({ dev: true }), ...site.plugins];
+	config.server ??= {};
+	config.server.host ??= "localhost";
+	config.server.port ??= 7059;
+	// Resolve tsconfig path aliases (e.g. `@/*`). Previously provided by the
+	// default `vite-tsconfig-paths` plugin on Site; vite-plus handles it inline
+	config.resolve ??= {};
+	config.resolve.tsconfigPaths ??= true;
+	// Resolve `@torpor/view` (runtime, compiler, SSR) from source in dev mode
+	// so changes to the compiler take effect without rebuilding dist.
+	config.resolve.conditions ??= [];
+	config.resolve.conditions.push("development");
+	// vite-plus' `tsconfigPaths` isn't honored by the SSR module-runner's
+	// externalization path (it hardcodes tsconfigPaths:false), so dev SSR can't
+	// resolve path aliases. Mirror tsconfig `compilerOptions.paths` as Vite
+	// `resolve.alias` so they resolve during transform for both client and SSR.
+	config.resolve.alias = [...asAliasArray(config.resolve.alias), ...tsconfigAliases(site.root)];
+
+	// The adapter provides the dev-runtime plugin(s); fall back to the
+	// framework's Node-runtime plugin when it doesn't.
+	const adapterDev = site.adapter.dev?.(site);
+	const devPlugins = normalizePlugins(adapterDev ?? devPlugin(site));
+
+	config.plugins = [
+		manifest(site, true),
+		torpor({ dev: true }),
+		...devPlugins,
+		...site.vitePlugins,
+	];
 
 	// HACK: To be able to import `.torp` files from barrel files in
 	// node_modules, we need to add their libraries to `ssr.noExternal` in
@@ -28,62 +69,109 @@ export default async function runDev(site: Site): Promise<void> {
 	config.optimizeDeps ??= {};
 	config.optimizeDeps.extensions ??= [];
 	config.optimizeDeps.extensions.push(".torp");
-	config.optimizeDeps.esbuildOptions ??= {};
-	config.optimizeDeps.esbuildOptions.plugins ??= [];
-	config.optimizeDeps.esbuildOptions.plugins.push(estorpor());
+	config.optimizeDeps.rolldownOptions ??= {};
+	config.optimizeDeps.rolldownOptions.plugins ??= [estorpor()];
+	// TODO: config.optimizeDeps.rolldownOptions.plugins.push(estorpor());
+
+	// Packages that ship `.torp` files (e.g. icon libraries) need the torpor
+	// compiler: dep optimization would parse them as plain JavaScript and
+	// fail, and SSR externalization would leave raw `.torp` imports that
+	// Node/workerd can't load. Exclude them from optimization and mark them
+	// for SSR bundling so they go through the torpor plugin
+	addTorporPackageConfig(site.root, config);
+
+	// Workspace packages may have been rebuilt since the last dev run; drop
+	// Vite's dep cache so SSR never executes stale prebundled modules
+	clearStaleDepCache(site.root, (message) => console.log(`\n${message}`));
+
+	// A workspace package with dist .torp copies (e.g. @torpor/ui) whose src
+	// changed without a rebuild serves OLD components to the site, silently;
+	// report the drift so it can be fixed with a rebuild
+	reportStaleTorpCopies(site.root, (message) => console.log(`\n${message}`));
+
+	// Load environment variables from a `.env` file, with defaults if not set
+	configDotenv();
+
+	process.env.PROTOCOL ??= "http:";
+	process.env.HOST ??= "localhost";
+	process.env.PORT ??= "7059";
+
+	const connectingUrl = `${process.env.PROTOCOL}//${process.env.HOST}:${process.env.PORT}`;
+	console.log(`\nConnecting to ${connectingUrl}`);
 
 	const vite = await createViteServer(config);
+	await vite.listen();
 
-	// Read site.html
-	// It's called site.html because @torpor/build builds the site (html, routes
-	// etc) while the user builds the app (components etc)
-	const templateFile = path.resolve(site.root, "src/site.html");
-	let template = await fs.readFile(templateFile, "utf-8");
+	watchRouteTypes(site, vite);
 
-	// Apply Vite HTML transforms. This injects the Vite HMR client, and also
-	// applies HTML transforms from Vite plugins. Note that we only support a
-	// universal transform, not individual transforms for each route
-	template = await vite.transformIndexHtml("", template);
+	const listeningUrl = vite.resolvedUrls?.local?.[0] ?? connectingUrl;
+	console.log(`Listening on ${listeningUrl}\n`);
+}
 
-	const siteFolder = path.resolve(site.root, "./node_modules/@torpor/build/src/site/");
-	let clientScript = path.join(siteFolder, "clientEntry.ts");
-	let clientDevScript = path.join(siteFolder, "clientEntryDev.ts");
-	let serverScript = path.join(siteFolder, "serverEntry.ts");
+/**
+ * Reports route type issues at startup, then re-checks route files and
+ * `makeApi` calls as they change so annotation problems surface during
+ * development without failing the dev server.
+ */
+function watchRouteTypes(site: Site, vite: ViteDevServer): void {
+	reportRouteIssues(checkRoutes(site));
+	reportRouteIssues(checkApiCalls(site));
+	reportRouteIssues(checkLayoutSlots(site));
 
-	// Prepare site.html so that we can just splice components into it
-	template = prepareTemplate(template, clientScript, clientDevScript);
+	// Map absolute route file paths to their manifest entries, so changed
+	// files can be re-checked against their derived route. Layout route files
+	// are included for their slot check (a .torp layout is its own component)
+	const routeFiles = new Map(
+		site.routes
+			.filter(
+				(r) => r.file?.endsWith(".ts") || (r.file?.endsWith(".torp") && r.type === LAYOUT_ROUTE),
+			)
+			.map((r) => [path.resolve(site.root, r.file!), r]),
+	);
+	const apiCheck = createApiCallCheck(site);
+	// Only report when a file's issues change, to avoid repeating the same
+	// warnings on every save
+	const reported = new Map<string, string>();
 
-	// Use Vite's Connect instance as middleware. We need to wrap it with
-	// createMiddlewareHandler that converts Connect middleware to
-	// Request/Response web handlers
-	server.use(connectMiddleware(vite.middlewares));
+	const report = (file: string, issues: RouteCheckIssue[]) => {
+		const key = JSON.stringify(issues);
+		if (reported.get(file) === key) return;
+		reported.set(file, key);
+		reportRouteIssues(issues);
+	};
 
-	// Every request (GET, POST, etc) goes through loadEndPoint
-	server.add("*", async (ev) => {
+	const recheck = (file: string): void => {
+		const route = routeFiles.get(file);
+		if (route) {
+			report(
+				file,
+				route.type === LAYOUT_ROUTE ? checkLayoutSlot(site, route) : checkRoute(site, route),
+			);
+			return;
+		}
+		if (!/\.(ts|js|torp)$/.test(file)) return;
+		let source: string;
 		try {
-			// Load the server entry. ssrLoadModule automatically transforms ESM
-			// source code to be usable in Node.js. No bundling is required, and
-			// it provides efficient invalidation similar to HMR
-			const { load } = await vite.ssrLoadModule(serverScript);
-
-			// Render the app HTML (or fetch server data etc) via serverEntry's
-			// exported `load` function
-			return await load(ev, template);
-		} catch (e: any) {
-			// If an error is caught, let Vite fix the stack trace so it maps
-			// back to your actual source code
-			vite.ssrFixStacktrace(e);
-			return serverError(e);
+			source = readFileSync(file, "utf8");
+		} catch {
+			return;
 		}
-	});
+		report(file, checkApiCallSource(source, file, apiCheck));
+	};
 
-	// Load environment variables from a `.env` file, with defaults if not set
-	configDotenv();
+	vite.watcher.on("change", recheck);
+	vite.watcher.on("add", recheck);
+}
 
-	process.env.PROTOCOL ??= "http:";
-	process.env.HOST ??= "localhost";
-	process.env.PORT ??= "7059";
+function normalizePlugins(plugins: Plugin | Plugin[] | void): Plugin[] {
+	if (!plugins) return [];
+	return Array.isArray(plugins) ? plugins : [plugins];
+}
 
-	// Serve the site
-	site.adapter.serve(server, site);
+function asAliasArray(alias: AliasOptions | undefined): AliasEntry[] {
+	// Normalize an existing `resolve.alias` value (array | object | undefined)
+	// into an array so we can concatenate our tsconfig-derived aliases.
+	if (!alias) return [];
+	if (Array.isArray(alias)) return alias;
+	return Object.entries(alias).map(([find, replacement]) => ({ find, replacement }));
 }

package/src/run/runOpenApi.ts

@@ -0,0 +1,52 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { ViteDevServer } from "vite";
+import buildOpenApiDocument from "../openapi/document";
+import { OPEN_API_STATE_KEY } from "../openapi/plugin";
+import type { OpenApiEndPoint, OpenApiRouteEntry, ResolvedOpenApiOptions } from "../openapi/types";
+import type Site from "../site/Site";
+import { SERVER_ROUTE } from "../types/RouteType";
+
+/**
+ * Writes an OpenAPI document for the site's +server endpoints to a file.
+ * Route files are loaded through the supplied Vite server, so this must be
+ * called while the server from `loadSite` is still open.
+ */
+export default async function runOpenApi(
+	site: Site,
+	vite: ViteDevServer,
+	outFile = "openapi.json",
+): Promise<void> {
+	const options = site.pluginState.get(OPEN_API_STATE_KEY) as ResolvedOpenApiOptions | undefined;
+	if (!options) {
+		throw new Error(
+			'No OpenAPI options found. Add the openApi() plugin to site.plugins to use "tb --openapi"',
+		);
+	}
+
+	const entries: OpenApiRouteEntry[] = [];
+	for (const route of site.routes) {
+		if (route.type !== SERVER_ROUTE) {
+			continue;
+		}
+		// Don't document the docs page itself
+		if (options.docs && route.path === options.docs) {
+			continue;
+		}
+		if (route.endPoint && !route.file) {
+			// Inline endpoint
+			entries.push({ path: route.path, endPoint: route.endPoint as OpenApiEndPoint });
+		} else if (route.file) {
+			const file = path.resolve(site.root, route.file);
+			const mod = await vite.ssrLoadModule(file);
+			entries.push({ path: route.path, endPoint: mod.default });
+		}
+	}
+
+	const doc = buildOpenApiDocument(entries, options);
+	await writeFile(path.resolve(site.root, outFile), JSON.stringify(doc, null, 2) + "\n");
+
+	console.log(
+		`OpenAPI document written to ${outFile} (${Object.keys(doc.paths ?? {}).length} paths)`,
+	);
+}

package/src/run/runPreview.ts

@@ -16,23 +16,24 @@ export default async function runPreview(site: Site): Promise<void> {
 	const clientFolder = path.join(distFolder, "client");
 	const serverFolder = path.join(distFolder, "server");
 
-	// Find the client script file in /assets
-	let clientScript = (await fs.readdir(path.join(clientFolder, "assets"))).find((f) =>
-		f.startsWith("clientEntry-"),
-	);
-	if (!clientScript) {
-		throw new Error("clientEntry.js not found");
-	}
-	clientScript = `/assets/${clientScript}`;
+	// Read site.html if present, and find the client script file in /assets.
+	// An endpoints-only site has no site.html, and no template is needed
+	let template: string | undefined;
+	const siteHtml = path.join(clientFolder, "site.html");
+	if (existsSync(siteHtml)) {
+		let clientScript = (await fs.readdir(path.join(clientFolder, "assets"))).find((f) =>
+			f.startsWith("clientEntry-"),
+		);
+		if (!clientScript) {
+			throw new Error("clientEntry.js not found");
+		}
+		clientScript = `/assets/${clientScript}`;
 
-	// Read site.html
-	// It's called site.html because @torpor/build builds the site (html, routes
-	// etc) while the user builds the app (components etc)
-	let siteHtml = path.join(clientFolder, "site.html");
-	let template = await fs.readFile(siteHtml, "utf-8");
+		template = await fs.readFile(siteHtml, "utf-8");
 
-	// Prepare site.html so that we can just splice components into it
-	template = prepareTemplate(template, clientScript);
+		// Prepare site.html so that we can just splice components into it
+		template = prepareTemplate(template, clientScript);
+	}
 
 	// Configure the server
 	const server = new Server();
@@ -43,8 +44,7 @@ export default async function runPreview(site: Site): Promise<void> {
 			const url = new URL(ev.request.url);
 			const file = path.join(site.root, "dist", "client", url.pathname);
 			if (existsSync(file)) {
-				// TODO: Stream the data?
-				const body = bufferToArrayBuffer(await fs.readFile(file));
+				const body = await fs.readFile(file);
 				return new Response(body, {
 					status: 200,
 					headers: {
@@ -82,12 +82,3 @@ export default async function runPreview(site: Site): Promise<void> {
 	// Serve the site
 	site.adapter.serve(server, site);
 }
-
-// From https://stackoverflow.com/a/79345620
-// No idea why it is needed
-function bufferToArrayBuffer(buffer: Buffer): ArrayBuffer {
-	return buffer.buffer.slice(
-		buffer.byteOffset,
-		buffer.byteOffset + buffer.byteLength,
-	) as ArrayBuffer;
-}

package/src/run/staleTorpCopies.ts

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import type { PackageJson } from "../utils/torporPackages";
+import { findWorkspaceRoot, workspaceDependencyDirs } from "./depCache";
+
+/**
+ * Workspace packages that ship copies of their .torp components (e.g.
+ * @torpor/ui copies its src .torp files into dist/ during its build) can go
+ * stale: a site resolves the package to its dist folder, so edits to src
+ * silently keep serving the OLD components until the package is rebuilt.
+ * The symptom is confusing -- e.g. a TypeError about a renamed slot prop
+ * after a component's API changed.
+ *
+ * reportStaleTorpCopies runs at `tb --dev` startup: for every workspace
+ * dependency with both src and dist folders, it compares the .torp files and
+ * reports anything missing from dist, differing from src, or left over in
+ * dist without a src file.
+ */
+
+/**
+ * Reports stale dist .torp copies in the site's workspace dependencies.
+ * Never throws -- a broken check must not break dev startup.
+ */
+export function reportStaleTorpCopies(siteRoot: string, log?: (message: string) => void): void {
+	try {
+		const workspaceRoot = findWorkspaceRoot(siteRoot);
+		if (!workspaceRoot) return;
+
+		for (const dir of workspaceDependencyDirs(siteRoot, workspaceRoot)) {
+			const srcFolder = path.join(dir, "src");
+			const distFolder = path.join(dir, "dist");
+			// Only packages that ship dist copies of src .torp files are
+			// checked; packages without the folders (or with neither .torp
+			// set) are skipped
+			if (!existsSync(srcFolder) || !existsSync(distFolder)) continue;
+			const src = collectTorpFiles(srcFolder);
+			const dist = collectTorpFiles(distFolder);
+			if (src.size === 0 && dist.size === 0) continue;
+
+			const problems: string[] = [];
+			for (const [rel, content] of src) {
+				const distContent = dist.get(rel);
+				if (distContent === undefined) {
+					problems.push(`${rel} (not copied to dist)`);
+				} else if (distContent !== content) {
+					problems.push(`${rel} (differs from src)`);
+				}
+			}
+			for (const rel of dist.keys()) {
+				if (!src.has(rel)) {
+					problems.push(`${rel} (left over in dist, no src file)`);
+				}
+			}
+			if (problems.length === 0) continue;
+
+			const shown = problems
+				.slice(0, 5)
+				.map((p) => `  ${p}`)
+				.join("\n");
+			const more = problems.length > 5 ? `\n  ... and ${problems.length - 5} more` : "";
+			log?.(
+				`${packageLabel(dir, workspaceRoot)}'s dist .torp copies are stale, so the site is ` +
+					`serving OLD components:\n${shown}${more}\n` +
+					`Rebuild the package (e.g. \`pnpm build\` in ` +
+					`${path.relative(workspaceRoot, dir) || "."}) and restart \`tb --dev\`.`,
+			);
+		}
+	} catch (e) {
+		if (process.env.TORPOR_DEBUG_CACHE) throw e;
+	}
+}
+
+function collectTorpFiles(folder: string): Map<string, string> {
+	const files = new Map<string, string>();
+	collect(folder, folder, files);
+	return files;
+}
+
+function collect(folder: string, root: string, files: Map<string, string>): void {
+	for (const entry of readdirSync(folder, { withFileTypes: true })) {
+		if (entry.name === "node_modules" || entry.name === ".git") continue;
+		const full = path.join(folder, entry.name);
+		if (entry.isDirectory()) {
+			collect(full, root, files);
+			continue;
+		}
+		if (!entry.isFile() || !entry.name.endsWith(".torp")) continue;
+		files.set(path.relative(root, full).replaceAll("\\", "/"), readFileSync(full, "utf8"));
+	}
+}
+
+function packageLabel(dir: string, workspaceRoot: string): string {
+	try {
+		const pkg: PackageJson = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+		if (pkg.name) return pkg.name;
+	} catch {
+		// Fall through to the relative path
+	}
+	return path.relative(workspaceRoot, dir) || dir;
+}

package/src/run.ts

@@ -1,6 +1,7 @@
 import run from "./run/run";
 import runBuild from "./run/runBuild";
 import runDev from "./run/runDev";
+import runOpenApi from "./run/runOpenApi";
 import runPreview from "./run/runPreview";
 
-export { run, runDev, runBuild, runPreview };
+export { run, runDev, runBuild, runPreview, runOpenApi };

package/src/schema.ts

@@ -0,0 +1,7 @@
+import validate from "./validation/validate";
+
+export { validate };
+
+export { default as ValidationError } from "./validation/ValidationError";
+
+export type { StandardSchemaV1 } from "./types/StandardSchema";

package/src/server/CookieHelper.ts

@@ -1,4 +1,4 @@
-import { SerializeOptions, parse, serialize } from "cookie";
+import { type SerializeOptions, parseCookie, stringifySetCookie } from "cookie";
 
 export default class CookieHelper {
 	request: Request;
@@ -11,11 +11,14 @@ export default class CookieHelper {
 	get(name: string): string | undefined {
 		// If it's been set, return the value from the map
 		if (this.cookies.has(name)) {
-			return parse(this.cookies.get(name)!)[name];
+			// The stored value is a serialized Set-Cookie header; pull the
+			// "name=value" prefix off and re-parse to get just the value
+			return parseCookie(this.cookies.get(name)!)[name];
 		}
+
 		// Otherwise, return the value from the `cookie` header
-		const header = this.request.headers.get("cookie");
-		return parse(header ?? "")[name];
+		const header = this.request.headers.get("Cookie");
+		return parseCookie(header ?? "")[name];
 	}
 
 	set(name: string, value: string, options?: SerializeOptions): void {
@@ -24,13 +27,20 @@ export default class CookieHelper {
 		options.httpOnly ??= true;
 		options.secure ??= true;
 		options.sameSite ??= "lax";
-		this.cookies.set(name, serialize(name, value, options));
+
+		this.cookies.set(name, stringifySetCookie({ name, value, ...options }));
 	}
 
 	delete(name: string, options?: SerializeOptions): void {
-		// Set a cookie header with an immediate expiry date
+		// Set a cookie header with an empty value and an immediate expiry date.
+		// Apply the same secure defaults as `set` so a previously-set Secure
+		// cookie is actually overridden by the deletion.
 		options ??= {};
+		options.httpOnly ??= true;
+		options.secure ??= true;
+		options.sameSite ??= "lax";
 		options.expires = new Date(0);
-		this.cookies.set(name, serialize(name, "", options));
+
+		this.cookies.set(name, stringifySetCookie({ name, value: "", ...options }));
 	}
 }

package/src/server/Server.ts

@@ -1,16 +1,16 @@
-import pathToRegex from "../utils/pathToRegex";
+import PathTrie from "../utils/pathTrie";
 import ServerEvent from "./ServerEvent";
 import type MiddlewareFunction from "./types/MiddlewareFunction";
 import type ServerFunction from "./types/ServerFunction";
 
-const noop = () => {};
-
 /**
  * A Fetch API Request/Response server.
  */
 export default class Server {
 	// TODO: We don't use any of the routes, just add("*") in runDev/runBuild...
 	routes: RouteHandler[] = [];
+	// Match index for the routes above
+	#trie = new PathTrie<RouteHandler>();
 	// TODO: We only use the Vite middleware here
 	middleware: MiddlewareFunction[] = [];
 
@@ -25,29 +25,55 @@ export default class Server {
 	 * @returns
 	 */
 	fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-		const request = new Request(input, init);
+		// Use the request as-is when we were given one, so that the adapter
+		// doesn't pay for constructing it twice
+		const request = input instanceof Request && !init ? input : new Request(input, init);
 		const url = new URL(request.url);
 		const match = this.match(url.pathname);
-		let ev = new ServerEvent(request, match?.params);
+		let ev = new ServerEvent(request, match?.params, url);
 
 		if (this.middleware.length) {
 			// TODO: Get middleware that applies to this route only?
-			await this.middleware[0](ev, buildNext(this.middleware, 0));
-			function buildNext(middleware: MiddlewareFunction[], i: number): () => void | Promise<void> {
-				if (ev.response) {
-					return noop;
+			let entered = 0;
+			let response: Response | undefined = undefined;
+			let error: unknown = undefined;
+			try {
+				for (; entered < this.middleware.length && !response; entered++) {
+					// A middleware returns a Response to short-circuit the request
+					const result = await this.middleware[entered].enter?.(ev);
+					if (result) {
+						response = result;
+					}
 				}
-
-				if (i < middleware.length - 1) {
-					let next = middleware[i + 1];
-					return async () => next(ev, buildNext(middleware, i + 1));
-				} else {
-					return match
-						? async () => {
-								ev.response = await match.fn(ev);
-							}
-						: noop;
+				if (!response && match) {
+					const result = await match.fn(ev);
+					if (result) {
+						response = result;
+					}
+				}
+			} catch (e) {
+				// Exits can handle the error by returning a Response; if none
+				// does, it is rethrown below
+				error = e;
+				ev.error = e;
+			} finally {
+				if (response) {
+					ev.response = response;
 				}
+				// Run exit hooks in reverse order for the middleware that were
+				// entered. An exit hook can return a Response to replace the
+				// response, or to handle ev.error
+				while (entered > 0) {
+					entered--;
+					const result = await this.middleware[entered].exit?.(ev);
+					if (result) {
+						response = result;
+						ev.response = result;
+					}
+				}
+			}
+			if (error && !response) {
+				throw error;
 			}
 		} else if (match) {
 			ev.response = await match.fn(ev);
@@ -69,20 +95,20 @@ export default class Server {
 	 * @returns
 	 */
 	add(path: string, fn: ServerFunction): Server {
-		this.routes.push(new RouteHandler(path, fn));
+		let handler = new RouteHandler(path, fn);
+		this.routes.push(handler);
+		this.#trie.insert(path, handler);
 		this.#sortRoutes();
 		return this;
 	}
 
 	match(path: string): Match | undefined {
-		for (let handler of this.routes) {
-			let match = path.match(handler.regex);
-			if (match) {
-				return {
-					fn: handler.fn,
-					params: match.groups,
-				};
-			}
+		const found = this.#trie.match(path);
+		if (found) {
+			return {
+				fn: found.value.fn,
+				params: found.params,
+			};
 		}
 		console.log(`Server path not found: ${path}`);
 	}
@@ -116,12 +142,10 @@ export default class Server {
 
 class RouteHandler {
 	path: string;
-	regex: RegExp;
 	fn: ServerFunction;
 
 	constructor(path: string, fn: ServerFunction) {
 		this.path = path;
-		this.regex = pathToRegex(path);
 		this.fn = fn;
 	}
 }