@ubean/server 0.1.2 → 0.1.4

package/dist/index.js

@@ -0,0 +1,2066 @@
+import { createHooks } from "hookable";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, join } from "pathe";
+//#region src/cache.ts
+function createMemoryStore(maxEntries = 200) {
+	const store = /* @__PURE__ */ new Map();
+	function evict() {
+		if (store.size <= maxEntries) return;
+		const entries = Array.from(store.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+		const removeCount = Math.ceil(entries.length * .2);
+		for (let i = 0; i < removeCount; i++) store.delete(entries[i][0]);
+	}
+	return {
+		async get(key) {
+			const entry = store.get(key);
+			if (!entry) return void 0;
+			if (Date.now() > entry.expiresAt) {
+				store.delete(key);
+				return;
+			}
+			return entry;
+		},
+		async set(key, entry, ttl) {
+			const now = Date.now();
+			store.set(key, {
+				...entry,
+				createdAt: now,
+				expiresAt: now + ttl * 1e3
+			});
+			evict();
+		},
+		async delete(key) {
+			return store.delete(key);
+		},
+		async clear() {
+			store.clear();
+		}
+	};
+}
+let globalStore = null;
+function useCacheStore(store) {
+	if (store) {
+		globalStore = store;
+		return store;
+	}
+	if (!globalStore) globalStore = createMemoryStore();
+	return globalStore;
+}
+function clearCacheStore() {
+	globalStore = null;
+}
+function buildCacheKey(c) {
+	const url = new URL(c.req.url);
+	return `${c.req.method}:${url.pathname}${url.search}`;
+}
+function serializeResponse(res) {
+	return res.arrayBuffer().then((body) => {
+		const headers = {};
+		res.headers.forEach((v, k) => {
+			const kl = k.toLowerCase();
+			if (kl !== "set-cookie" && kl !== "authorization") headers[k] = v;
+		});
+		return {
+			body,
+			headers,
+			status: res.status,
+			statusText: res.statusText
+		};
+	});
+}
+function entryToResponse(entry) {
+	const headers = new Headers(entry.headers);
+	headers.set("X-Cache", "HIT");
+	headers.set("Age", String(Math.max(0, Math.floor((Date.now() - entry.createdAt) / 1e3))));
+	return new Response(entry.body, {
+		status: entry.status,
+		statusText: entry.statusText,
+		headers
+	});
+}
+function isCacheableRequest(c) {
+	if (c.req.method !== "GET" && c.req.method !== "HEAD") return false;
+	if (c.req.header("authorization")) return false;
+	if (c.req.header("cookie")) {
+		if (!(c.req.header("cache-control") || "").includes("public")) return false;
+	}
+	const cc = c.req.header("cache-control");
+	if (cc && (cc.includes("no-cache") || cc.includes("no-store"))) return false;
+	return true;
+}
+function isCacheableResponse(res) {
+	if (res.status !== 200) return false;
+	if (res.headers.get("set-cookie")) return false;
+	const cc = res.headers.get("cache-control");
+	if (cc && (cc.includes("private") || cc.includes("no-store"))) return false;
+	return true;
+}
+function matchPath(pattern, path) {
+	const DOUBLE = "__DWC__";
+	const SINGLE = "__SWC__";
+	let s = pattern;
+	s = s.replace(/\/\*\*/g, `/${DOUBLE}`);
+	s = s.replace(/\*/g, SINGLE);
+	s = s.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	s = s.replace(new RegExp(SINGLE, "g"), "[^/]*");
+	s = s.replace(new RegExp(`/${DOUBLE}`, "g"), "(?:/.*)?");
+	return new RegExp(`^${s}$`).test(path);
+}
+function createCacheMiddleware(options = {}) {
+	const store = options.store || useCacheStore();
+	function findTtl(path) {
+		if (!options.rules) return null;
+		const patterns = Object.keys(options.rules);
+		for (const pattern of patterns) if (matchPath(pattern, path)) return options.rules[pattern].ttl;
+		return null;
+	}
+	return async function cacheMiddleware(c, next) {
+		const path = new URL(c.req.url).pathname;
+		const ttl = findTtl(path);
+		if (ttl != null && ttl > 0 && isCacheableRequest(c)) {
+			const key = buildCacheKey(c);
+			const existing = await store.get(key);
+			if (existing) return entryToResponse(existing);
+		}
+		await next();
+		if (ttl == null || ttl <= 0) return;
+		const res = c.res;
+		if (!res || !isCacheableRequest(c) || !isCacheableResponse(res)) return;
+		const serialized = await serializeResponse(res.clone());
+		await store.set(buildCacheKey(c), serialized, ttl);
+	};
+}
+function cachedEventHandler(handler, options = { ttl: 60 }) {
+	const store = useCacheStore();
+	const ttl = options.ttl;
+	const keyBase = options.name;
+	return (async (c) => {
+		const key = keyBase || buildCacheKey(c);
+		if (ttl > 0 && isCacheableRequest(c)) {
+			const existing = await store.get(key);
+			if (existing) return entryToResponse(existing);
+		}
+		const res = await handler(c);
+		if (ttl > 0 && isCacheableResponse(res)) {
+			const serialized = await serializeResponse(res.clone());
+			await store.set(key, serialized, ttl);
+		}
+		return res;
+	});
+}
+async function invalidateRouteCache(keyPattern) {
+	const store = useCacheStore();
+	if (!keyPattern) {
+		await store.clear();
+		return;
+	}
+	if (typeof keyPattern === "string") {
+		await store.delete(keyPattern);
+		return;
+	}
+	const memStore = store;
+	if (memStore.store) {
+		for (const k of Array.from(memStore.store.keys())) if (keyPattern.test(k)) await store.delete(k);
+	}
+}
+function resolveRouteCacheRules(routeRules) {
+	const result = {};
+	for (const [path, rule] of Object.entries(routeRules)) if (rule.cache && rule.cache.ttl != null) result[path] = {
+		ttl: rule.cache.ttl,
+		swr: rule.cache.swr
+	};
+	return result;
+}
+//#endregion
+//#region src/database.ts
+const _global = globalThis;
+const dbRegistry = /* @__PURE__ */ new Map();
+const dbHooks = createHooks();
+let defaultDatabase = null;
+const RAW_SQL = Symbol("rawSql");
+function rawSql(str) {
+	return {
+		[RAW_SQL]: true,
+		value: str
+	};
+}
+function createInMemoryDatabase() {
+	const tables = /* @__PURE__ */ new Map();
+	function getTable(name) {
+		return tables.get(name.toLowerCase());
+	}
+	function parseSqlValue(val) {
+		const trimmed = val.trim();
+		const upper = trimmed.toUpperCase();
+		if (upper === "NULL") return null;
+		if (upper === "TRUE") return true;
+		if (upper === "FALSE") return false;
+		if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+		if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+		if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+			const quote = trimmed[0];
+			return trimmed.slice(1, -1).replace(new RegExp(quote + quote, "g"), quote);
+		}
+		return trimmed;
+	}
+	function splitByCommaRespectingStrings(str) {
+		const parts = [];
+		let current = "";
+		let inString = false;
+		let stringChar = "";
+		let depth = 0;
+		for (let i = 0; i < str.length; i++) {
+			const ch = str[i];
+			const next = str[i + 1];
+			if (!inString && (ch === "'" || ch === "\"")) {
+				inString = true;
+				stringChar = ch;
+				current += ch;
+			} else if (inString && ch === stringChar) if (next === stringChar) {
+				current += ch + ch;
+				i++;
+			} else {
+				inString = false;
+				current += ch;
+			}
+			else if (!inString && ch === "(") {
+				depth++;
+				current += ch;
+			} else if (!inString && ch === ")") {
+				depth--;
+				current += ch;
+			} else if (!inString && depth === 0 && ch === ",") {
+				parts.push(current.trim());
+				current = "";
+			} else current += ch;
+		}
+		if (current.trim()) parts.push(current.trim());
+		return parts;
+	}
+	function parseCreateTable(query) {
+		const ifNotExists = /IF\s+NOT\s+EXISTS/i.test(query);
+		const match = query.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["`]?(\w+)["`]?\s*\(([\s\S]+)\)\s*;?\s*$/i);
+		if (!match) return;
+		const [, tableName, colsStr] = match;
+		const lowerName = tableName.toLowerCase();
+		if (ifNotExists && tables.has(lowerName)) return;
+		const table = {
+			name: tableName,
+			columns: /* @__PURE__ */ new Map(),
+			rows: []
+		};
+		const colDefs = splitByCommaRespectingStrings(colsStr);
+		for (const colDef of colDefs) {
+			const upperDef = colDef.toUpperCase().trim();
+			if (upperDef.startsWith("PRIMARY KEY") || upperDef.startsWith("CONSTRAINT") || upperDef.startsWith("FOREIGN") || upperDef.startsWith("UNIQUE") || upperDef.startsWith("INDEX")) continue;
+			const match2 = colDef.match(/^["`]?(\w+)["`]?\s+(\w+)?(.*)$/);
+			if (!match2) continue;
+			const [, colNameRaw, colTypeRaw = "TEXT", rest] = match2;
+			const colName = colNameRaw.replace(/["`]/g, "");
+			const colType = (colTypeRaw || "TEXT").toUpperCase();
+			const isPK = /PRIMARY\s+KEY/i.test(rest);
+			const notNull = /NOT\s+NULL/i.test(rest);
+			table.columns.set(colName, {
+				type: colType,
+				primaryKey: isPK,
+				notNull
+			});
+		}
+		tables.set(lowerName, table);
+	}
+	function parseInsert(query) {
+		const insertMatch = query.match(/INSERT\s+INTO\s+["`]?(\w+)["`]?\s*(?:\(([^)]+)\))?\s*VALUES\s*\(([\s\S]+)\)\s*;?\s*$/i);
+		if (!insertMatch) return null;
+		const [, tableName, colsStr, valuesStr] = insertMatch;
+		const table = getTable(tableName);
+		if (!table) return null;
+		const columns = colsStr ? splitByCommaRespectingStrings(colsStr).map((c) => c.trim().replace(/["`]/g, "")) : Array.from(table.columns.keys());
+		const values = splitByCommaRespectingStrings(valuesStr).map((s) => parseSqlValue(s));
+		return {
+			table: tableName.toLowerCase(),
+			columns,
+			values
+		};
+	}
+	function parseSelect(query) {
+		const simpleMatch = query.match(/SELECT\s+([\s\S]+?)\s+FROM\s+["`]?(\w+)["`]?/i);
+		if (!simpleMatch) return null;
+		const tableName = simpleMatch[2];
+		let where;
+		const whereIdx = query.toUpperCase().indexOf("WHERE");
+		if (whereIdx !== -1) {
+			let wherePart = query.slice(whereIdx + 5);
+			const orderIdx = wherePart.toUpperCase().indexOf("ORDER");
+			const limitIdx = wherePart.toUpperCase().indexOf("LIMIT");
+			let endIdx = wherePart.length;
+			if (orderIdx !== -1) endIdx = Math.min(endIdx, orderIdx);
+			if (limitIdx !== -1) endIdx = Math.min(endIdx, limitIdx);
+			wherePart = wherePart.slice(0, endIdx).trim().replace(/;$/, "");
+			const eqIdx = wherePart.indexOf("=");
+			if (eqIdx !== -1) where = {
+				col: wherePart.slice(0, eqIdx).trim().replace(/["`]/g, ""),
+				val: parseSqlValue(wherePart.slice(eqIdx + 1).trim())
+			};
+		}
+		return {
+			table: tableName.toLowerCase(),
+			where
+		};
+	}
+	function escapeValue(val) {
+		if (val !== null && typeof val === "object" && RAW_SQL in val) return val.value;
+		if (val === null || val === void 0) return "NULL";
+		if (typeof val === "number") return String(val);
+		if (typeof val === "boolean") return val ? "1" : "0";
+		if (val instanceof Date) return `'${val.toISOString()}'`;
+		return `'${String(val).replace(/'/g, "''")}'`;
+	}
+	function buildQueryFromTemplate(strings, values) {
+		let query = "";
+		for (let i = 0; i < strings.length; i++) {
+			query += strings[i];
+			if (i < values.length) query += escapeValue(values[i]);
+		}
+		return query;
+	}
+	function executeRaw(query) {
+		const upperQuery = query.toUpperCase().trim();
+		if (upperQuery.startsWith("CREATE TABLE")) {
+			parseCreateTable(query);
+			return [];
+		}
+		if (upperQuery.startsWith("INSERT INTO")) {
+			const parsed = parseInsert(query);
+			if (parsed) {
+				const table = getTable(parsed.table);
+				if (table) {
+					const row = {};
+					for (let i = 0; i < parsed.columns.length; i++) row[parsed.columns[i]] = parsed.values[i] ?? null;
+					table.rows.push(row);
+				}
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("SELECT")) {
+			const parsed = parseSelect(query);
+			if (parsed) {
+				const table = getTable(parsed.table);
+				if (!table) return [];
+				let rows = [...table.rows];
+				if (parsed.where) rows = rows.filter((row) => row[parsed.where.col] == parsed.where.val);
+				return rows;
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("DELETE FROM")) {
+			const match = query.match(/DELETE\s+FROM\s+["`]?(\w+)["`]?\s*(?:WHERE\s+(.+))?/i);
+			if (match) {
+				const table = getTable(match[1]);
+				if (table) {
+					const whereStr = match[2];
+					if (whereStr) {
+						const eqIdx = whereStr.indexOf("=");
+						if (eqIdx !== -1) {
+							const col = whereStr.slice(0, eqIdx).trim().replace(/["`]/g, "");
+							const val = parseSqlValue(whereStr.slice(eqIdx + 1).trim());
+							table.rows = table.rows.filter((row) => row[col] != val);
+						} else table.rows = [];
+					} else table.rows = [];
+				}
+			}
+			return [];
+		}
+		if (upperQuery.startsWith("DROP TABLE")) {
+			const match = query.match(/DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["`]?(\w+)["`]?/i);
+			if (match) tables.delete(match[1].toLowerCase());
+			return [];
+		}
+		return [];
+	}
+	return {
+		async sql(strings, ...values) {
+			const query = buildQueryFromTemplate(strings, values);
+			try {
+				await dbHooks.callHook("db:query", query, values);
+				return { rows: executeRaw(query) };
+			} catch (err) {
+				await dbHooks.callHook("db:error", err instanceof Error ? err : new Error(String(err)), query);
+				throw err;
+			}
+		},
+		async exec(query) {
+			const statements = splitSqlStatements(query);
+			for (const stmt of statements) {
+				const trimmed = stmt.trim();
+				if (!trimmed) continue;
+				try {
+					await dbHooks.callHook("db:query", trimmed);
+					executeRaw(trimmed);
+				} catch (err) {
+					await dbHooks.callHook("db:error", err instanceof Error ? err : new Error(String(err)), trimmed);
+					throw err;
+				}
+			}
+		},
+		async close() {
+			tables.clear();
+		}
+	};
+}
+function splitSqlStatements(sql) {
+	const statements = [];
+	let current = "";
+	let inString = false;
+	let stringChar = "";
+	for (let i = 0; i < sql.length; i++) {
+		const ch = sql[i];
+		if (!inString && (ch === "'" || ch === "\"")) {
+			inString = true;
+			stringChar = ch;
+			current += ch;
+		} else if (inString && ch === stringChar) if (sql[i + 1] === stringChar) {
+			current += ch + ch;
+			i++;
+		} else {
+			inString = false;
+			current += ch;
+		}
+		else if (!inString && ch === ";") {
+			statements.push(current);
+			current = "";
+		} else current += ch;
+	}
+	if (current.trim()) statements.push(current);
+	return statements;
+}
+function wrapDatabase(raw, name) {
+	const db = {
+		sql: raw.sql,
+		exec: raw.exec,
+		async close() {
+			await raw.close();
+			if (name) dbRegistry.delete(name);
+			if (defaultDatabase === db) defaultDatabase = null;
+			await dbHooks.callHook("db:disconnect", db);
+		}
+	};
+	return db;
+}
+function defineDatabase(options = {}) {
+	if (!options.connector && !options.connectors) {
+		const db = wrapDatabase(createInMemoryDatabase());
+		if (!defaultDatabase) defaultDatabase = db;
+		dbRegistry.set("default", db);
+		dbHooks.callHook("db:connect", db);
+		return db;
+	}
+	const createFn = _global.$db0Create;
+	let raw;
+	if (options.connector) if (createFn) try {
+		raw = createFn(options.connector);
+	} catch {
+		raw = createInMemoryDatabase();
+	}
+	else raw = createInMemoryDatabase();
+	else if (options.connectors) {
+		const defaultName = options.default || Object.keys(options.connectors)[0];
+		const connector = options.connectors[defaultName];
+		if (connector && createFn) try {
+			raw = createFn(connector);
+		} catch {
+			raw = createInMemoryDatabase();
+		}
+		else raw = createInMemoryDatabase();
+	} else raw = createInMemoryDatabase();
+	const dbName = options.default || "default";
+	const db = wrapDatabase(raw, dbName);
+	dbRegistry.set(dbName, db);
+	if (!defaultDatabase) defaultDatabase = db;
+	dbHooks.callHook("db:connect", db);
+	return db;
+}
+function useDatabase(name) {
+	if (name) {
+		const db = dbRegistry.get(name);
+		if (!db) throw new Error(`Database '${name}' not found. Call defineDatabase() first.`);
+		return db;
+	}
+	if (!defaultDatabase) defaultDatabase = defineDatabase();
+	return defaultDatabase;
+}
+async function closeDatabases() {
+	const dbs = Array.from(dbRegistry.values());
+	dbRegistry.clear();
+	defaultDatabase = null;
+	for (const db of dbs) await db.close();
+}
+function getDatabaseHooks() {
+	return dbHooks;
+}
+function registerDb0Create(fn) {
+	_global.$db0Create = fn;
+}
+async function migrateDatabase(db, migrations) {
+	for (const migration of migrations) await db.exec(migration);
+}
+async function runMigrations(db, migrations, options = {}) {
+	const tableName = options.table || "_migrations";
+	const applied = [];
+	await db.exec(`CREATE TABLE IF NOT EXISTS ${tableName} (name TEXT PRIMARY KEY, applied_at INTEGER)`);
+	const { rows } = await db.sql`SELECT name FROM ${rawSql(tableName)}`;
+	const appliedNames = new Set(rows.map((r) => r.name));
+	for (const migration of migrations) {
+		if (appliedNames.has(migration.name)) continue;
+		await db.exec(migration.up);
+		await db.sql`INSERT INTO ${rawSql(tableName)} (name, applied_at) VALUES (${migration.name}, ${Date.now()})`;
+		applied.push(migration.name);
+		if (options.log) console.log(`[db] Applied migration: ${migration.name}`);
+	}
+	return { applied };
+}
+//#endregion
+//#region src/queue.ts
+const queueDefinitions = /* @__PURE__ */ new Map();
+let globalDriver = null;
+const inMemoryQueues = /* @__PURE__ */ new Map();
+function generateId$2() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function defineQueue(options, handler) {
+	if (!options.name) throw new Error("[ubean] Queue must have a name");
+	const finalHandler = handler || options.handler;
+	if (!finalHandler) throw new Error(`[ubean] Queue "${options.name}" must have a handler`);
+	const def = {
+		name: options.name,
+		handler: finalHandler,
+		concurrency: options.concurrency ?? 5,
+		retries: options.retries ?? 3,
+		retryDelay: options.retryDelay ?? 1e3,
+		deadLetterQueue: options.deadLetterQueue
+	};
+	queueDefinitions.set(options.name, def);
+	const untypedDef = def;
+	if (globalDriver?.registerHandler) globalDriver.registerHandler(options.name, finalHandler, untypedDef);
+	ensureInMemoryQueue(options.name, untypedDef);
+	return def;
+}
+function ensureInMemoryQueue(name, options) {
+	if (!inMemoryQueues.has(name)) inMemoryQueues.set(name, {
+		messages: [],
+		processing: /* @__PURE__ */ new Set(),
+		stats: {
+			pending: 0,
+			processing: 0,
+			completed: 0,
+			failed: 0
+		},
+		options: {
+			name,
+			...options
+		}
+	});
+	return inMemoryQueues.get(name);
+}
+function createMemoryQueueDriver() {
+	let running = false;
+	let processTimer = null;
+	async function processQueue(name) {
+		const queue = inMemoryQueues.get(name);
+		if (!queue) return;
+		const def = queueDefinitions.get(name);
+		const concurrency = def?.concurrency ?? 5;
+		const retries = def?.retries ?? 3;
+		const retryDelay = def?.retryDelay ?? 1e3;
+		while (queue.processing.size < concurrency && queue.messages.length > 0) {
+			const msg = queue.messages.shift();
+			if (!msg) break;
+			queue.processing.add(msg.id);
+			queue.stats.processing++;
+			queue.stats.pending--;
+			processMessage(name, msg).catch(() => {});
+		}
+		async function processMessage(queueName, message) {
+			const q = inMemoryQueues.get(queueName);
+			if (!q) return;
+			const handler = queueDefinitions.get(queueName)?.handler;
+			if (!handler) {
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				return;
+			}
+			try {
+				await handler(message);
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				q.stats.completed++;
+			} catch (err) {
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				message.attempts++;
+				if (message.attempts >= retries) {
+					q.stats.failed++;
+					const dlq = def?.deadLetterQueue;
+					if (dlq) await driver.send(dlq, message.body, { headers: { "x-error": err instanceof Error ? err.message : String(err) } });
+				} else {
+					await new Promise((resolve) => setTimeout(resolve, retryDelay * message.attempts));
+					q.messages.unshift(message);
+					q.stats.pending++;
+				}
+			}
+		}
+	}
+	const driver = {
+		async send(queueName, body, options = {}) {
+			const queue = ensureInMemoryQueue(queueName);
+			const id = generateId$2();
+			const message = {
+				id,
+				body,
+				timestamp: Date.now(),
+				attempts: 0,
+				headers: options.headers
+			};
+			if (options.delay && options.delay > 0) setTimeout(() => {
+				queue.messages.push(message);
+				queue.stats.pending++;
+				if (running) processQueue(queueName);
+			}, options.delay);
+			else {
+				queue.messages.push(message);
+				queue.stats.pending++;
+				if (running) processQueue(queueName);
+			}
+			return id;
+		},
+		async sendBatch(queueName, bodies, options = {}) {
+			const ids = [];
+			for (const body of bodies) {
+				const id = await this.send(queueName, body, options);
+				ids.push(id);
+			}
+			return ids;
+		},
+		registerHandler(queueName, handler, options) {
+			const queue = ensureInMemoryQueue(queueName, options);
+			queue.handler = handler;
+		},
+		async start() {
+			if (running) return;
+			running = true;
+			for (const [name, def] of queueDefinitions) {
+				const queue = ensureInMemoryQueue(name, def);
+				queue.handler = def.handler;
+			}
+			processTimer = setInterval(() => {
+				for (const name of inMemoryQueues.keys()) processQueue(name);
+			}, 100);
+			for (const name of inMemoryQueues.keys()) processQueue(name);
+		},
+		async stop() {
+			running = false;
+			if (processTimer) {
+				clearInterval(processTimer);
+				processTimer = null;
+			}
+		},
+		async getQueueDepth(queueName) {
+			const queue = inMemoryQueues.get(queueName);
+			if (!queue) return 0;
+			return queue.messages.length;
+		},
+		async deleteMessage(queueName, messageId) {
+			const queue = inMemoryQueues.get(queueName);
+			if (!queue) return false;
+			const idx = queue.messages.findIndex((m) => m.id === messageId);
+			if (idx >= 0) {
+				queue.messages.splice(idx, 1);
+				queue.stats.pending--;
+				return true;
+			}
+			if (queue.processing.has(messageId)) {
+				queue.processing.delete(messageId);
+				queue.stats.processing--;
+				return true;
+			}
+			return false;
+		}
+	};
+	return driver;
+}
+function useQueueDriver() {
+	if (!globalDriver) globalDriver = createMemoryQueueDriver();
+	return globalDriver;
+}
+function setQueueDriver(driver) {
+	globalDriver = driver;
+	for (const [name, def] of queueDefinitions) if (driver.registerHandler) driver.registerHandler(name, def.handler, def);
+}
+async function sendMessage(queueName, body, options) {
+	return useQueueDriver().send(queueName, body, options);
+}
+async function sendMessages(queueName, bodies, options) {
+	return useQueueDriver().sendBatch(queueName, bodies, options);
+}
+function getQueueDefinitions() {
+	return Array.from(queueDefinitions.values());
+}
+function clearQueueDefinitions() {
+	queueDefinitions.clear();
+	inMemoryQueues.clear();
+}
+async function startQueueWorkers() {
+	const driver = useQueueDriver();
+	if (driver.start) await driver.start();
+}
+async function stopQueueWorkers() {
+	const driver = useQueueDriver();
+	if (driver.stop) await driver.stop();
+}
+function getQueueStats(queueName) {
+	const queue = inMemoryQueues.get(queueName);
+	if (!queue) return void 0;
+	return { ...queue.stats };
+}
+function getAllQueueStats() {
+	const result = {};
+	for (const [name, queue] of inMemoryQueues) result[name] = { ...queue.stats };
+	return result;
+}
+//#endregion
+//#region src/cron.ts
+const SCHEDULED_TASKS_KEY = "__ubean_scheduled_tasks__";
+const TASK_RUN_COUNT_KEY = "__ubean_task_run_count__";
+function getTaskMap() {
+	if (!globalThis[SCHEDULED_TASKS_KEY]) globalThis[SCHEDULED_TASKS_KEY] = /* @__PURE__ */ new Map();
+	return globalThis[SCHEDULED_TASKS_KEY];
+}
+function getTaskRunCount() {
+	if (!globalThis[TASK_RUN_COUNT_KEY]) globalThis[TASK_RUN_COUNT_KEY] = { value: 0 };
+	return globalThis[TASK_RUN_COUNT_KEY];
+}
+function defineScheduled(metaOrName, handler) {
+	let meta;
+	let fn;
+	if (typeof metaOrName === "string") {
+		meta = {
+			name: metaOrName,
+			schedule: "* * * * *"
+		};
+		fn = handler || (() => {});
+	} else {
+		meta = metaOrName;
+		fn = handler || (() => {});
+	}
+	if (!meta.name) throw new Error("[ubean] Cron task must have a name");
+	if (!meta.schedule) throw new Error(`[ubean] Cron task "${meta.name}" must have a schedule (cron expression)`);
+	const task = {
+		name: meta.name,
+		schedule: meta.schedule,
+		handler: fn,
+		meta: {
+			description: meta.description,
+			timezone: meta.timezone,
+			timeout: meta.timeout,
+			runOnStart: meta.runOnStart
+		}
+	};
+	getTaskMap().set(meta.name, task);
+	return task;
+}
+function getScheduledTasks() {
+	return Array.from(getTaskMap().values());
+}
+function clearScheduledTasks() {
+	getTaskMap().clear();
+}
+async function runScheduledTask(name) {
+	const task = getTaskMap().get(name);
+	if (!task) throw new Error(`[ubean] Cron task "${name}" not found`);
+	const runCount = ++getTaskRunCount().value;
+	const start = Date.now();
+	try {
+		const ctx = {
+			name: task.name,
+			schedule: task.schedule,
+			timestamp: /* @__PURE__ */ new Date(),
+			runCount
+		};
+		await task.handler(ctx);
+		return {
+			ok: true,
+			duration: Date.now() - start
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			duration: Date.now() - start,
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+}
+function createCronContext(name, schedule) {
+	const runCount = ++getTaskRunCount().value;
+	return {
+		name,
+		schedule,
+		timestamp: /* @__PURE__ */ new Date(),
+		runCount
+	};
+}
+//#endregion
+//#region src/cron-scheduler.ts
+function parseField(field, min, max) {
+	const result = /* @__PURE__ */ new Set();
+	for (const part of field.split(",")) {
+		const trimmed = part.trim();
+		if (trimmed === "*") {
+			for (let i = min; i <= max; i++) result.add(i);
+			continue;
+		}
+		const stepMatch = trimmed.match(/^(.+)\/(\d+)$/);
+		let base = trimmed;
+		let step = 1;
+		if (stepMatch) {
+			base = stepMatch[1];
+			step = parseInt(stepMatch[2], 10);
+		}
+		if (base === "*") {
+			for (let i = min; i <= max; i += step) result.add(i);
+			continue;
+		}
+		const rangeMatch = base.match(/^(\d+)-(\d+)$/);
+		if (rangeMatch) {
+			const start = parseInt(rangeMatch[1], 10);
+			const end = parseInt(rangeMatch[2], 10);
+			for (let i = Math.max(min, start); i <= Math.min(max, end); i += step) result.add(i);
+			continue;
+		}
+		const value = parseInt(base, 10);
+		if (!isNaN(value) && value >= min && value <= max) result.add(value);
+	}
+	return Array.from(result).sort((a, b) => a - b);
+}
+function parseCron(schedule) {
+	const parts = schedule.trim().split(/\s+/);
+	if (parts.length < 5) return null;
+	const parsed = {
+		minute: parseField(parts[0], 0, 59),
+		hour: parseField(parts[1], 0, 23),
+		dom: parseField(parts[2], 1, 31),
+		month: parseField(parts[3], 1, 12),
+		dow: parseField(parts[4], 0, 6)
+	};
+	if (parsed.minute.length === 0 || parsed.hour.length === 0 || parsed.dom.length === 0 || parsed.month.length === 0 || parsed.dow.length === 0) return null;
+	return parsed;
+}
+function matches(date, parsed) {
+	return parsed.minute.includes(date.getMinutes()) && parsed.hour.includes(date.getHours()) && parsed.dom.includes(date.getDate()) && parsed.month.includes(date.getMonth() + 1) && parsed.dow.includes(date.getDay());
+}
+function nextMatch(from, parsed) {
+	const d = new Date(from);
+	d.setSeconds(0, 0);
+	d.setMinutes(d.getMinutes() + 1);
+	for (let i = 0; i < 366 * 24 * 60; i++) {
+		if (matches(d, parsed)) return new Date(d);
+		d.setMinutes(d.getMinutes() + 1);
+	}
+	return null;
+}
+const taskRunCounts = /* @__PURE__ */ new Map();
+function getRunCount(name) {
+	const c = taskRunCounts.get(name) || 0;
+	taskRunCounts.set(name, c + 1);
+	return c + 1;
+}
+function createMemoryCronScheduler(options = {}) {
+	let timer = null;
+	let running = false;
+	const taskTimers = /* @__PURE__ */ new Map();
+	const runOnStartExecuted = /* @__PURE__ */ new Set();
+	async function executeTask(task) {
+		const ctx = {
+			name: task.name,
+			schedule: task.schedule,
+			timestamp: /* @__PURE__ */ new Date(),
+			runCount: getRunCount(task.name)
+		};
+		const start = Date.now();
+		options.onTaskStart?.(task);
+		try {
+			const timeoutMs = task.meta.timeout || options.defaultTimeout || 3e4;
+			await Promise.race([task.handler(ctx), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`Task "${task.name}" timed out after ${timeoutMs}ms`)), timeoutMs))]);
+			const result = {
+				ok: true,
+				duration: Date.now() - start
+			};
+			options.onTaskComplete?.(task, result);
+			return result;
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			const result = {
+				ok: false,
+				duration: Date.now() - start,
+				error
+			};
+			options.onTaskError?.(task, error);
+			options.onTaskComplete?.(task, result);
+			return result;
+		}
+	}
+	function checkAndRun() {
+		const tasks = getScheduledTasks();
+		const now = /* @__PURE__ */ new Date();
+		for (const task of tasks) {
+			const parsed = parseCron(task.schedule);
+			if (!parsed) continue;
+			if (matches(now, parsed)) {
+				const timerKey = `${task.name}_${now.getFullYear()}-${now.getMonth()}-${now.getDate()}-${now.getHours()}-${now.getMinutes()}`;
+				if (taskTimers.has(timerKey)) continue;
+				if (runOnStartExecuted.has(task.name)) {
+					runOnStartExecuted.delete(task.name);
+					taskTimers.set(timerKey, setTimeout(() => {
+						taskTimers.delete(timerKey);
+					}, 6e4));
+					continue;
+				}
+				taskTimers.set(timerKey, setTimeout(() => {
+					taskTimers.delete(timerKey);
+				}, 6e4));
+				executeTask(task);
+			}
+		}
+	}
+	return {
+		async start() {
+			if (running) return;
+			running = true;
+			const tasks = getScheduledTasks();
+			for (const task of tasks) if (task.meta.runOnStart) {
+				runOnStartExecuted.add(task.name);
+				await executeTask(task);
+			}
+			timer = setInterval(checkAndRun, 3e4);
+		},
+		async stop() {
+			running = false;
+			if (timer) {
+				clearInterval(timer);
+				timer = null;
+			}
+			for (const t of taskTimers.values()) clearTimeout(t);
+			taskTimers.clear();
+		},
+		async runTask(name) {
+			const task = getScheduledTasks().find((t) => t.name === name);
+			if (!task) throw new Error(`[ubean] Cron task "${name}" not found`);
+			return executeTask(task);
+		},
+		isRunning() {
+			return running;
+		},
+		getTasks() {
+			return getScheduledTasks();
+		},
+		getNextRuns() {
+			return getScheduledTasks().map((task) => {
+				const parsed = parseCron(task.schedule);
+				return {
+					name: task.name,
+					nextRun: parsed ? nextMatch(/* @__PURE__ */ new Date(), parsed) : null
+				};
+			});
+		}
+	};
+}
+function startCronScheduler(options = {}) {
+	const scheduler = createMemoryCronScheduler(options);
+	scheduler.start();
+	return scheduler;
+}
+function resetCronRunCounts() {
+	taskRunCounts.clear();
+}
+function validateCron(schedule) {
+	return parseCron(schedule) !== null;
+}
+//#endregion
+//#region src/websocket.ts
+const rooms = /* @__PURE__ */ new Map();
+const topicSubscribers = /* @__PURE__ */ new Map();
+const definitions = /* @__PURE__ */ new Map();
+const peerIdSeed = { value: 0 };
+var RoomImpl = class {
+	name;
+	peers = /* @__PURE__ */ new Set();
+	constructor(name) {
+		this.name = name;
+	}
+	broadcast(msg, options) {
+		for (const peer of this.peers) {
+			if (options?.except && peer === options.except) continue;
+			if (peer.readyState === 1) try {
+				peer.send(msg);
+			} catch {}
+		}
+	}
+	add(peer) {
+		this.peers.add(peer);
+		peer._rooms.add(this.name);
+	}
+	remove(peer) {
+		this.peers.delete(peer);
+		peer._rooms.delete(this.name);
+		if (this.peers.size === 0) rooms.delete(this.name);
+	}
+};
+function generateId$1() {
+	peerIdSeed.value++;
+	return `peer_${Date.now().toString(36)}_${peerIdSeed.value.toString(36)}`;
+}
+function createPeer(options) {
+	const subscriptions = /* @__PURE__ */ new Set();
+	const peerRooms = /* @__PURE__ */ new Set();
+	let data = void 0;
+	const peer = {
+		id: options.id,
+		url: options.url,
+		headers: options.headers,
+		get readyState() {
+			return 1;
+		},
+		_subscriptions: subscriptions,
+		_rooms: peerRooms,
+		_raw: options.raw,
+		send: options.send,
+		close: options.close,
+		publish(topic, msg) {
+			const topicPeers = topicSubscribers.get(topic);
+			if (topicPeers) {
+				for (const p of topicPeers) if (p !== peer && p.readyState === 1) try {
+					p.send(msg);
+				} catch {}
+			}
+		},
+		subscribe(topic) {
+			subscriptions.add(topic);
+			let set = topicSubscribers.get(topic);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				topicSubscribers.set(topic, set);
+			}
+			set.add(peer);
+		},
+		unsubscribe(topic) {
+			subscriptions.delete(topic);
+			topicSubscribers.get(topic)?.delete(peer);
+		},
+		getData() {
+			return data;
+		},
+		setData(value) {
+			data = value;
+		}
+	};
+	return peer;
+}
+function createRoom(name) {
+	const existing = rooms.get(name);
+	if (existing) return existing;
+	const room = new RoomImpl(name);
+	rooms.set(name, room);
+	return room;
+}
+function defineWebSocket(def) {
+	return def;
+}
+function defineRoom(name) {
+	return createRoom(name);
+}
+function getRoom(name) {
+	return rooms.get(name);
+}
+function getRooms() {
+	return rooms;
+}
+function broadcast(topic, data) {
+	const peers = topicSubscribers.get(topic);
+	if (!peers) return;
+	for (const peer of peers) if (peer.readyState === 1) try {
+		peer.send(data);
+	} catch {}
+}
+function registerWebSocket(path, def) {
+	definitions.set(path, def);
+}
+function getWebSocketDefinitions() {
+	return definitions;
+}
+function handleUpgrade(c, options) {
+	const path = new URL(c.req.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	const peer = createPeer({
+		id: generateId$1(),
+		url: c.req.url,
+		headers: c.req.raw.headers,
+		send: options.send,
+		close: options.close,
+		raw: options.raw
+	});
+	if (def?.topics) for (const topic of def.topics) peer.subscribe(topic);
+	if (def?.rooms) for (const roomName of def.rooms) createRoom(roomName).add(peer);
+	if (def?.hooks?.open) queueMicrotask(() => {
+		Promise.resolve(def.hooks.open(peer)).catch(() => {});
+	});
+	return {
+		response: new Response(null, {
+			status: 200,
+			headers: {
+				Upgrade: "websocket",
+				Connection: "Upgrade"
+			}
+		}),
+		peer
+	};
+}
+function handleMessage(peer, message) {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	if (def?.hooks?.message) Promise.resolve(def.hooks.message(peer, message)).catch(() => {});
+}
+function handleClose(peer, code = 1e3, reason = "") {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	const internal = peer;
+	for (const topic of internal._subscriptions) topicSubscribers.get(topic)?.delete(peer);
+	for (const roomName of internal._rooms) rooms.get(roomName)?.remove(peer);
+	internal._subscriptions.clear();
+	if (def?.hooks?.close) Promise.resolve(def.hooks.close(peer, code, reason)).catch(() => {});
+}
+function handleError(peer, error) {
+	const path = new URL(peer.url).pathname;
+	const def = definitions.get(path) || definitions.get("/*");
+	if (def?.hooks?.error) Promise.resolve(def.hooks.error(peer, error)).catch(() => {});
+}
+function createWebSocketMiddleware() {
+	return async function wsMiddleware(c, next) {
+		if (c.req.header("upgrade")?.toLowerCase() !== "websocket") {
+			await next();
+			return;
+		}
+		const path = new URL(c.req.url).pathname;
+		if (!definitions.get(path)) {
+			await next();
+			return;
+		}
+		return new Response("WebSocket upgrade requires platform-specific handler", { status: 426 });
+	};
+}
+function clearWebSocketState() {
+	rooms.clear();
+	topicSubscribers.clear();
+	definitions.clear();
+	peerIdSeed.value = 0;
+}
+//#endregion
+//#region src/sse.ts
+const connections = /* @__PURE__ */ new Map();
+let idSeed = 0;
+function generateId() {
+	idSeed++;
+	return `sse_${Date.now().toString(36)}_${idSeed.toString(36)}`;
+}
+function formatSSEMessage(msg) {
+	const lines = [];
+	if (msg.comment) for (const line of msg.comment.split("\n")) lines.push(`: ${line}`);
+	if (msg.id != null) lines.push(`id: ${msg.id}`);
+	if (msg.event) lines.push(`event: ${msg.event}`);
+	if (msg.retry != null) lines.push(`retry: ${msg.retry}`);
+	if (msg.data != null) {
+		const data = typeof msg.data === "string" ? msg.data : JSON.stringify(msg.data);
+		for (const line of data.split("\n")) lines.push(`data: ${line}`);
+	}
+	return `${lines.join("\n")}\n\n`;
+}
+var SSEConnectionImpl = class {
+	id;
+	writer = null;
+	encoder = new TextEncoder();
+	_closed = false;
+	keepAliveTimer = null;
+	onCloseCb;
+	constructor(writer, options = {}, onClose) {
+		this.id = generateId();
+		this.writer = writer;
+		this.onCloseCb = onClose;
+		if (options.keepAlive !== false) {
+			const interval = typeof options.keepAlive === "number" ? options.keepAlive : 3e4;
+			this.keepAliveTimer = setInterval(() => {
+				if (!this._closed) this.comment("keep-alive");
+			}, interval);
+		}
+		connections.set(this.id, this);
+	}
+	get closed() {
+		return this._closed;
+	}
+	send(msg) {
+		if (this._closed || !this.writer) return;
+		const raw = formatSSEMessage(msg);
+		this.writer.write(this.encoder.encode(raw)).catch(() => this._cleanup());
+	}
+	sendData(data, event) {
+		this.send({
+			data,
+			event
+		});
+	}
+	comment(text) {
+		if (this._closed || !this.writer) return;
+		try {
+			const raw = `: ${text}\n\n`;
+			this.writer.write(this.encoder.encode(raw)).catch(() => this._cleanup());
+		} catch {
+			this._cleanup();
+		}
+	}
+	close() {
+		this._cleanup();
+	}
+	_cleanup() {
+		if (this._closed) return;
+		this._closed = true;
+		if (this.keepAliveTimer) {
+			clearInterval(this.keepAliveTimer);
+			this.keepAliveTimer = null;
+		}
+		if (this.writer) {
+			try {
+				this.writer.close();
+			} catch {}
+			this.writer = null;
+		}
+		connections.delete(this.id);
+		if (this.onCloseCb) {
+			try {
+				Promise.resolve(this.onCloseCb(this)).catch(() => {});
+			} catch {}
+			this.onCloseCb = void 0;
+		}
+	}
+};
+function createSSEStream(c, handler, options = {}) {
+	const { readable, writable } = new TransformStream();
+	const writer = writable.getWriter();
+	const headers = {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no",
+		...options.headers
+	};
+	const connection = new SSEConnectionImpl(writer, options, handler.onClose);
+	if (options.retry != null) connection.send({ retry: options.retry });
+	queueMicrotask(() => {
+		Promise.resolve(handler.onConnect?.(connection)).catch(() => {});
+	});
+	return new Response(readable, { headers });
+}
+function defineSSE(handler, options) {
+	return (async (c) => {
+		return createSSEStream(c, handler, options);
+	});
+}
+function getSSEConnections() {
+	return connections;
+}
+function broadcastSSE(event, data, filter) {
+	for (const conn of connections.values()) if (!conn.closed && (!filter || filter(conn))) conn.sendData(data, event);
+}
+function closeAllSSE() {
+	for (const conn of Array.from(connections.values())) conn.close();
+	connections.clear();
+}
+function sseHeaders() {
+	return {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no"
+	};
+}
+function clearSSEState() {
+	closeAllSSE();
+	idSeed = 0;
+}
+//#endregion
+//#region src/storage.ts
+function createMemoryDriver() {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		async getItemRaw(key) {
+			return store.get(key);
+		},
+		async setItemRaw(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const prefix = base || "";
+			return Array.from(store.keys()).filter((k) => k.startsWith(prefix));
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of Array.from(store.keys())) if (key.startsWith(base)) store.delete(key);
+		},
+		async hasItem(key) {
+			return store.has(key);
+		}
+	};
+}
+function createStorage(options = {}) {
+	const mounts = /* @__PURE__ */ new Map();
+	const rootDriver = options.driver || createMemoryDriver();
+	const rootBase = options.base ? `${options.base.replace(/\/$/, "")}:` : "";
+	function resolveKey(key) {
+		const fullKey = rootBase + key;
+		let bestMatch = "";
+		let bestDriver = rootDriver;
+		for (const [base, driver] of mounts) if (fullKey.startsWith(`${base}:`) && base.length > bestMatch.length) {
+			bestMatch = base;
+			bestDriver = driver;
+		}
+		const relativeKey = bestMatch ? fullKey.slice(bestMatch.length + 1) : fullKey;
+		return {
+			driver: bestDriver,
+			relativeKey
+		};
+	}
+	async function getEntry(key) {
+		const { driver, relativeKey } = resolveKey(key);
+		const raw = await driver.getItemRaw(relativeKey);
+		if (raw === void 0 || raw === null) return null;
+		const entry = raw;
+		if (entry.expiresAt && Date.now() > entry.expiresAt) {
+			await driver.removeItem(relativeKey);
+			return null;
+		}
+		return entry;
+	}
+	return {
+		async get(key) {
+			const entry = await getEntry(key);
+			return entry ? entry.value : null;
+		},
+		async set(key, value, ttl) {
+			const { driver, relativeKey } = resolveKey(key);
+			const entry = {
+				value,
+				createdAt: Date.now(),
+				expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+			};
+			await driver.setItemRaw(relativeKey, entry);
+		},
+		async remove(key) {
+			const { driver, relativeKey } = resolveKey(key);
+			await driver.removeItem(relativeKey);
+		},
+		async keys(base) {
+			const prefix = base || "";
+			const rootPrefix = rootBase;
+			const results = /* @__PURE__ */ new Set();
+			const rootKeys = await rootDriver.getKeys(rootPrefix);
+			for (const k of rootKeys) {
+				const stripped = k.slice(rootPrefix.length);
+				if (!prefix || stripped.startsWith(prefix)) results.add(stripped);
+			}
+			return Array.from(results);
+		},
+		async clear(base) {
+			const rootPrefix = rootBase + (base || "");
+			const rootKeys = await rootDriver.getKeys(rootPrefix);
+			for (const k of rootKeys) await rootDriver.removeItem(k);
+		},
+		async has(key) {
+			return await getEntry(key) !== null;
+		},
+		async getMeta(key) {
+			const entry = await getEntry(key);
+			if (!entry) return null;
+			return {
+				ttl: entry.expiresAt ? Math.max(0, Math.floor((entry.expiresAt - Date.now()) / 1e3)) : void 0,
+				createdAt: entry.createdAt,
+				expiresAt: entry.expiresAt
+			};
+		},
+		mount(base, driver) {
+			mounts.set(rootBase + base.replace(/\/$/, ""), driver);
+		}
+	};
+}
+let globalStorage = null;
+function useStorage(storage) {
+	if (storage) {
+		globalStorage = storage;
+		return storage;
+	}
+	if (!globalStorage) globalStorage = createStorage();
+	return globalStorage;
+}
+function clearGlobalStorage() {
+	globalStorage = null;
+}
+function createKV(options = {}) {
+	const storage = useStorage();
+	const prefix = options.prefix || "kv:default";
+	const serialize = options.serialize || ((v) => JSON.stringify(v));
+	const deserialize = options.deserialize || ((raw) => JSON.parse(raw));
+	const fullKey = (key) => `${prefix}:${key}`;
+	return {
+		async get(key) {
+			const raw = await storage.get(fullKey(key));
+			if (raw === null) return null;
+			return deserialize(raw);
+		},
+		async set(key, value, ttl) {
+			await storage.set(fullKey(key), serialize(value), ttl ?? options.ttl);
+		},
+		async remove(key) {
+			await storage.remove(fullKey(key));
+		},
+		async keys() {
+			return (await storage.keys(prefix)).map((k) => k.slice(prefix.length + 1)).filter((k) => k.length > 0);
+		},
+		async has(key) {
+			return storage.has(fullKey(key));
+		},
+		async clear() {
+			await storage.clear(prefix);
+		}
+	};
+}
+const namespaces = /* @__PURE__ */ new Map();
+function useKV(name = "default", options) {
+	if (namespaces.has(name)) return namespaces.get(name);
+	const ns = createKV({
+		...options,
+		prefix: `kv:${name}`
+	});
+	namespaces.set(name, ns);
+	return ns;
+}
+//#endregion
+//#region src/observability.ts
+const REQUEST_ID_HEADER = "x-request-id";
+function generateRequestId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function getRequestId(c) {
+	return c.get("requestId");
+}
+function generateSpanId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+	return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function generateTraceId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID().replace(/-/g, "") + crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+	return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function createSpan(options) {
+	let ended = false;
+	const ctx = {
+		traceId: generateTraceId(),
+		spanId: generateSpanId()
+	};
+	if (options.parent) if ("context" in options.parent) {
+		ctx.traceId = options.parent.context.traceId;
+		ctx.parentSpanId = options.parent.context.spanId;
+	} else {
+		ctx.traceId = options.parent.traceId;
+		ctx.parentSpanId = options.parent.spanId;
+	}
+	const span = {
+		name: options.name,
+		context: ctx,
+		startTime: Date.now(),
+		status: "ok",
+		attributes: { ...options.attributes },
+		events: [],
+		parent: options.parent && "context" in options.parent ? options.parent : void 0,
+		end(opts) {
+			if (ended) return;
+			ended = true;
+			span.endTime = Date.now();
+			if (opts?.status) span.status = opts.status;
+			if (opts?.attributes) Object.assign(span.attributes, opts.attributes);
+			if (opts?.error) {
+				span.error = opts.error;
+				span.status = "error";
+			}
+		},
+		setAttribute(key, value) {
+			if (!ended) span.attributes[key] = value;
+		},
+		setAttributes(attrs) {
+			if (!ended) Object.assign(span.attributes, attrs);
+		},
+		addEvent(name, attributes) {
+			if (!ended) span.events.push({
+				name,
+				timestamp: Date.now(),
+				attributes
+			});
+		},
+		isRecording() {
+			return !ended;
+		},
+		duration() {
+			if (span.endTime === void 0) return void 0;
+			return span.endTime - span.startTime;
+		}
+	};
+	return span;
+}
+function createObservabilityTracer(config = {}) {
+	const hooks = createHooks();
+	const exporters = [...config.exporters || []];
+	const sensitiveKeys = new Set((config.sensitiveKeys || [
+		"password",
+		"passwd",
+		"secret",
+		"token",
+		"authorization",
+		"api_key",
+		"apikey",
+		"access_token",
+		"refresh_token",
+		"private_key",
+		"credit_card",
+		"ssn",
+		"auth"
+	]).map((k) => k.toLowerCase()));
+	const enabled = config.enabled !== false;
+	function addExporter(exporter) {
+		exporters.push(exporter);
+	}
+	function removeExporter(name) {
+		const idx = exporters.findIndex((e) => e.name === name);
+		if (idx >= 0) exporters.splice(idx, 1);
+	}
+	function redactAttributes(attrs) {
+		const result = {};
+		for (const [key, value] of Object.entries(attrs)) if (sensitiveKeys.has(key.toLowerCase())) result[key] = "[REDACTED]";
+		else if (typeof value === "string" && value.length > 2048) result[key] = `${value.slice(0, 2048)}...[truncated]`;
+		else result[key] = value;
+		return result;
+	}
+	function startTracedSpan(options) {
+		if (!enabled) return createSpan(options);
+		const span = createSpan({
+			...options,
+			attributes: {
+				...config.defaultAttributes,
+				...options.attributes
+			}
+		});
+		hooks.callHook("span:start", span);
+		const originalEnd = span.end.bind(span);
+		span.end = function(opts) {
+			if (opts?.attributes) opts.attributes = redactAttributes(opts.attributes);
+			span.attributes = redactAttributes(span.attributes);
+			originalEnd(opts);
+			hooks.callHook("span:end", span);
+			if (span.error) hooks.callHook("span:error", span, span.error);
+			for (const exporter of exporters) try {
+				exporter.exportSpan(span);
+			} catch {}
+		};
+		return span;
+	}
+	async function tracedWithSpan(options, fn) {
+		const span = startTracedSpan(typeof options === "string" ? { name: options } : options);
+		try {
+			const result = await fn(span);
+			span.end();
+			return result;
+		} catch (err) {
+			span.end({
+				error: err instanceof Error ? err : new Error(String(err)),
+				status: "error"
+			});
+			throw err;
+		}
+	}
+	function getActiveSpan() {}
+	async function flush() {
+		await Promise.all(exporters.map((e) => e.flush?.()));
+	}
+	async function shutdown() {
+		await flush();
+		await Promise.all(exporters.map((e) => e.shutdown?.()));
+	}
+	return {
+		hooks,
+		startSpan: startTracedSpan,
+		withSpan: tracedWithSpan,
+		getActiveSpan,
+		addExporter,
+		removeExporter,
+		redactAttributes,
+		flush,
+		shutdown,
+		createSpan
+	};
+}
+let globalTracer = null;
+function setGlobalTracer(tracer) {
+	globalTracer = tracer;
+}
+function getGlobalTracer() {
+	if (!globalTracer) globalTracer = createObservabilityTracer();
+	return globalTracer;
+}
+function startSpan(options) {
+	return getGlobalTracer().startSpan(typeof options === "string" ? { name: options } : options);
+}
+function withSpan(options, fn) {
+	return getGlobalTracer().withSpan(options, fn);
+}
+function createOpenTelemetryExporter(options = {}) {
+	const url = options.url || "http://localhost:4318/v1/traces";
+	const headers = options.headers || {};
+	const serviceName = options.serviceName || "ubean-app";
+	const serviceVersion = options.serviceVersion || "0.0.0";
+	const fetchImpl = options.fetchImpl || (typeof fetch !== "undefined" ? fetch : void 0);
+	const batch = [];
+	let batchTimer = null;
+	const BATCH_SIZE = 512;
+	const FLUSH_INTERVAL = 5e3;
+	function spanToOTLP(span) {
+		const attributes = [];
+		for (const [k, v] of Object.entries(span.attributes)) {
+			if (v === void 0 || v === null) continue;
+			attributes.push({
+				key: k,
+				value: typeof v === "string" ? { stringValue: v } : typeof v === "number" ? { intValue: String(Math.floor(v)) } : typeof v === "boolean" ? { boolValue: v } : { stringValue: String(v) }
+			});
+		}
+		const events = span.events.map((e) => ({
+			timeUnixNano: e.timestamp * 1e6,
+			name: e.name,
+			attributes: e.attributes ? Object.entries(e.attributes).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => ({
+				key: k,
+				value: typeof v === "string" ? { stringValue: v } : typeof v === "number" ? { intValue: String(Math.floor(v)) } : { stringValue: String(v) }
+			})) : []
+		}));
+		return {
+			traceId: span.context.traceId,
+			spanId: span.context.spanId,
+			parentSpanId: span.context.parentSpanId || "",
+			name: span.name,
+			kind: "SPAN_KIND_INTERNAL",
+			startTimeUnixNano: span.startTime * 1e6,
+			endTimeUnixNano: (span.endTime || Date.now()) * 1e6,
+			attributes,
+			events,
+			status: span.status === "error" ? {
+				code: "STATUS_CODE_ERROR",
+				message: span.error?.message || ""
+			} : { code: "STATUS_CODE_OK" },
+			droppedAttributesCount: 0,
+			droppedEventsCount: 0
+		};
+	}
+	async function exportBatch() {
+		if (batch.length === 0 || !fetchImpl) return;
+		const spans = batch.splice(0, BATCH_SIZE);
+		try {
+			await fetchImpl(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...headers
+				},
+				body: JSON.stringify({ resourceSpans: [{
+					resource: { attributes: [{
+						key: "service.name",
+						value: { stringValue: serviceName }
+					}, {
+						key: "service.version",
+						value: { stringValue: serviceVersion }
+					}] },
+					scopeSpans: [{
+						scope: { name: "ubean" },
+						spans
+					}]
+				}] })
+			});
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (batchTimer) return;
+		batchTimer = setTimeout(() => {
+			batchTimer = null;
+			exportBatch();
+		}, FLUSH_INTERVAL);
+	}
+	return {
+		name: "opentelemetry",
+		exportSpan(span) {
+			batch.push(spanToOTLP(span));
+			if (batch.length >= BATCH_SIZE) exportBatch();
+			else scheduleFlush();
+		},
+		async flush() {
+			while (batch.length > 0) await exportBatch();
+		},
+		async shutdown() {
+			if (batchTimer) {
+				clearTimeout(batchTimer);
+				batchTimer = null;
+			}
+			await this.flush?.();
+		}
+	};
+}
+function createConsoleExporter(options = {}) {
+	const slowThreshold = options.slowThreshold ?? 1e3;
+	return {
+		name: "console",
+		exportSpan(span) {
+			const duration = span.duration() ?? 0;
+			const status = span.status === "error" ? "✗" : span.status === "cancelled" ? "○" : "✓";
+			const slow = duration >= slowThreshold ? " (slow)" : "";
+			const errMsg = span.error ? ` — ${span.error.message}` : "";
+			if (!(typeof globalThis.console !== "undefined")) return;
+			const msg = `${status} [${duration}ms] ${span.name}${slow}${errMsg}`;
+			if (span.status === "error") console.error(msg);
+			else if (slow) console.warn(msg);
+			else console.debug(msg);
+		}
+	};
+}
+function createTracingMiddleware(options = {}) {
+	const tracer = options.tracer || getGlobalTracer();
+	const headerFilter = options.headerFilter || (() => false);
+	const includeHeaders = options.includeHeaders ?? false;
+	return async function tracingMiddleware(c, next) {
+		const method = c.req.method || "GET";
+		const path = c.req.path || "/";
+		const requestId = getRequestId(c);
+		const span = tracer.startSpan({
+			name: `${method} ${path}`,
+			attributes: {
+				"http.method": method,
+				"http.url": path,
+				"http.request_id": requestId
+			}
+		});
+		c.set("span", span);
+		if (includeHeaders) {
+			const headers = {};
+			for (const [k, v] of Object.entries(c.req.header?.() || {})) if (!headerFilter(k)) headers[k] = v;
+			span.setAttributes(tracer.redactAttributes(headers));
+		}
+		const start = Date.now();
+		try {
+			await next();
+			const statusCode = c.res?.status || 200;
+			span.setAttribute("http.status_code", statusCode);
+			if (statusCode >= 500) span.end({ status: "error" });
+			else span.end({ status: statusCode >= 400 ? "error" : "ok" });
+		} catch (err) {
+			const duration = Date.now() - start;
+			span.setAttribute("error.duration_ms", duration);
+			span.end({
+				error: err instanceof Error ? err : new Error(String(err)),
+				status: "error"
+			});
+			throw err;
+		}
+	};
+}
+function getSpan(c) {
+	return c.get("span");
+}
+//#endregion
+//#region src/static.ts
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".htm": "text/html; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".mjs": "application/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".avif": "image/avif",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".eot": "application/vnd.ms-fontobject",
+	".txt": "text/plain; charset=utf-8",
+	".xml": "application/xml; charset=utf-8",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".gz": "application/gzip",
+	".mp3": "audio/mpeg",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".wasm": "application/wasm",
+	".map": "application/json; charset=utf-8"
+};
+function getMimeType(filePath) {
+	const ext = extname(filePath).toLowerCase();
+	return MIME_TYPES[ext] || "application/octet-stream";
+}
+function serveStatic(options) {
+	const { publicDir, indexFiles = ["index.html"], maxAge = 3600 } = options;
+	return async (c, next) => {
+		const path = decodeURIComponent(c.req.path);
+		if (path.startsWith("/_") || path.startsWith("/api/")) return next();
+		let filePath = join(publicDir, path);
+		try {
+			if (!existsSync(filePath)) {
+				if (path.endsWith("/")) for (const indexFile of indexFiles) {
+					const indexPath = join(filePath, indexFile);
+					if (existsSync(indexPath) && statSync(indexPath).isFile()) {
+						filePath = indexPath;
+						break;
+					}
+				}
+				if (!existsSync(filePath) || !statSync(filePath).isFile()) return next();
+			}
+			if (statSync(filePath).isDirectory()) for (const indexFile of indexFiles) {
+				const indexPath = join(filePath, indexFile);
+				if (existsSync(indexPath) && statSync(indexPath).isFile()) {
+					filePath = indexPath;
+					break;
+				}
+			}
+			if (!existsSync(filePath) || statSync(filePath).isDirectory()) return next();
+			const finalStat = statSync(filePath);
+			const mimeType = getMimeType(filePath);
+			const body = readFileSync(filePath);
+			const headers = {
+				"Content-Type": mimeType,
+				"Content-Length": String(body.length),
+				"Cache-Control": `public, max-age=${maxAge}`,
+				"X-Content-Type-Options": "nosniff"
+			};
+			const ifNoneMatch = c.req.header("If-None-Match");
+			const etag = `"${finalStat.size.toString(16)}-${finalStat.mtimeMs.toString(16)}"`;
+			if (ifNoneMatch === etag) return new Response(null, {
+				status: 304,
+				headers
+			});
+			headers.ETag = etag;
+			return new Response(body, {
+				status: 200,
+				headers
+			});
+		} catch {
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/cors.ts
+const DEFAULT_METHODS = [
+	"GET",
+	"HEAD",
+	"PUT",
+	"POST",
+	"DELETE",
+	"PATCH",
+	"OPTIONS"
+];
+const DEFAULT_HEADERS = [
+	"Content-Type",
+	"Authorization",
+	"X-Requested-With",
+	"Accept",
+	"Origin"
+];
+function isPreflight(c) {
+	return c.req.method === "OPTIONS" && !!c.req.header("origin") && !!c.req.header("access-control-request-method");
+}
+function configureOrigin(c, option, requestOrigin) {
+	if (option === true || option === void 0 || option === "*") return "*";
+	if (option === false) return null;
+	if (typeof option === "string") return option;
+	if (Array.isArray(option)) {
+		if (option.includes(requestOrigin) || option.includes("*")) return requestOrigin;
+		return null;
+	}
+	if (typeof option === "function") return null;
+	return null;
+}
+function createCorsMiddleware(options = {}) {
+	const { origin = "*", allowMethods = DEFAULT_METHODS, allowHeaders, exposeHeaders = [], credentials = false, maxAge, preflightContinue = false } = options;
+	const resolvedAllowHeaders = allowHeaders?.length ? allowHeaders : DEFAULT_HEADERS;
+	return async function corsMiddleware(c, next) {
+		const requestOrigin = c.req.header("origin") || "";
+		let originValue = null;
+		if (typeof origin === "function") {
+			const result = await origin(requestOrigin, c);
+			if (result === true || result === void 0) originValue = requestOrigin;
+			else if (result === false) originValue = null;
+			else if (typeof result === "string") originValue = result;
+		} else originValue = configureOrigin(c, origin, requestOrigin);
+		if (originValue) {
+			c.header("Access-Control-Allow-Origin", originValue);
+			if (originValue !== "*" || credentials) c.header("Vary", "Origin");
+		}
+		if (credentials) c.header("Access-Control-Allow-Credentials", "true");
+		if (exposeHeaders.length > 0) c.header("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+		if (isPreflight(c)) {
+			const preflightHeaders = {};
+			if (originValue) preflightHeaders["Access-Control-Allow-Origin"] = originValue;
+			if (credentials) preflightHeaders["Access-Control-Allow-Credentials"] = "true";
+			preflightHeaders["Access-Control-Allow-Methods"] = allowMethods.join(", ");
+			preflightHeaders["Access-Control-Allow-Headers"] = resolvedAllowHeaders.join(", ");
+			if (maxAge != null) preflightHeaders["Access-Control-Max-Age"] = String(maxAge);
+			if (originValue && originValue !== "*") preflightHeaders["Vary"] = "Origin";
+			if (!preflightContinue) return new Response(null, {
+				status: 204,
+				headers: preflightHeaders
+			});
+		}
+		await next();
+	};
+}
+function defineCors(options) {
+	return createCorsMiddleware(options);
+}
+//#endregion
+//#region src/rate-limit.ts
+var MemoryRateLimitStore = class {
+	store = /* @__PURE__ */ new Map();
+	timer = null;
+	constructor() {
+		this.timer = setInterval(() => this._cleanup(), 6e4);
+	}
+	_cleanup() {
+		const now = Date.now();
+		for (const [key, entry] of this.store.entries()) if (entry.expireAt <= now) this.store.delete(key);
+	}
+	async get(key) {
+		const entry = this.store.get(key);
+		if (!entry || entry.expireAt <= Date.now()) {
+			if (entry) this.store.delete(key);
+			return;
+		}
+		return {
+			count: entry.count,
+			resetAt: entry.resetAt
+		};
+	}
+	async set(key, entry, ttlMs) {
+		this.store.set(key, {
+			...entry,
+			expireAt: Date.now() + ttlMs
+		});
+	}
+	async increment(key, windowMs) {
+		const now = Date.now();
+		const existing = this.store.get(key);
+		if (!existing || existing.resetAt <= now) {
+			const entry = {
+				count: 1,
+				resetAt: now + windowMs,
+				expireAt: now + windowMs
+			};
+			this.store.set(key, entry);
+			return {
+				count: 1,
+				resetAt: entry.resetAt
+			};
+		}
+		existing.count++;
+		return {
+			count: existing.count,
+			resetAt: existing.resetAt
+		};
+	}
+	async reset(key) {
+		this.store.delete(key);
+	}
+	destroy() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+		this.store.clear();
+	}
+};
+function defaultKeyGenerator(c) {
+	const forwarded = c.req.header("x-forwarded-for");
+	if (forwarded) return forwarded.split(",")[0].trim();
+	const realIp = c.req.header("x-real-ip");
+	if (realIp) return realIp;
+	return c.req.raw.headers.get("cf-connecting-ip") || "unknown";
+}
+function defaultHandler(c, info) {
+	c.header("Retry-After", String(Math.ceil(info.retryAfter / 1e3)));
+	return c.json({
+		error: "Too Many Requests",
+		message: `Rate limit exceeded. Try again in ${Math.ceil(info.retryAfter / 1e3)} seconds.`,
+		limit: info.limit,
+		remaining: info.remaining,
+		reset: info.reset
+	}, 429);
+}
+function createRateLimitMiddleware(options = {}) {
+	const { maxRequests = 100, windowMs = 6e4, keyGenerator = defaultKeyGenerator, handler = defaultHandler, skip, standardHeaders = true, legacyHeaders = false, store: customStore } = options;
+	const store = customStore || new MemoryRateLimitStore();
+	return async function rateLimitMiddleware(c, next) {
+		if (skip && await skip(c)) {
+			await next();
+			return;
+		}
+		const key = keyGenerator(c);
+		const result = await store.increment(key, windowMs);
+		const now = Date.now();
+		const remaining = Math.max(0, maxRequests - result.count);
+		const reset = Math.ceil(result.resetAt / 1e3);
+		const retryAfter = Math.max(0, result.resetAt - now);
+		if (standardHeaders) {
+			c.header("RateLimit-Limit", String(maxRequests));
+			c.header("RateLimit-Remaining", String(remaining));
+			c.header("RateLimit-Reset", String(reset));
+		}
+		if (legacyHeaders) {
+			c.header("X-RateLimit-Limit", String(maxRequests));
+			c.header("X-RateLimit-Remaining", String(remaining));
+			c.header("X-RateLimit-Reset", String(reset));
+		}
+		if (result.count > maxRequests) return handler(c, {
+			limit: maxRequests,
+			remaining: 0,
+			reset,
+			retryAfter
+		});
+		await next();
+	};
+}
+function defineRateLimit(options) {
+	return createRateLimitMiddleware(options);
+}
+function createMemoryRateLimitStore() {
+	return new MemoryRateLimitStore();
+}
+//#endregion
+export { REQUEST_ID_HEADER, broadcast, broadcastSSE, cachedEventHandler, clearCacheStore, clearGlobalStorage, clearQueueDefinitions, clearSSEState, clearScheduledTasks, clearWebSocketState, closeAllSSE, closeDatabases, createCacheMiddleware, createConsoleExporter, createCorsMiddleware, createCronContext, createKV, createMemoryCronScheduler, createMemoryDriver, createMemoryQueueDriver, createMemoryRateLimitStore, createMemoryStore, createObservabilityTracer, createOpenTelemetryExporter, createRateLimitMiddleware, createRoom, createSSEStream, createSpan, createStorage, createTracingMiddleware, createWebSocketMiddleware, defineCors, defineDatabase, defineQueue, defineRateLimit, defineRoom, defineSSE, defineScheduled, defineWebSocket, formatSSEMessage, generateRequestId, getAllQueueStats, getDatabaseHooks, getGlobalTracer, getQueueDefinitions, getQueueStats, getRequestId, getRoom, getRooms, getSSEConnections, getScheduledTasks, getSpan, getWebSocketDefinitions, handleClose, handleError, handleMessage, handleUpgrade, invalidateRouteCache, migrateDatabase, parseCron, rawSql as raw, rawSql, rawSql as sqlRaw, registerDb0Create, registerWebSocket, resetCronRunCounts, resolveRouteCacheRules, runMigrations, runScheduledTask, sendMessage, sendMessages, serveStatic, setGlobalTracer, setQueueDriver, sseHeaders, startCronScheduler, startQueueWorkers, startSpan, stopQueueWorkers, useCacheStore, useDatabase, useKV, useQueueDriver, useStorage, validateCron, withSpan };