spooder 4.6.2 → 5.0.0

package/src/api.ts

@@ -2,27 +2,304 @@ import { dispatch_report } from './dispatch';
 import http from 'node:http';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import { log } from './utils';
 import crypto from 'crypto';
 import { Blob } from 'node:buffer';
-import { Database } from 'bun:sqlite';
-import type * as mysql_types from 'mysql2/promise';
-
-let mysql: typeof mysql_types | undefined;
-try {
-	mysql = await import('mysql2/promise') as typeof mysql_types;
-} catch (e) {
-	// mysql2 optional dependency not installed.
-	// this dependency will be replaced once bun:sql supports mysql.
-	// db_update_schema_mysql and db_init_schema_mysql will throw.
+import { ColorInput } from 'bun';
+import packageJson from '../package.json' with { type: 'json' };
+
+// region api forwarding
+export * from './api_db';
+// endregion
+
+// region workers
+type WorkerMessageData = Record<string, any>;
+type WorkerEventPipeOptions = {
+	use_canary_reporting?: boolean;
+};
+
+export interface WorkerEventPipe {
+	send: (id: string, data?: object) => void;
+	on: (event: string, callback: (data: WorkerMessageData) => Promise<void> | void) => void;
+	once: (event: string, callback: (data: WorkerMessageData) => Promise<void> | void) => void;
+	off: (event: string) => void;
 }
 
-export const HTTP_STATUS_CODE = http.STATUS_CODES;
+function worker_validate_message(message: any) {
+	if (typeof message !== 'object' || message === null)
+		throw new ErrorWithMetadata('invalid worker message type', { message });
+	
+	if (typeof message.id !== 'string')
+		throw new Error('missing worker message .id');
+}
 
-// Create enum containing HTTP methods
-type HTTP_METHOD = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
-type HTTP_METHODS = HTTP_METHOD|HTTP_METHOD[];
+const log_worker = log_create_logger('worker', 'spooder');
+export function worker_event_pipe(worker: Worker, options?: WorkerEventPipeOptions): WorkerEventPipe {
+	const use_canary_reporting = options?.use_canary_reporting ?? false;
+	const callbacks = new Map<string, (data: Record<string, any>) => Promise<void> | void>();
+	
+	function handle_message(event: MessageEvent) {
+		try {
+			const message = JSON.parse(event.data);
+			worker_validate_message(message);
+			
+			const callback = callbacks.get(message.id);
+			if (callback !== undefined)
+				callback(message.data ?? {});
+		} catch (e) {
+			log_error(`exception in worker: ${(e as Error).message}`);
+			
+			if (use_canary_reporting)
+				caution('worker: exception handling payload', { exception: e });
+		}
+	}
+	
+	if (Bun.isMainThread) {
+		log_worker(`event pipe connected {main thread} ⇄ {worker}`);
+		worker.addEventListener('message', handle_message);
+	} else {
+		log_worker(`event pipe connected {worker} ⇄ {main thread}`);
+		worker.onmessage = handle_message;
+	}
+	
+	return {
+		send: (id: string, data: object = {}) => {
+			worker.postMessage(JSON.stringify({ id, data }));
+		},
+		
+		on: (event: string, callback: (data: WorkerMessageData) => Promise<void> | void) => {
+			callbacks.set(event, callback);
+		},
+		
+		off: (event: string) => {
+			callbacks.delete(event);
+		},
+		
+		once: (event: string, callback: (data: WorkerMessageData) => Promise<void> | void) => {
+			callbacks.set(event, async (data: WorkerMessageData) => {
+				await callback(data);
+				callbacks.delete(event);
+			});
+		}
+	};
+}
+// endregion
+
+// region utility
+const FILESIZE_UNITS = ['bytes', 'kb', 'mb', 'gb', 'tb'];
+
+function filesize(bytes: number): string {
+	if (bytes === 0)
+		return '0 bytes';
+	
+	const i = Math.floor(Math.log(bytes) / Math.log(1024));
+	const size = bytes / Math.pow(1024, i);
+	
+	return `${size.toFixed(i === 0 ? 0 : 1)} ${FILESIZE_UNITS[i]}`;
+}
+// endregion
+
+// region logging
+export function log_create_logger(label: string, color: ColorInput = 'blue') {
+	if (color === 'spooder')
+		color = '#16b39e';
+	
+	const ansi = Bun.color(color, 'ansi-256') ?? '\x1b[38;5;6m';
+	const prefix = `[${ansi}${label}\x1b[0m] `;
+	
+	return (message: string) => {
+		process.stdout.write(prefix + message.replace(/\{([^}]+)\}/g, `${ansi}$1\x1b[0m`) + '\n');
+	};
+}
+
+export function log_list(input: any[], delimiter = ',') {
+	return input.map(e => `{${e}}`).join(delimiter);
+}
 
+const log_spooder = log_create_logger('spooder', 'spooder');
+export const log = log_create_logger('info', 'blue');
+export const log_error = log_create_logger('error', 'red');
+
+// endregion
+
+// region cache
+type CacheOptions = {
+	ttl?: number;
+	max_size?: number;
+	use_etags?: boolean;
+	headers?: Record<string, string>,
+	use_canary_reporting?: boolean;
+};
+
+type CacheEntry = {
+	content: string;
+	last_access_ts: number;
+	etag?: string;
+	content_type: string;
+	size: number;
+	cached_ts: number;
+};
+
+const CACHE_DEFAULT_TTL = 5 * 60 * 60 * 1000; // 5 hours
+const CACHE_DEFAULT_MAX_SIZE = 5 * 1024 * 1024; // 5 MB
+
+const log_cache = log_create_logger('cache', 'spooder');
+
+function is_cache_http(target: any): target is ReturnType<typeof cache_http> {
+	return target && typeof target === 'object' && 'entries' in target && typeof target.entries === 'object';
+}
+
+export function cache_http(options?: CacheOptions) {
+	const ttl = options?.ttl ?? CACHE_DEFAULT_TTL;
+	const max_cache_size = options?.max_size ?? CACHE_DEFAULT_MAX_SIZE;
+	const use_etags = options?.use_etags ?? true;
+	const cache_headers = options?.headers ?? {};
+	const canary_report = options?.use_canary_reporting ?? false;
+	
+	const entries = new Map<string, CacheEntry>();
+	let total_cache_size = 0;
+	
+	function get_and_validate_entry(cache_key: string, now_ts: number): CacheEntry | undefined {
+		let entry = entries.get(cache_key);
+		
+		if (entry) {
+			entry.last_access_ts = now_ts;
+			
+			if (now_ts - entry.cached_ts > ttl) {
+				log_cache(`access: invalidating expired cache entry {${cache_key}} (TTL expired)`);
+				entries.delete(cache_key);
+				total_cache_size -= entry.size ?? 0;
+				entry = undefined;
+			}
+		}
+		
+		return entry;
+	}
+	
+	function store_cache_entry(cache_key: string, entry: CacheEntry, now_ts: number): void {
+		const size = entry.size;
+		
+		if (size < max_cache_size) {
+			if (use_etags)
+				entry.etag = crypto.createHash('sha256').update(entry.content).digest('hex');
+			
+			entries.set(cache_key, entry);
+			total_cache_size += size;
+			
+			log_cache(`caching {${cache_key}} (size: {${filesize(size)}}, etag: {${entry.etag ?? 'none'}})`);
+			
+			if (total_cache_size > max_cache_size) {
+				log_cache(`exceeded maximum capacity {${filesize(total_cache_size)}} > {${filesize(max_cache_size)}}, freeing space...`);
+				
+				if (canary_report) {
+					caution('cache exceeded maximum capacity', {
+						total_cache_size,
+						max_cache_size,
+						item_count: entries.size
+					});
+				}
+				
+				log_cache(`free: force-invalidating expired entries`);
+				for (const [key, cache_entry] of entries.entries()) {
+					if (now_ts - cache_entry.last_access_ts > ttl) {
+						log_cache(`free: invalidating expired cache entry {${key}} (TTL expired)`);
+						entries.delete(key);
+						total_cache_size -= cache_entry.size;
+					}
+				}
+				
+				if (total_cache_size > max_cache_size) {
+					log_cache(`free: cache still over-budget {${filesize(total_cache_size)}} > {${filesize(max_cache_size)}}, pruning by last access`);
+					const sorted_entries = Array.from(entries.entries()).sort((a, b) => a[1].last_access_ts - b[1].last_access_ts);
+					for (let i = 0; i < sorted_entries.length && total_cache_size > max_cache_size; i++) {
+						const [key, cache_entry] = sorted_entries[i];
+						log_cache(`free: removing entry {${key}} (size: {${filesize(cache_entry.size)}})`);
+						entries.delete(key);
+						total_cache_size -= cache_entry.size;
+					}
+				}
+			}
+		} else {
+			log_cache(`{${cache_key}} cannot enter cache, exceeds maximum size {${filesize(size)} > ${filesize(max_cache_size)}}`);
+			
+			if (canary_report) {
+				caution('cache entry exceeds maximum size', {
+					file_path: cache_key,
+					size,
+					max_cache_size
+				});
+			}
+		}
+	}
+	
+	function build_response(entry: CacheEntry, req: Request, status_code: number): Response {
+		const headers = Object.assign({
+			'Content-Type': entry.content_type
+		}, cache_headers) as Record<string, string>;
+		
+		if (use_etags && entry.etag) {
+			headers['ETag'] = entry.etag;
+			
+			if (req.headers.get('If-None-Match') === entry.etag)
+				return new Response(null, { status: 304, headers });
+		}
+		
+		return new Response(entry.content, { status: status_code, headers });
+	}
+	
+	return {
+		entries,
+		
+		file(file_path: string) {
+			return async (req: Request, url: URL) => {
+				const now_ts = Date.now();
+				let entry = get_and_validate_entry(file_path, now_ts);
+				
+				if (entry === undefined) {
+					const file = Bun.file(file_path);
+					const content = await file.text();
+					const size = Buffer.byteLength(content);
+					
+					entry = {
+						content,
+						size,
+						last_access_ts: now_ts,
+						content_type: file.type,
+						cached_ts: now_ts
+					};
+					
+					store_cache_entry(file_path, entry, now_ts);
+				}
+				
+				return build_response(entry, req, 200);
+			};
+		},
+		
+		async request(req: Request, cache_key: string, content_generator: () => string | Promise<string>, status_code = 200): Promise<Response> {
+			const now_ts = Date.now();
+			let entry = get_and_validate_entry(cache_key, now_ts);
+			
+			if (entry === undefined) {
+				const content = await content_generator();
+				const size = Buffer.byteLength(content);
+				
+				entry = {
+					content,
+					size,
+					last_access_ts: now_ts,
+					content_type: 'text/html',
+					cached_ts: now_ts
+				};
+				
+				store_cache_entry(cache_key, entry, now_ts);
+			}
+			
+			return build_response(entry, req, status_code);
+		}
+	};
+}
+// endregion
+
+// region error handling
 export class ErrorWithMetadata extends Error {
 	constructor(message: string, public metadata: Record<string, unknown>) {
 		super(message);
@@ -30,66 +307,66 @@ export class ErrorWithMetadata extends Error {
 		if (this.stack)
 			this.stack = this.stack.split('\n').slice(1).join('\n');
 	}
-
+	
 	async resolve_metadata(): Promise<object> {
 		const metadata = Object.assign({}, this.metadata);
 		for (const [key, value] of Object.entries(metadata)) {
 			let resolved_value = value;
-
+			
 			if (value instanceof Promise)
 				resolved_value = await value;
 			else if (typeof value === 'function')
 				resolved_value = await value();
 			else if (value instanceof ReadableStream)
 				resolved_value = await Bun.readableStreamToText(value);
-
+			
 			if (typeof resolved_value === 'string' && resolved_value.includes('\n'))
 				resolved_value = resolved_value.split(/\r?\n/);
-
+			
 			metadata[key] = resolved_value;
 		}
-
+		
 		return metadata;
 	}
 }
 
 async function handle_error(prefix: string, err_message_or_obj: string | object, ...err: unknown[]): Promise<void> {
 	let error_message = 'unknown error';
-
+	
 	if (typeof err_message_or_obj === 'string') {
 		error_message = err_message_or_obj;
 		err.unshift(error_message);
 	} else {
 		if (err_message_or_obj instanceof Error)
 			error_message = err_message_or_obj.message;
-
+		
 		err.push(err_message_or_obj);
 	}
-
+	
 	const final_err = Array(err.length);
 	for (let i = 0; i < err.length; i++) {
 		const e = err[i];
-
+		
 		if (e instanceof Error) {
 			const report = {
 				name: e.name,
 				message: e.message,
 				stack: e.stack?.split('\n') ?? []
 			} as Record<string, unknown>;
-
+			
 			if (e instanceof ErrorWithMetadata)
 				report.metadata = await e.resolve_metadata();
-
+			
 			final_err[i] = report;
 		} else {
 			final_err[i] = e;
 		}
 	}
-
+	
 	if (process.env.SPOODER_ENV === 'dev') {
-		log('[{dev}] dispatch_report %s', prefix + error_message);
-		log('[{dev}] without {--dev}, this would raise a canary report');
-		log('[{dev}] %o', final_err);
+		log_spooder(`[{dev}] dispatch_report ${prefix + error_message}`);
+		log_spooder('[{dev}] without {--dev}, this would raise a canary report');
+		log_spooder(`[{dev}] ${final_err}`);
 	} else {
 		await dispatch_report(prefix + error_message, final_err);
 	}
@@ -104,16 +381,6 @@ export async function caution(err_message_or_obj: string | object, ...err: objec
 	await handle_error('caution: ', err_message_or_obj, ...err);
 }
 
-type WebsocketAcceptReturn = object | boolean;
-type WebsocketHandlers = {
-	accept?: (req: Request) => WebsocketAcceptReturn | Promise<WebsocketAcceptReturn>,
-	message?: (ws: WebSocket, message: string) => void,
-	message_json?: (ws: WebSocket, message: JsonSerializable) => void,
-	open?: (ws: WebSocket) => void,
-	close?: (ws: WebSocket, code: number, reason: string) => void,
-	drain?: (ws: WebSocket) => void
-};
-
 type CallableFunction = (...args: any[]) => any;
 type Callable = Promise<any> | CallableFunction;
 
@@ -122,91 +389,139 @@ export async function safe(target_fn: Callable) {
 		if (target_fn instanceof Promise)
 			await target_fn;
 		else
-			await target_fn();
+		await target_fn();
 	} catch (e) {
 		caution(e as Error);
 	}
 }
+// endregion
 
+// region templates
 type ReplacerFn = (key: string) => string | Array<string> | undefined;
 type AsyncReplaceFn = (key: string) => Promise<string | Array<string> | undefined>;
-type Replacements = Record<string, string | Array<string>> | ReplacerFn | AsyncReplaceFn;
+type Replacements = Record<string, string | Array<string> | object | object[]> | ReplacerFn | AsyncReplaceFn;
 
-export async function parse_template(template: string, replacements: Replacements, drop_missing = false): Promise<string> {
-	let result = '';
-	let buffer = '';
-	let buffer_active = false;
+function get_nested_property(obj: any, path: string): any {
+	const keys = path.split('.');
+	let current = obj;
+	
+	for (const key of keys) {
+		if (current === null || current === undefined || typeof current !== 'object')
+			return undefined;
+		current = current[key];
+	}
+	
+	return current;
+}
 
+export async function parse_template(template: string, replacements: Replacements, drop_missing = false): Promise<string> {
 	const is_replacer_fn = typeof replacements === 'function';
-
-	const template_length = template.length;
-	for (let i = 0; i < template_length; i++) {
-		const char = template[i];
-
-		if (char === '{' && template[i + 1] === '$') {
-			i++;
-			buffer_active = true;
-			buffer = '';
-		} else if (char === '}' && buffer_active) {
-			buffer_active = false;
-
-			if (buffer.startsWith('for:')) {
-				const loop_key = buffer.substring(4);
-
-				const loop_entries = is_replacer_fn ? await replacements(loop_key) : replacements[loop_key];
-				const loop_content_start_index = i + 1;
-				const loop_close_index = template.indexOf('{/for}', loop_content_start_index);
-				
-				if (loop_close_index === -1) {
-					if (!drop_missing)
-						result += '{$' + buffer + '}';
-				} else {
-					const loop_content = template.substring(loop_content_start_index, loop_close_index);
-					if (loop_entries !== undefined) {
-						for (const loop_entry of loop_entries) {
-							const inner_content = loop_content.replaceAll('%s', loop_entry);
-							result += await parse_template(inner_content, replacements, drop_missing);
-						}
+	let result = template;
+	let previous_result = '';
+	
+	// Keep processing until no more changes occur (handles nested tags)
+	while (result !== previous_result) {
+		previous_result = result;
+		
+		// Parse t-for tags first (outermost structures)
+		const for_regex = /<t-for\s+items="([^"]+)"\s+as="([^"]+)"\s*>(.*?)<\/t-for>/gs;
+		result = await replace_async(result, for_regex, async (match, entries_key, alias_name, loop_content) => {
+			const loop_entries = is_replacer_fn ? await replacements(entries_key) : replacements[entries_key];
+			
+			if (loop_entries !== undefined && Array.isArray(loop_entries)) {
+				let loop_result = '';
+				for (const loop_entry of loop_entries) {
+					let scoped_replacements: Replacements;
+					
+					if (typeof replacements === 'function') {
+						scoped_replacements = async (key: string) => {
+							if (key === alias_name) return loop_entry;
+							if (key.startsWith(alias_name + '.')) {
+								const prop_path = key.substring(alias_name.length + 1);
+								return get_nested_property(loop_entry, prop_path);
+							}
+							return await replacements(key);
+						};
 					} else {
-						if (!drop_missing)
-							result += '{$' + buffer + '}' + loop_content + '{/for}';
+						scoped_replacements = {
+							...replacements,
+							[alias_name]: loop_entry
+						};
 					}
-					i += loop_content.length + 6;
+					
+					loop_result += await parse_template(loop_content, scoped_replacements, drop_missing);
 				}
-			} else if (buffer.startsWith('if:')) {
-				const if_key = buffer.substring(3);
-				const if_content_start_index = i + 1;
-				const if_close_index = template.indexOf('{/if}', if_content_start_index);
-
-				if (if_close_index === -1) {
-					if (!drop_missing)
-						result += '{$' + buffer + '}';
-				} else {
-					const if_content = template.substring(if_content_start_index, if_close_index);
-					const condition_value = is_replacer_fn ? await replacements(if_key) : replacements[if_key];
-
-					if (!drop_missing) {
-						result += '{$' + buffer + '}' + if_content + '{/if}';
-					} else if (condition_value) {
-						result += await parse_template(if_content, replacements, drop_missing);
+				return loop_result;
+			} else {
+				if (!drop_missing)
+					return match;
+				
+				return '';
+			}
+		});
+		
+		// Parse t-if tags
+		const if_regex = /<t-if\s+test="([^"]+)"\s*>(.*?)<\/t-if>/gs;
+		result = await replace_async(result, if_regex, async (match, condition_key, if_content) => {
+			const condition_value = is_replacer_fn ? await replacements(condition_key) : replacements[condition_key];
+			
+			if (!drop_missing && !condition_value)
+				return match;
+			if (condition_value)
+				return await parse_template(if_content, replacements, drop_missing);
+			
+			return '';
+		});
+		
+		// Parse {{variable}} tags (innermost)
+		const var_regex = /\{\{([^}]+)\}\}/g;
+		result = await replace_async(result, var_regex, async (match, var_name) => {
+			// Trim whitespace from variable name
+			var_name = var_name.trim();
+			let replacement;
+			
+			if (is_replacer_fn) {
+				replacement = await replacements(var_name);
+			} else {
+				// First try direct key lookup (handles hash keys with dots like "hash=.gitignore")
+				replacement = replacements[var_name];
+				
+				// If direct lookup fails and variable contains dots, try nested property access
+				if (replacement === undefined && var_name.includes('.')) {
+					const dot_index = var_name.indexOf('.');
+					const base_key = var_name.substring(0, dot_index);
+					const prop_path = var_name.substring(dot_index + 1);
+					const base_obj = replacements[base_key];
+					
+					if (base_obj !== undefined) {
+						replacement = get_nested_property(base_obj, prop_path);
 					}
-					i += if_content.length + 5;
 				}
-			} else {
-				const replacement = is_replacer_fn ? await replacements(buffer) : replacements[buffer];
-				if (replacement !== undefined)
-					result += replacement;
-				else if (!drop_missing)
-					result += '{$' + buffer + '}';
 			}
-			buffer = '';
-		} else if (buffer_active) {
-			buffer += char;
-		} else {
-			result += char;
-		}
+			
+			if (replacement !== undefined)
+				return replacement;
+			
+			if (!drop_missing)
+				return match;
+			
+			return '';
+		});
 	}
+	
+	return result;
+}
 
+async function replace_async(str: string, regex: RegExp, replacer_fn: (match: string, ...args: any[]) => Promise<string>): Promise<string> {
+	const matches = Array.from(str.matchAll(regex));
+	let result = str;
+	
+	for (let i = matches.length - 1; i >= 0; i--) {
+		const match = matches[i];
+		const replacement = await replacer_fn(match[0], ...match.slice(1));
+		result = result.substring(0, match.index!) + replacement + result.substring(match.index! + match[0].length);
+	}
+	
 	return result;
 }
 
@@ -216,347 +531,204 @@ export async function get_git_hashes(length = 7): Promise<Record<string, string>
 		stdout: 'pipe',
 		stderr: 'pipe'
 	});
-
+	
 	await process.exited;
-
+	
 	if (process.exitCode as number > 0)
 		throw new Error('get_git_hashes() failed, `' + cmd.join(' ') + '` exited with non-zero exit code.');
-
+	
 	const stdout = await Bun.readableStreamToText(process.stdout as ReadableStream);
 	const hash_map: Record<string, string> = {};
-
+	
 	const regex = /([^\s]+)\s([^\s]+)\s([^\s]+)\t(.+)/g;
 	let match: RegExpExecArray | null;
-
+	
 	while (match = regex.exec(stdout))
 		hash_map[match[4]] = match[3].substring(0, length);
-
+	
 	return hash_map;
 }
 
 export async function generate_hash_subs(length = 7, prefix = 'hash=', hashes?: Record<string, string>): Promise<Record<string, string>> {	
 	const hash_map: Record<string, string> = {};
-
+	
 	if (!hashes)
 		hashes = await get_git_hashes(length);
-
+	
 	for (const [file, hash] of Object.entries(hashes))
 		hash_map[prefix + file] = hash;
-
+	
 	return hash_map;
 }
-
-interface DependencyTarget {
-	file_name: string;
-	deps: string[];
-}
-
-function order_schema_dep_tree<T extends DependencyTarget>(deps: T[]): T[] {
-	const visited = new Set<string>();
-	const temp = new Set<string>();
-	const result: T[] = [];
-	const map = new Map(deps.map(d => [d.file_name, d]));
- 
-	function visit(node: T): void {
-		if (temp.has(node.file_name))
-			throw new Error(`Cyclic dependency {${node.file_name}}`);
- 
-		if (visited.has(node.file_name))
-			return;
- 
-		temp.add(node.file_name);
- 
-		for (const dep of node.deps) {
-			const dep_node = map.get(dep);
-			if (!dep_node)
-				throw new Error(`Missing dependency {${dep}}`);
-			
-			visit(dep_node as T);
-		}
- 
-		temp.delete(node.file_name);
-		visited.add(node.file_name);
-		result.push(node);
-	}
- 
-	for (const dep of deps)
-		if (!visited.has(dep.file_name))
-			visit(dep);
- 
-	return result;
- }
-
-type Row_DBSchema = { db_schema_table_name: string, db_schema_version: number };
-type SchemaVersionMap = Map<string, number>;
-
-async function db_load_schema(schema_dir: string, schema_versions: SchemaVersionMap) {
-	const schema_out = [];
-	const schema_files = await fs.readdir(schema_dir, { recursive: true, withFileTypes: true });
-
-	for (const schema_file_ent of schema_files) {
-		if (schema_file_ent.isDirectory())
-			continue;
-
-		const schema_file = schema_file_ent.name;
-		const schema_file_lower = schema_file.toLowerCase();
-		if (!schema_file_lower.endsWith('.sql'))
-			continue;
-
-		log('[{db}] parsing schema file {%s}', schema_file_lower);
-
-		const schema_name = path.basename(schema_file_lower, '.sql');
-		const schema_path = path.join(schema_file_ent.parentPath, schema_file);
-		const schema = await fs.readFile(schema_path, 'utf8');
-
-		const deps = new Array<string>();
-
-		const revisions = new Map();
-		let current_rev_id = 0;
-		let current_rev = '';
-
-		for (const line of schema.split(/\r?\n/)) {
-			const line_identifier = line.match(/^--\s*\[(\d+|deps)\]/);
-			if (line_identifier !== null) {
-				if (line_identifier[1] === 'deps') {
-					// Line contains schema dependencies, example: -- [deps] schema_b.sql,schema_c.sql
-					const deps_raw = line.substring(line.indexOf(']') + 1);
-					deps.push(...deps_raw.split(',').map(e => e.trim().toLowerCase()));
-				} else {
-					// New chunk definition detected, store the current chunk and start a new one.
-					if (current_rev_id > 0) {
-						revisions.set(current_rev_id, current_rev);
-						current_rev = '';
-					}
-
-					const rev_number = parseInt(line_identifier[1]);
-					if (isNaN(rev_number) || rev_number < 1)
-						throw new Error(rev_number + ' is not a valid revision number in ' + schema_file_lower);
-					current_rev_id = rev_number;
-				}
-			} else {
-				// Append to existing revision.
-				current_rev += line + '\n';
-			}
-		}
-
-		// There may be something left in current_chunk once we reach end of the file.
-		if (current_rev_id > 0)
-			revisions.set(current_rev_id, current_rev);
-
-		if (revisions.size === 0) {
-			log('[{db}] {%s} contains no valid revisions', schema_file);
-			continue;
-		}
-
-		if (deps.length > 0)
-			log('[{db}] {%s} dependencies: %s', schema_file, deps.map(e => '{' + e +'}').join(', '));
-
-		const current_schema_version = schema_versions.get(schema_name) ?? 0;
-		schema_out.push({
-			revisions,
-			file_name: schema_file_lower,
-			name: schema_name,
-			current_version: current_schema_version,
-			deps,
-			chunk_keys: Array.from(revisions.keys()).filter(chunk_id => chunk_id > current_schema_version).sort((a, b) => a - b)
-		});
-	}
-
-	return order_schema_dep_tree(schema_out);
-}
-
-export async function db_update_schema_sqlite(db: Database, schema_dir: string, schema_table_name = 'db_schema') {
-	log('[{db}] updating database schema for {%s}', db.filename);
-
-	const schema_versions = new Map();
-
-	try {
-		const query = db.query('SELECT db_schema_table_name, db_schema_version FROM ' + schema_table_name);
-		for (const row of query.all() as Array<Row_DBSchema>)
-			schema_versions.set(row.db_schema_table_name, row.db_schema_version);
-	} catch (e) {
-		log('[{db}] creating {%s} table', schema_table_name);
-		db.run(`CREATE TABLE ${schema_table_name} (db_schema_table_name TEXT PRIMARY KEY, db_schema_version INTEGER)`);
-	}
+// endregion
+
+// region serving
+export const HTTP_STATUS_TEXT: Record<number, string> = {
+	// 1xx Informational Response
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
 	
-	db.transaction(async () => {
-		const update_schema_query = db.prepare(`
-			INSERT INTO ${schema_table_name} (db_schema_version, db_schema_table_name) VALUES (?1, ?2)
-			ON CONFLICT(db_schema_table_name) DO UPDATE SET db_schema_version = EXCLUDED.db_schema_version
-		`);
-
-		const schemas = await db_load_schema(schema_dir, schema_versions);
-
-		for (const schema of schemas) {
-			let newest_schema_version = schema.current_version;
-			for (const rev_id of schema.chunk_keys) {
-				const revision = schema.revisions.get(rev_id);
-				log('[{db}] applying revision {%d} to {%s}', rev_id, schema.name);
-				db.transaction(() => db.run(revision))();
-				newest_schema_version = rev_id;
-			}
+	// 2xx Success
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
 	
-			if (newest_schema_version > schema.current_version) {
-				log('[{db}] updated table {%s} to revision {%d}', schema.name, newest_schema_version);
-				update_schema_query.run(newest_schema_version, schema.name);
-			}
-		}
-	})();
-}
-
-export async function db_update_schema_mysql(db: mysql_types.Connection, schema_dir: string, schema_table_name = 'db_schema') {
-	if (mysql === undefined)
-		throw new Error('{db_update_schema_mysql} cannot be called without optional dependency {mysql2} installed');
-
-	log('[{db}] updating database schema for {%s}', db.config.database);
-
-	const schema_versions = new Map();
-
-	try {
-		const [rows] = await db.query('SELECT db_schema_table_name, db_schema_version FROM ' + schema_table_name);
-		for (const row of rows as Array<Row_DBSchema>)
-			schema_versions.set(row.db_schema_table_name, row.db_schema_version);
-	} catch (e) {
-		log('[{db}] creating {%s} table', schema_table_name);
-		await db.query(`CREATE TABLE ${schema_table_name} (db_schema_table_name VARCHAR(255) PRIMARY KEY, db_schema_version INT)`);
-	}
-
-	await db.beginTransaction();
+	// 3xx Redirection
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
 	
-	const update_schema_query = await db.prepare(`
-		INSERT INTO ${schema_table_name} (db_schema_version, db_schema_table_name) VALUES (?, ?)
-		ON DUPLICATE KEY UPDATE db_schema_version = VALUES(db_schema_version);
-	`);
-
-	const schemas = await db_load_schema(schema_dir, schema_versions);
-	for (const schema of schemas) {
-		let newest_schema_version = schema.current_version;
-		for (const rev_id of schema.chunk_keys) {
-			const revision = schema.revisions.get(rev_id);
-			log('[{db}] applying revision {%d} to {%s}', rev_id, schema.name);
-
-			await db.query(revision);
-			newest_schema_version = rev_id;
-		}
-
-		if (newest_schema_version > schema.current_version) {
-			log('[{db}] updated table {%s} to revision {%d}', schema.name, newest_schema_version);
-			
-			await update_schema_query.execute([newest_schema_version, schema.name]);
-		}
-	}
-
-	await db.commit();
-}
-
-export async function db_init_sqlite(db_path: string, schema_dir?: string): Promise<Database> {
-	const db = new Database(db_path, { create: true });
-
-	if (schema_dir !== undefined)
-		await db_update_schema_sqlite(db, schema_dir);
-
-	return db;
-}
-
-export async function db_init_mysql<T extends boolean = false>(db_info: mysql_types.ConnectionOptions, schema_dir?: string, pool: T = false as T): Promise<T extends true ? mysql_types.Pool : mysql_types.Connection> {
-	if (mysql === undefined)
-		throw new Error('db_init_mysql cannot be called without optional dependency {mysql2} installed');
-
-	// required for parsing multiple statements from schema files
-	db_info.multipleStatements = true;
-
-	if (pool) {
-		const pool = mysql.createPool(db_info);
-		const connection = await pool.getConnection();
-
-		if (schema_dir !== undefined)
-			await db_update_schema_mysql(connection, schema_dir);
-
-		connection.release();
-
-		return pool as any;
-	} else {
-		const connection = await mysql.createConnection(db_info);
-
-		if (schema_dir !== undefined)
-			await db_update_schema_mysql(connection, schema_dir);
-		
-		return connection as any;
-	}
-}
-
-export type CookieOptions = {
-	same_site?: 'Strict' | 'Lax' | 'None',
-	secure?: boolean,
-	http_only?: boolean,
-	path?: string,
-	expires?: number,
-	encode?: boolean,
-	max_age?: number
+	// 4xx Client Errors
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Failed',
+	413: 'Payload Too Large',
+	414: 'URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: 'I\'m a Teapot',
+	421: 'Misdirected Request',
+	422: 'Unprocessable Content',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+	
+	// 5xx Server Errors
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	510: 'Not Extended',
+	511: 'Network Authentication Required'
 };
 
-export function set_cookie(res: Response, name: string, value: string, options?: CookieOptions): void {
-	let cookie = name + '=';
-	if (options !== undefined) {
-		cookie += options.encode ? encodeURIComponent(value) : value;
-
-		if (options.same_site !== undefined)
-			cookie += '; SameSite=' + options.same_site;
-
-		if (options.secure)
-			cookie += '; Secure';
-
-		if (options.http_only)
-			cookie += '; HttpOnly';
-
-		if (options.path !== undefined)
-			cookie += '; Path=' + options.path;
-
-		if (options.expires !== undefined) {
-			const date = new Date(Date.now() + options.expires);
-			cookie += '; Expires=' + date.toUTCString();
-		}
-
-		if (options.max_age !== undefined)
-			cookie += '; Max-Age=' + options.max_age;
-	} else {
-		cookie += value;
-	}
-
-	res.headers.append('Set-Cookie', cookie);
-}
-
-export function get_cookies(source: Request | Response, decode: boolean = false): Record<string, string> {
-	const parsed_cookies: Record<string, string> = {};
-	const cookie_header = source.headers.get('cookie');
-
-	if (cookie_header !== null) {
-		const cookies = cookie_header.split('; ');
-		for (const cookie of cookies) {
-			const [name, value] = cookie.split('=');
-			parsed_cookies[name] = decode ? decodeURIComponent(value) : value;
-		}
-	}
+export const HTTP_STATUS_CODE = {
+	// 1xx Informational Response
+	Continue_100: 100,
+	SwitchingProtocols_101: 101,
+	Processing_102: 102,
+	EarlyHints_103: 103,
+	
+	// 2xx Success
+	OK_200: 200,
+	Created_201: 201,
+	Accepted_202: 202,
+	NonAuthoritativeInformation_203: 203,
+	NoContent_204: 204,
+	ResetContent_205: 205,
+	PartialContent_206: 206,
+	MultiStatus_207: 207,
+	AlreadyReported_208: 208,
+	IMUsed_226: 226,
+	
+	// 3xx Redirection
+	MultipleChoices_300: 300,
+	MovedPermanently_301: 301,
+	Found_302: 302,
+	SeeOther_303: 303,
+	NotModified_304: 304,
+	UseProxy_305: 305,
+	TemporaryRedirect_307: 307,
+	PermanentRedirect_308: 308,
+	
+	// 4xx Client Errors
+	BadRequest_400: 400,
+	Unauthorized_401: 401,
+	Forbidden_403: 403,
+	NotFound_404: 404,
+	MethodNotAllowed_405: 405,
+	NotAcceptable_406: 406,
+	ProxyAuthenticationRequired_407: 407,
+	RequestTimeout_408: 408,
+	Conflict_409: 409,
+	Gone_410: 410,
+	LengthRequired_411: 411,
+	PreconditionFailed_412: 412,
+	PayloadTooLarge_413: 413,
+	URITooLong_414: 414,
+	UnsupportedMediaType_415: 415,
+	RangeNotSatisfiable_416: 416,
+	ExpectationFailed_417: 417,
+	ImATeapot_418: 418,
+	MisdirectedRequest_421: 421,
+	UnprocessableContent_422: 422,
+	Locked_423: 423,
+	FailedDependency_424: 424,
+	TooEarly_425: 425,
+	UpgradeRequired_426: 426,
+	PreconditionRequired_428: 428,
+	TooManyRequests_429: 429,
+	RequestHeaderFieldsTooLarge_431: 431,
+	UnavailableForLegalReasons_451: 451,
+	
+	// 5xx Server Errors
+	InternalServerError_500: 500,
+	NotImplemented_501: 501,
+	BadGateway_502: 502,
+	ServiceUnavailable_503: 503,
+	GatewayTimeout_504: 504,
+	HTTPVersionNotSupported_505: 505,
+	VariantAlsoNegotiates_506: 506,
+	InsufficientStorage_507: 507,
+	LoopDetected_508: 508,
+	NotExtended_510: 510,
+	NetworkAuthenticationRequired_511: 511
+} as const;
 
-	return parsed_cookies;
-}
+// Create enum containing HTTP methods
+type HTTP_METHOD = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+type HTTP_METHODS = HTTP_METHOD|HTTP_METHOD[];
 
-export function apply_range(file: BunFile, request: Request): BunFile {
+export function http_apply_range(file: BunFile, request: Request): BunFile {
 	const range_header = request.headers.get('range');
 	if (range_header !== null) {
 		const regex = /bytes=(\d*)-(\d*)/;
 		const match = range_header.match(regex);
-
+		
 		if (match !== null) {
 			const start = parseInt(match[1]);
 			const end = parseInt(match[2]);
-
+			
 			const start_is_nan = isNaN(start);
 			const end_is_nan = isNaN(end);
-
+			
 			if (start_is_nan && end_is_nan)
 				return file;
-
+			
 			file = file.slice(start_is_nan ? file.size - end : start, end_is_nan || start_is_nan ? undefined : end);
 		}
 	}
@@ -606,124 +778,267 @@ type DirStat = PromiseType<ReturnType<typeof fs.stat>>;
 
 type DirHandler = (file_path: string, file: BunFile, stat: DirStat, request: Request, url: URL) => HandlerReturnType;
 
-function default_directory_handler(file_path: string, file: BunFile, stat: DirStat, request: Request): HandlerReturnType {
-	// ignore hidden files by default, return 404 to prevent file sniffing
-	if (path.basename(file_path).startsWith('.'))
-		return 404; // Not Found
+interface DirOptions {
+	ignore_hidden?: boolean;
+	index_directories?: boolean;
+	support_ranges?: boolean;
+}
+
+let directory_index_template: string | null = null;
+
+async function get_directory_index_template(): Promise<string> {
+	if (directory_index_template === null) {
+		const template_path = path.join(import.meta.dir, 'template', 'directory_index.html');
+		const template_file = Bun.file(template_path);
+		directory_index_template = await template_file.text();
+	}
+	return directory_index_template;
+}
+
+function format_date(date: Date): string {
+	const options: Intl.DateTimeFormatOptions = {
+		year: 'numeric',
+		month: 'short',
+		day: '2-digit',
+		hour: '2-digit',
+		minute: '2-digit',
+		hour12: true
+	};
+	return date.toLocaleDateString('en-US', options);
+}
 
-	if (stat.isDirectory())
-		return 401; // Unauthorized
+function format_date_mobile(date: Date): string {
+	const options: Intl.DateTimeFormatOptions = {
+		year: 'numeric',
+		month: 'short',
+		day: '2-digit'
+	};
+	return date.toLocaleDateString('en-US', options);
+}
 
-	return apply_range(file, request);
+async function generate_directory_index(file_path: string, request_path: string): Promise<Response> {
+	try {
+		const entries = await fs.readdir(file_path, { withFileTypes: true });
+		let filtered_entries = entries.filter(entry => !entry.name.startsWith('.'));
+		filtered_entries.sort((a, b) => {
+			if (a.isDirectory() === b.isDirectory())
+				return a.name.localeCompare(b.name);
+			
+			return a.isDirectory() ? -1 : 1;
+		});
+		
+		const base_url = request_path.endsWith('/') ? request_path.slice(0, -1) : request_path;
+		const entry_data = await Promise.all(filtered_entries.map(async entry => {
+			const entry_path = path.join(file_path, entry.name);
+			const stat = await fs.stat(entry_path);
+			return {
+				name: entry.name,
+				type: entry.isDirectory() ? 'directory' : 'file',
+				size: entry.isDirectory() ? '-' : filesize(stat.size),
+				modified: format_date(stat.mtime),
+				modified_mobile: format_date_mobile(stat.mtime),
+				raw_size: entry.isDirectory() ? 0 : stat.size
+			};
+		}));
+		
+		const template = await get_directory_index_template();
+		const html = await parse_template(template, {
+			title: path.basename(file_path) || 'Root',
+			path: request_path,
+			base_url: base_url,
+			entries: entry_data,
+			version: packageJson.version
+		}, true);
+		
+		return new Response(html, {
+			status: 200,
+			headers: { 'Content-Type': 'text/html' }
+		});
+	} catch (err) {
+		return new Response('Error reading directory', {
+			status: 500,
+			headers: { 'Content-Type': 'text/plain' }
+		});
+	}
 }
 
-function route_directory(route_path: string, dir: string, handler: DirHandler): RequestHandler {
+
+function route_directory(route_path: string, dir: string, handler_or_options: DirHandler | DirOptions): RequestHandler {
+	const is_handler = typeof handler_or_options === 'function';
+	const handler = is_handler ? handler_or_options as DirHandler : null;
+	const default_options = { ignore_hidden: true, index_directories: false, support_ranges: true };
+	const options = is_handler ? default_options : { ...default_options, ...handler_or_options as DirOptions };
+	
 	return async (req: Request, url: URL) => {
 		const file_path = path.join(dir, url.pathname.slice(route_path.length));
-
+		
 		try {
 			const file_stat = await fs.stat(file_path);
 			const bun_file = Bun.file(file_path);
-
-			return await handler(file_path, bun_file, file_stat, req, url);
+			
+			if (handler)
+				return await handler(file_path, bun_file, file_stat, req, url);
+			
+			// Options-based handling
+			if (options.ignore_hidden && path.basename(file_path).startsWith('.'))
+				return 404; // Not Found
+			
+			if (file_stat.isDirectory()) {
+				if (options.index_directories)
+					return await generate_directory_index(file_path, url.pathname);
+				
+				return 401; // Unauthorized
+			}
+			
+			return options.support_ranges ? http_apply_range(bun_file, req) : bun_file;
 		} catch (e) {
 			const err = e as NodeJS.ErrnoException;
 			if (err?.code === 'ENOENT')
 				return 404; // Not Found
-
+			
 			return 500; // Internal Server Error
 		}
 	};
 }
 
-export function validate_req_json(json_handler: JSONRequestHandler): RequestHandler {
-	return async (req: Request, url: URL) => {
-		try {
-			// validate content type header
-			if (req.headers.get('Content-Type') !== 'application/json')
-				return 400; // Bad Request
-
-			const json = await req.json();
-
-			// validate json is a plain object
-			if (json === null || typeof json !== 'object' || Array.isArray(json))
-				return 400; // Bad Request
-
-			return json_handler(req, url, json as JsonObject);
-		} catch (e) {
-			return 400; // Bad Request
-		}
-	};
-}
-
 function format_query_parameters(search_params: URLSearchParams): string {
 	let result_parts = [];
-
+	
 	for (let [key, value] of search_params)
 		result_parts.push(`${key}: ${value}`);
-
+	
 	return '\x1b[90m( ' + result_parts.join(', ') + ' )\x1b[0m';
 }
 
 function print_request_info(req: Request, res: Response, url: URL, request_time: number): Response {
 	const search_params = url.search.length > 0 ? format_query_parameters(url.searchParams) : '';
-
+	
 	// format status code based on range (2xx is green, 4xx is yellow, 5xx is red), use ansi colors.
 	const status_fmt = res.status < 300 ? '\x1b[32m' : res.status < 500 ? '\x1b[33m' : '\x1b[31m';
 	const status_code = status_fmt + res.status + '\x1b[0m';
-
+	
 	// format request time based on range (0-100ms is green, 100-500ms is yellow, 500ms+ is red), use ansi colors.
 	const time_fmt = request_time < 100 ? '\x1b[32m' : request_time < 500 ? '\x1b[33m' : '\x1b[31m';
 	const request_time_str = time_fmt + request_time + 'ms\x1b[0m';
-
-	log('[%s] {%s} %s %s [{%s}]', status_code, req.method, url.pathname, search_params, request_time_str);
+	
+	log_spooder(`[${status_code}] {${req.method}} ${url.pathname} ${search_params} [{${request_time_str}}]`);
 	return res;
 }
 
 function is_valid_method(method: HTTP_METHODS, req: Request): boolean {
 	if (Array.isArray(method))
 		return method.includes(req.method as HTTP_METHOD);
-
+	
 	return req.method === method;
 }
 
-export function serve(port: number, hostname?: string) {
+function is_bun_file(obj: any): obj is BunFile {
+	return obj.constructor === Blob;
+}
+
+function sub_table_merge(target: Record<string, any>, ...sources: (Record<string, any> | undefined | null)[]): Record<string, any> {
+	const result = { ...target };
+	
+	for (const source of sources) {
+		if (source == null)
+			continue;
+		
+		for (const key in source) {
+			if (source.hasOwnProperty(key)) {
+				const sourceValue = source[key];
+				const targetValue = result[key];
+				
+				if (Array.isArray(targetValue) && Array.isArray(sourceValue))
+					result[key] = [...targetValue, ...sourceValue];
+				else
+					result[key] = sourceValue;
+			}
+		}
+	}
+	
+	return result;
+}
+
+async function resolve_bootstrap_content(content: string | BunFile): Promise<string> {
+	if (is_bun_file(content))
+		return await content.text();
+
+	return content;
+}
+
+type WebsocketAcceptReturn = object | boolean;
+type WebsocketHandlers = {
+	accept?: (req: Request) => WebsocketAcceptReturn | Promise<WebsocketAcceptReturn>,
+	message?: (ws: WebSocket, message: string) => void,
+	message_json?: (ws: WebSocket, message: JsonSerializable) => void,
+	open?: (ws: WebSocket) => void,
+	close?: (ws: WebSocket, code: number, reason: string) => void,
+	drain?: (ws: WebSocket) => void
+};
+
+type BootstrapSub = string | string[];
+
+type BootstrapRoute = {
+	content: string | BunFile;
+	subs?: Record<string, BootstrapSub>;
+};
+
+type BootstrapOptions = {
+	base?: string | BunFile;
+	routes: Record<string, BootstrapRoute>;
+	cache?: ReturnType<typeof cache_http> | CacheOptions;
+	cache_bust?: boolean;
+	error?: {
+		use_canary_reporting?: boolean;
+		error_page: string | BunFile;
+	},
+	
+	static?: {
+		route: string;
+		directory: string;
+		sub_ext?: Array<string>;
+	},
+	
+	global_subs?: Record<string, BootstrapSub>;
+};
+
+export function http_serve(port: number, hostname?: string) {
 	const routes = new Array<[string[], RequestHandler, HTTP_METHODS]>();
 	const handlers = new Map<number, StatusCodeHandler>();
 	
 	let error_handler: ErrorHandler | undefined;
 	let default_handler: DefaultHandler | undefined;
-
+	
 	async function resolve_handler(response: HandlerReturnType | Promise<HandlerReturnType>, status_code: number, return_status_code = false): Promise<Response | number> {
 		if (response instanceof Promise)
 			response = await response;
-
+		
 		if (response === undefined || response === null)
 			throw new Error('HandlerReturnType cannot resolve to undefined or null');
-
+		
 		// Pre-assembled responses are returned as-is.
 		if (response instanceof Response)
 			return response;
-	
+		
 		// Content-type/content-length are automatically set for blobs.
 		if (response instanceof Blob)
 			// @ts-ignore Response does accept Blob in Bun, typing disagrees.
-			return new Response(response, { status: status_code });
-
+		return new Response(response, { status: status_code });
+		
 		// Status codes can be returned from some handlers.
 		if (return_status_code && typeof response === 'number')
 			return response;
-
+		
 		// This should cover objects, arrays, etc.
 		if (typeof response === 'object')
 			return Response.json(response, { status: status_code });
-	
+		
 		return new Response(String(response), { status: status_code, headers: { 'Content-Type': 'text/html' } });
 	}
-
+	
 	async function generate_response(req: Request, url: URL): Promise<Response> {
 		let status_code = 200;
-
+		
 		try {
 			let pathname = url.pathname;
 			if (pathname.length > 1 && pathname.endsWith('/'))
@@ -731,44 +1046,44 @@ export function serve(port: number, hostname?: string) {
 			const route_array = pathname.split('/').filter(e => !(e === '..' || e === '.'));
 			let handler: RequestHandler | undefined;
 			let methods: HTTP_METHODS | undefined;
-
+			
 			for (const [path, route_handler, route_methods] of routes) {
 				const is_trailing_wildcard = path[path.length - 1] === '*';
 				if (!is_trailing_wildcard && path.length !== route_array.length)
 					continue;
-
+				
 				let match = true;
 				for (let i = 0; i < path.length; i++) {
 					const path_part = path[i];
-
+					
 					if (path_part === '*')
 						continue;
-
+					
 					if (path_part.startsWith(':')) {
 						url.searchParams.append(path_part.slice(1), route_array[i]);
 						continue;
 					}
-
+					
 					if (path_part !== route_array[i]) {
 						match = false;
 						break;
 					}
 				}
-
+				
 				if (match) {
 					handler = route_handler;
 					methods = route_methods;
 					break;
 				}
 			}
-
+			
 			// Check for a handler for the route.
 			if (handler !== undefined) {
 				if (is_valid_method(methods!, req)) {
 					const response = await resolve_handler(handler(req, url), status_code, true);
 					if (response instanceof Response)
 						return response;
-
+					
 					// If the handler returned a status code, use that instead.
 					status_code = response;
 				} else {
@@ -777,7 +1092,7 @@ export function serve(port: number, hostname?: string) {
 			} else {
 				status_code = 404; // Not Found
 			}
-
+			
 			// Fallback to checking for a handler for the status code.
 			const status_code_handler = handlers.get(status_code);
 			if (status_code_handler !== undefined) {
@@ -785,70 +1100,70 @@ export function serve(port: number, hostname?: string) {
 				if (response instanceof Response)
 					return response;
 			}
-
+			
 			// Fallback to the default handler, if any.
 			if (default_handler !== undefined) {
 				const response = await resolve_handler(default_handler(req, status_code), status_code);
 				if (response instanceof Response)
 					return response;
 			}
-
+			
 			// Fallback to returning a basic response.
 			return new Response(http.STATUS_CODES[status_code], { status: status_code });
 		} catch (e) {
 			if (error_handler !== undefined)
 				return await error_handler(e as Error, req, url);
-
-			return new Response(http.STATUS_CODES[500], { status: 500 });
+			
+			return new Response(HTTP_STATUS_TEXT[500], { status: 500 });
 		}
 	}
-
+	
 	type SlowRequestCallback = (req: Request, request_time: number, url: URL) => void;
-
+	
 	let slow_request_callback: SlowRequestCallback | null = null;
 	let slow_request_threshold: number = 1000;
-
+	
 	const slow_requests = new WeakSet();
-
+	
 	let ws_message_handler: any = undefined;
 	let ws_message_json_handler: any = undefined;
 	let ws_open_handler: any = undefined;
 	let ws_close_handler: any = undefined;
 	let ws_drain_handler: any = undefined;
-
+	
 	const server = Bun.serve({
 		port,
 		hostname,
 		development: false,
-
+		
 		async fetch(req: Request): Promise<Response> {
 			const url = new URL(req.url) as URL;
 			const request_start = Date.now();
-
+			
 			const response = await generate_response(req, url);
 			const request_time = Date.now() - request_start;
-
+			
 			const is_known_slow = slow_requests.has(req);
 			if (slow_request_callback !== null && request_time > slow_request_threshold && !is_known_slow)
 				slow_request_callback(req, request_time, url);
-
+			
 			if (is_known_slow)
 				slow_requests.delete(req);
-
+			
 			return print_request_info(req, response, url, request_time);
 		},
-
+		
 		websocket: {
 			message(ws, message) {
 				ws_message_handler?.(ws, message);
-
+				
 				if (ws_message_json_handler) {
 					try {
 						if (message instanceof ArrayBuffer)
 							message = new TextDecoder().decode(message);
 						else if (message instanceof Buffer)
 							message = message.toString('utf8');
-
+						
 						const parsed = JSON.parse(message as string);
 						ws_message_json_handler(ws, parsed);
 					} catch (e) {
@@ -856,23 +1171,23 @@ export function serve(port: number, hostname?: string) {
 					}
 				}
 			},
-
+			
 			open(ws) {
 				ws_open_handler?.(ws);
 			},
-
+			
 			close(ws, code, reason) {
 				ws_close_handler?.(ws, code, reason);
 			},
-
+			
 			drain(ws) {
 				ws_drain_handler?.(ws);
 			}
 		}
 	});
-
-	log('server started on port {%d} (host: {%s})', port, hostname ?? 'unspecified');
-
+	
+	log_spooder(`server started on port {${port}} (host: {${hostname ?? 'unspecified'}})`);
+	
 	return {
 		/** Register a handler for a specific route. */
 		route: (path: string, handler: RequestHandler, method: HTTP_METHODS = 'GET'): void => {
@@ -880,34 +1195,58 @@ export function serve(port: number, hostname?: string) {
 				path = path.slice(0, -1);
 			routes.push([path.split('/'), handler, method]);
 		},
-
+		
+		/** Register a JSON endpoint with automatic content validation. */
+		json: (path: string, handler: JSONRequestHandler, method: HTTP_METHODS = 'POST'): void => {
+			const json_wrapper: RequestHandler = async (req: Request, url: URL) => {
+				try {
+					if (req.headers.get('Content-Type') !== 'application/json')
+						return 400; // Bad Request
+					
+					const json = await req.json();
+					if (json === null || typeof json !== 'object' || Array.isArray(json))
+						return 400; // Bad Request
+					
+					return handler(req, url, json as JsonObject);
+				} catch (e) {
+					return 400; // Bad Request
+				}
+			};
+			
+			if (path.length > 1 && path.endsWith('/'))
+				path = path.slice(0, -1);
+			
+			routes.push([path.split('/'), json_wrapper, method]);
+		},
+		
 		/** Unregister a specific route */
 		unroute: (path: string): void => {
 			const path_parts = path.split('/');
 			routes.splice(routes.findIndex(([route_parts]) => {
 				if (route_parts.length !== path_parts.length)
 					return false;
-
+				
 				for (let i = 0; i < route_parts.length; i++) {
 					if (route_parts[i] !== path_parts[i])
 						return false;
 				}
-
+				
 				return true;
 			}, 1));
 		},
-
+		
 		/** Serve a directory for a specific route. */
-		dir: (path: string, dir: string, handler?: DirHandler, method: HTTP_METHODS = 'GET'): void => {
+		dir: (path: string, dir: string, handler_or_options?: DirHandler | DirOptions, method: HTTP_METHODS = 'GET'): void => {
 			if (path.endsWith('/'))
 				path = path.slice(0, -1);
-
-			routes.push([[...path.split('/'), '*'], route_directory(path, dir, handler ?? default_directory_handler), method]);
+			
+			const final_handler_or_options = handler_or_options ?? { ignore_hidden: true, index_directories: false, support_ranges: true };
+			routes.push([[...path.split('/'), '*'], route_directory(path, dir, final_handler_or_options), method]);
 		},
-
+		
 		/** Add a route to upgrade connections to websockets. */
 		websocket: (path: string, handlers: WebsocketHandlers): void => {
-			routes.push([path.split('/'), async (req: Request, url: URL) => {
+			routes.push([path.split('/'), async (req: Request) => {
 				let context_data = undefined;
 				if (handlers.accept) {
 					const res = await handlers.accept(req);
@@ -918,94 +1257,108 @@ export function serve(port: number, hostname?: string) {
 						return 401; // Unauthorized
 					}
 				}
-
+				
 				if (server.upgrade(req, { data: context_data }))
 					return 101; // Switching Protocols
-
+				
 				return new Response('WebSocket upgrade failed', { status: 500 });
 			}, 'GET']);
-
+			
 			ws_message_json_handler = handlers.message_json;
 			ws_open_handler = handlers.open;
 			ws_close_handler = handlers.close;
 			ws_message_handler = handlers.message;
 			ws_drain_handler = handlers.drain;
 		},
-
-		webhook: (secret: string, path: string, handler: WebhookHandler): void => {
-			routes.push([path.split('/'), async (req: Request, url: URL) => {
+		
+		webhook: (secret: string, path: string, handler: WebhookHandler, branches?: string | string[]): void => {
+			routes.push([path.split('/'), async (req: Request) => {
 				if (req.headers.get('Content-Type') !== 'application/json')
 					return 400; // Bad Request
-
+				
 				const signature = req.headers.get('X-Hub-Signature-256');
 				if (signature === null)
 					return 401; // Unauthorized
-
+				
 				const body = await req.json() as JsonSerializable;
 				const hmac = crypto.createHmac('sha256', secret);
 				hmac.update(JSON.stringify(body));
-
-				if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from('sha256=' + hmac.digest('hex'))))
+				
+				const sig_buffer = new Uint8Array(Buffer.from(signature));
+				const hmac_buffer = new Uint8Array(Buffer.from('sha256=' + hmac.digest('hex')));
+				
+				if (!crypto.timingSafeEqual(sig_buffer, hmac_buffer))
 					return 401; // Unauthorized
-
+				
+				// Branch filtering logic
+				if (branches !== undefined) {
+					const branch_list = Array.isArray(branches) ? branches : [branches];
+					const payload = body as any;
+					
+					if (payload.ref && typeof payload.ref === 'string') {
+						const branch_name = payload.ref.split('/').pop() || payload.ref;
+						
+						if (!branch_list.includes(branch_name))
+							return 200; // OK
+					}
+				}
+				
 				return handler(body);
 			}, 'POST']);
 		},
-
+		
 		/** Register a callback for slow requests. */
 		on_slow_request: (callback: SlowRequestCallback, threshold = 1000): void => {
 			slow_request_callback = callback;
 			slow_request_threshold = threshold;
 		},
-
+		
 		/** Mark a request as slow, preventing it from triggering slow request callback. */
 		allow_slow_request: (req: Request): void => {
 			slow_requests.add(req);
 		},
-
+		
 		/** Register a default handler for all status codes. */
 		default: (handler: DefaultHandler): void => {
 			default_handler = handler;
 		},
-
+		
 		/** Register a handler for a specific status code. */
 		handle: (status_code: number, handler: StatusCodeHandler): void => {
 			handlers.set(status_code, handler);
 		},
-
+		
 		/** Register a handler for uncaught errors. */
 		error: (handler: ErrorHandler): void => {
 			error_handler = handler;
 		},
-
+		
 		/** Stops the server. */
 		stop: async (immediate = false): Promise<void> => {
 			server.stop(immediate);
-
+			
 			while (server.pendingRequests > 0)
 				await Bun.sleep(1000);
 		},
-
+		
 		/** Register a handler for server-sent events. */
 		sse: (path: string, handler: ServerSentEventHandler) => {
 			routes.push([path.split('/'), (req: Request, url: URL) => {			
 				let stream_controller: ReadableStreamDirectController;
 				let close_resolver: () => void;
-		
+				
 				function close_controller() {
 					stream_controller?.close();
 					close_resolver?.();
 				}
-		
+				
 				let lastEventTime = Date.now();
 				const KEEP_ALIVE_INTERVAL = 15000;
-		
+				
 				const stream = new ReadableStream({
-					// @ts-ignore Bun implements a "direct" mode which does not exist in the spec.
 					type: 'direct',
-		
+					
 					async pull(controller) {
-						// @ts-ignore `controller` in "direct" mode is ReadableStreamDirectController.
 						stream_controller = controller as ReadableStreamDirectController;
 						
 						while (!req.signal.aborted) {
@@ -1020,23 +1373,23 @@ export function serve(port: number, hostname?: string) {
 						}
 					}
 				});
-		
+				
 				const closed = new Promise<void>(resolve => close_resolver = resolve);
 				req.signal.onabort = close_controller;
-		
+				
 				handler(req, url, {
 					message: (message: string) => {
 						stream_controller.write('data: ' + message + '\n\n');
 						stream_controller.flush();
 						lastEventTime = Date.now();
 					},
-		
+					
 					event: (event_name: string, message: string) => {
 						stream_controller.write('event: ' + event_name + '\ndata: ' + message + '\n\n');
 						stream_controller.flush();
 						lastEventTime = Date.now();
 					},
-		
+					
 					close: close_controller,
 					closed
 				});
@@ -1050,6 +1403,98 @@ export function serve(port: number, hostname?: string) {
 					}
 				});
 			}, 'GET']);
+		},
+		
+		/* Bootstrap a static web server */
+		bootstrap: async function(options: BootstrapOptions) {
+			const hash_sub_table = options.cache_bust ? await generate_hash_subs() : {};
+			const global_sub_table = sub_table_merge(hash_sub_table, options.global_subs);
+
+			let cache = options.cache;
+			if (cache !== undefined && !is_cache_http(cache))
+				cache = cache_http(cache);
+
+			for (const [route, route_opts] of Object.entries(options.routes)) {
+				const content_generator = async () => {
+					let content = await resolve_bootstrap_content(route_opts.content);
+
+					if (options.base !== undefined)
+						content = await parse_template(await resolve_bootstrap_content(options.base), { content }, false);
+					
+					const sub_table = sub_table_merge({}, global_sub_table, route_opts.subs);
+					content = await parse_template(content, sub_table, true);
+					
+					return content;
+				};
+				
+				const handler = cache 
+					? async (req: Request) => cache.request(req, route, content_generator)
+					: async () => content_generator();
+				
+				this.route(route, handler);
+			}
+
+			const error_options = options.error;
+			if (error_options !== undefined) {
+				const create_error_content_generator = (status_code: number) => async () => {
+					const error_text = HTTP_STATUS_TEXT[status_code] as string;
+					let content = await resolve_bootstrap_content(error_options.error_page);
+
+					if (options.base !== undefined)
+						content = await parse_template(await resolve_bootstrap_content(options.base), { content }, false);
+
+					const sub_table = sub_table_merge({
+						error_code: status_code.toString(),
+						error_text: error_text
+					}, global_sub_table);
+
+					content = await parse_template(content, sub_table, true);
+					return content;
+				};
+
+				const default_handler = async (req: Request, status_code: number): Promise<Response> => {
+					if (cache) {
+						return cache.request(req, `error_${status_code}`, create_error_content_generator(status_code), status_code);
+					} else {
+						const content = await create_error_content_generator(status_code)();
+						return new Response(content, { status: status_code });
+					}
+				};
+
+				this.error((err, req) => {
+					if (options.error?.use_canary_reporting)
+						caution(err?.message ?? err);
+	
+					return default_handler(req, 500);
+				});
+				
+				this.default((req, status_code) => default_handler(req, status_code));
+			}
+			
+			const static_options = options.static;
+			if (static_options) {
+				this.dir(static_options.route, static_options.directory, async (file_path, file, stat, request) => {
+					// ignore hidden files by default, return 404 to prevent file sniffing
+					if (path.basename(file_path).startsWith('.'))
+						return 404; // Not Found
+					
+					if (stat.isDirectory())
+						return 401; // Unauthorized
+
+					const ext = path.extname(file_path);
+					if (static_options.sub_ext?.includes(ext)) {
+						const content = await parse_template(await file.text(), global_sub_table, true);
+						return new Response(content, {
+							headers: {
+								'Content-Type': file.type
+							}
+						});
+					}
+					
+					return http_apply_range(file, request);
+				});
+			}
 		}
 	};
-}
+}
+// endregion