silgi 0.43.29 → 0.50.0

package/dist/plugins/analytics/export.mjs

@@ -0,0 +1,86 @@
+import { redactHeaderValue, round, safeStringify } from "./utils.mjs";
+//#region src/plugins/analytics/export.ts
+/**
+* Markdown export for analytics entries.
+*/
+function errorToMarkdown(e) {
+	const time = new Date(e.timestamp).toISOString();
+	const inputJson = safeStringify(e.input);
+	let md = `## Error in \`${e.procedure}\`\n\n`;
+	md += `**Time:** ${time}  \n`;
+	md += `**Error:** ${e.code}  \n`;
+	md += `**Status:** ${e.status}  \n`;
+	md += `**Duration:** ${e.durationMs}ms\n\n`;
+	if (e.input !== void 0) md += `### Input\n\n\`\`\`json\n${inputJson}\n\`\`\`\n\n`;
+	if (e.stack) md += `### Stack Trace\n\n\`\`\`\n${e.stack}\n\`\`\`\n\n`;
+	if (Object.keys(e.headers).length > 0) {
+		md += `### Request Headers\n\n`;
+		for (const [k, v] of Object.entries(e.headers)) md += `- \`${k}\`: \`${redactHeaderValue(k, v)}\`\n`;
+		md += "\n";
+	}
+	if (e.spans.length > 0) {
+		md += `### Traced Operations\n\n`;
+		for (let i = 0; i < e.spans.length; i++) {
+			const s = e.spans[i];
+			const errMark = s.error ? ` ❌ ${s.error}` : "";
+			md += `**${i + 1}. [${s.kind}] ${s.name}** — ${s.durationMs}ms${errMark}\n`;
+			if (s.detail) md += `\`\`\`\n${s.detail}\n\`\`\`\n`;
+		}
+		md += "\n";
+	}
+	md += `### Error Message\n\n\`\`\`\n${e.error}\n\`\`\``;
+	return md;
+}
+function requestToMarkdown(r) {
+	const time = new Date(r.timestamp).toISOString();
+	let md = `## ${r.status >= 500 ? "💥" : r.status >= 400 ? "⚠️" : "✅"} ${r.method} ${r.path} → ${r.status} (${r.durationMs}ms)\n\n`;
+	md += `| Field | Value |\n|-------|-------|\n`;
+	md += `| Request ID | \`${r.requestId}\` |\n`;
+	md += `| Session ID | \`${r.sessionId}\` |\n`;
+	md += `| Method | ${r.method} |\n`;
+	md += `| URL | \`${r.url}\` |\n`;
+	md += `| Path | \`${r.path}\` |\n`;
+	md += `| Status | ${r.status} |\n`;
+	md += `| Duration | ${r.durationMs}ms |\n`;
+	md += `| Time | ${time} |\n`;
+	md += `| IP | ${r.ip} |\n`;
+	md += `| Procedures | ${r.procedures.length} |\n`;
+	if (r.isBatch) md += `| Batch | Yes |\n`;
+	md += "\n";
+	for (let i = 0; i < r.procedures.length; i++) {
+		const p = r.procedures[i];
+		const pEmoji = p.status >= 400 ? "⚠️" : "✅";
+		md += `### ${pEmoji} ${i + 1}. \`${p.procedure}\` → ${p.status} (${p.durationMs}ms)\n\n`;
+		if (p.input !== void 0 && p.input !== null) md += `#### Input\n\n\`\`\`json\n${safeStringify(p.input)}\n\`\`\`\n\n`;
+		if (p.output !== void 0 && p.output !== null) md += `#### Output\n\n\`\`\`json\n${safeStringify(p.output)}\n\`\`\`\n\n`;
+		if (p.spans.length > 0) {
+			const byKind = /* @__PURE__ */ new Map();
+			for (const s of p.spans) byKind.set(s.kind, (byKind.get(s.kind) ?? 0) + s.durationMs);
+			const tracedMs = [...byKind.values()].reduce((a, b) => a + b, 0);
+			const appMs = Math.max(0, p.durationMs - tracedMs);
+			const total = Math.max(p.durationMs, .1);
+			md += `#### Timing\n\n| Category | Duration | % |\n|----------|----------|---|\n`;
+			md += `| **Total** | **${p.durationMs}ms** | 100% |\n`;
+			for (const [kind, ms] of byKind) md += `| ${kind} | ${round(ms)}ms | ${round(ms / total * 100)}% |\n`;
+			md += `| App Logic | ${round(appMs)}ms | ${round(appMs / total * 100)}% |\n\n`;
+			for (let j = 0; j < p.spans.length; j++) {
+				const s = p.spans[j];
+				const offset = s.startOffsetMs != null ? ` (at +${s.startOffsetMs}ms)` : "";
+				const err = s.error ? ` ❌ ${s.error}` : "";
+				md += `**${j + 1}. [${s.kind}] ${s.name}** — ${s.durationMs}ms${offset}${err}\n`;
+				if (s.detail) md += `\`\`\`\n${s.detail}\n\`\`\`\n`;
+			}
+			md += "\n";
+		}
+		if (p.error) md += `#### Error\n\n\`\`\`\n${p.error}\n\`\`\`\n\n`;
+	}
+	md += `---\n\n**Analyze this request and suggest performance optimizations:**\n`;
+	md += `- Redundant or slow operations that could be combined?\n`;
+	md += `- N+1 query pattern?\n`;
+	md += `- Data that should be cached?\n`;
+	md += `- Sequential calls that could run in parallel?\n`;
+	if (r.durationMs > 100) md += `- ⚠️ This request took ${r.durationMs}ms — what is the bottleneck?\n`;
+	return md;
+}
+//#endregion
+export { errorToMarkdown, requestToMarkdown };

package/dist/plugins/analytics/normalize.mjs

@@ -0,0 +1,144 @@
+import { asRecord } from "./utils.mjs";
+//#region src/plugins/analytics/normalize.ts
+/**
+* Normalization functions for analytics data from storage.
+*
+* All data read from persistent storage passes through these functions
+* to ensure type safety and handle schema evolution.
+*/
+function normalizeString(value, fallback = "") {
+	return typeof value === "string" ? value : fallback;
+}
+function normalizeNumber(value, fallback = 0) {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizeBoolean(value, fallback = false) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function normalizeStringMap(value) {
+	const record = asRecord(value);
+	if (!record) return {};
+	const result = {};
+	for (const [key, raw] of Object.entries(record)) if (typeof raw === "string") result[key] = raw;
+	return result;
+}
+function normalizeSpanKind(value) {
+	switch (value) {
+		case "db":
+		case "http":
+		case "cache":
+		case "queue":
+		case "email":
+		case "ai":
+		case "custom": return value;
+		default: return "custom";
+	}
+}
+function normalizeTraceSpans(value) {
+	if (!Array.isArray(value)) return [];
+	const spans = [];
+	for (const entry of value) {
+		const span = asRecord(entry);
+		if (!span) continue;
+		const attributes = asRecord(span.attributes);
+		const normalizedAttributes = {};
+		if (attributes) {
+			for (const [key, raw] of Object.entries(attributes)) if (typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean") normalizedAttributes[key] = raw;
+		}
+		spans.push({
+			name: normalizeString(span.name, "unknown"),
+			kind: normalizeSpanKind(span.kind),
+			durationMs: normalizeNumber(span.durationMs),
+			startOffsetMs: typeof span.startOffsetMs === "number" ? span.startOffsetMs : void 0,
+			detail: typeof span.detail === "string" ? span.detail : void 0,
+			input: span.input,
+			output: span.output,
+			error: typeof span.error === "string" ? span.error : void 0,
+			attributes: Object.keys(normalizedAttributes).length > 0 ? normalizedAttributes : void 0
+		});
+	}
+	return spans;
+}
+function inferPathFromUrl(url) {
+	if (!url) return "";
+	try {
+		return new URL(url).pathname || "";
+	} catch {
+		return "";
+	}
+}
+function normalizeProcedureCall(value, fallback) {
+	const record = asRecord(value);
+	return {
+		procedure: normalizeString(record?.procedure, fallback.path.replace(/^\//, "") || fallback.path || "request"),
+		durationMs: normalizeNumber(record?.durationMs, fallback.durationMs),
+		status: normalizeNumber(record?.status, fallback.status),
+		input: record?.input ?? null,
+		output: record?.output ?? null,
+		spans: normalizeTraceSpans(record?.spans),
+		error: typeof record?.error === "string" ? record.error : void 0
+	};
+}
+function normalizeRequestEntry(value, fallbackId) {
+	const record = asRecord(value);
+	if (!record) return null;
+	const url = normalizeString(record.url);
+	const path = normalizeString(record.path, inferPathFromUrl(url));
+	const method = normalizeString(record.method, "GET");
+	const status = normalizeNumber(record.status, 200);
+	const durationMs = normalizeNumber(record.durationMs);
+	const procedureFallback = {
+		path: path || "/",
+		durationMs,
+		status
+	};
+	const proceduresRaw = Array.isArray(record.procedures) ? record.procedures : [];
+	const procedures = proceduresRaw.length > 0 ? proceduresRaw.map((entry) => normalizeProcedureCall(entry, procedureFallback)) : [normalizeProcedureCall(null, procedureFallback)];
+	return {
+		id: normalizeNumber(record.id, fallbackId),
+		requestId: normalizeString(record.requestId, String(normalizeNumber(record.id, fallbackId))),
+		sessionId: normalizeString(record.sessionId),
+		timestamp: normalizeNumber(record.timestamp),
+		durationMs,
+		method,
+		url: url || path,
+		path,
+		ip: normalizeString(record.ip),
+		headers: normalizeStringMap(record.headers),
+		responseHeaders: normalizeStringMap(record.responseHeaders),
+		userAgent: normalizeString(record.userAgent),
+		status,
+		procedures,
+		isBatch: normalizeBoolean(record.isBatch, procedures.length > 1),
+		traceId: normalizeString(record.traceId) || void 0,
+		parentRequestId: normalizeString(record.parentRequestId) || void 0
+	};
+}
+function normalizeErrorEntry(value, fallbackId) {
+	const record = asRecord(value);
+	if (!record) return null;
+	return {
+		id: normalizeNumber(record.id, fallbackId),
+		requestId: normalizeString(record.requestId),
+		timestamp: normalizeNumber(record.timestamp),
+		procedure: normalizeString(record.procedure, "request"),
+		error: normalizeString(record.error, "Unknown error"),
+		code: normalizeString(record.code, "INTERNAL_SERVER_ERROR"),
+		status: normalizeNumber(record.status, 500),
+		stack: normalizeString(record.stack),
+		input: record.input ?? null,
+		headers: normalizeStringMap(record.headers),
+		durationMs: normalizeNumber(record.durationMs),
+		spans: normalizeTraceSpans(record.spans)
+	};
+}
+function normalizeRequestEntries(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry, index) => normalizeRequestEntry(entry, index + 1)).filter((entry) => entry !== null);
+}
+function normalizeErrorEntries(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry, index) => normalizeErrorEntry(entry, index + 1)).filter((entry) => entry !== null);
+}
+//#endregion
+export { normalizeErrorEntries, normalizeRequestEntries };

package/dist/plugins/analytics/query.mjs

@@ -0,0 +1,164 @@
+//#region src/plugins/analytics/query.ts
+function parseQueryParams(params) {
+	const q = {};
+	const cursor = params.get("cursor");
+	if (cursor) q.cursor = Number(cursor);
+	const before = params.get("before");
+	if (before) q.before = Number(before);
+	const limit = params.get("limit");
+	q.limit = limit ? Math.max(1, Number(limit)) : 50;
+	q.sort = params.get("sort") ?? void 0;
+	q.order = params.get("order") ?? void 0;
+	q.status = params.get("status") ?? void 0;
+	q.path = params.get("path") ?? void 0;
+	q.search = params.get("search") ?? void 0;
+	q.procedure = params.get("procedure") ?? void 0;
+	q.session = params.get("session") ?? void 0;
+	const minDuration = params.get("minDuration");
+	if (minDuration) q.minDuration = Number(minDuration);
+	const maxDuration = params.get("maxDuration");
+	if (maxDuration) q.maxDuration = Number(maxDuration);
+	return q;
+}
+function matchesStatus(entryStatus, filter) {
+	const exact = Number(filter);
+	if (Number.isFinite(exact)) return entryStatus === exact;
+	if (/^[1-5]xx$/i.test(filter)) {
+		const cls = Number(filter[0]);
+		return Math.floor(entryStatus / 100) === cls;
+	}
+	const rangeMatch = filter.match(/^([<>]=?)(\d+)$/);
+	if (rangeMatch) {
+		const [, op, val] = rangeMatch;
+		const n = Number(val);
+		switch (op) {
+			case ">": return entryStatus > n;
+			case ">=": return entryStatus >= n;
+			case "<": return entryStatus < n;
+			case "<=": return entryStatus <= n;
+		}
+	}
+	return true;
+}
+function queryRequests(entries, params) {
+	let filtered = entries;
+	if (params.status) {
+		const status = params.status;
+		filtered = filtered.filter((r) => matchesStatus(r.status, status));
+	}
+	if (params.path) {
+		const prefix = params.path.toLowerCase();
+		filtered = filtered.filter((r) => r.path.toLowerCase().includes(prefix));
+	}
+	if (params.procedure) {
+		const proc = params.procedure.toLowerCase();
+		filtered = filtered.filter((r) => r.procedures.some((p) => p.procedure.toLowerCase().includes(proc)));
+	}
+	if (params.session) {
+		const session = params.session;
+		filtered = filtered.filter((r) => r.sessionId === session);
+	}
+	if (params.minDuration != null) {
+		const min = params.minDuration;
+		filtered = filtered.filter((r) => r.durationMs >= min);
+	}
+	if (params.maxDuration != null) {
+		const max = params.maxDuration;
+		filtered = filtered.filter((r) => r.durationMs <= max);
+	}
+	if (params.search) {
+		const term = params.search.toLowerCase();
+		filtered = filtered.filter((r) => r.path?.toLowerCase().includes(term) || r.procedures?.some((p) => p.procedure.toLowerCase().includes(term)) || r.method?.toLowerCase().includes(term) || r.requestId?.includes(term));
+	}
+	const sortField = params.sort ?? "timestamp";
+	const desc = (params.order ?? "desc") === "desc";
+	filtered = sortEntries(filtered, sortField, desc);
+	return paginate(filtered, params);
+}
+function queryErrors(entries, params) {
+	let filtered = entries;
+	if (params.status) {
+		const status = params.status;
+		filtered = filtered.filter((e) => matchesStatus(e.status, status));
+	}
+	if (params.procedure) {
+		const proc = params.procedure.toLowerCase();
+		filtered = filtered.filter((e) => e.procedure.toLowerCase().includes(proc));
+	}
+	if (params.path) {
+		const path = params.path.toLowerCase();
+		filtered = filtered.filter((e) => e.procedure.toLowerCase().includes(path));
+	}
+	if (params.minDuration != null) {
+		const min = params.minDuration;
+		filtered = filtered.filter((e) => e.durationMs >= min);
+	}
+	if (params.maxDuration != null) {
+		const max = params.maxDuration;
+		filtered = filtered.filter((e) => e.durationMs <= max);
+	}
+	if (params.search) {
+		const term = params.search.toLowerCase();
+		filtered = filtered.filter((e) => e.procedure.toLowerCase().includes(term) || e.error.toLowerCase().includes(term) || e.code.toLowerCase().includes(term) || e.requestId.includes(term));
+	}
+	const sortField = params.sort ?? "timestamp";
+	const desc = (params.order ?? "desc") === "desc";
+	filtered = sortEntries(filtered, sortField, desc);
+	return paginate(filtered, params);
+}
+function queryTasks(entries, params) {
+	let filtered = entries;
+	if (params.status) {
+		const status = params.status;
+		filtered = filtered.filter((t) => status === "error" ? t.status === "error" : t.status === "success");
+	}
+	if (params.search) {
+		const term = params.search.toLowerCase();
+		filtered = filtered.filter((t) => t.taskName.toLowerCase().includes(term) || (t.error?.toLowerCase().includes(term) ?? false));
+	}
+	if (params.minDuration != null) {
+		const min = params.minDuration;
+		filtered = filtered.filter((t) => t.durationMs >= min);
+	}
+	const sortField = params.sort ?? "timestamp";
+	const desc = (params.order ?? "desc") === "desc";
+	filtered = sortEntries(filtered, sortField, desc);
+	return paginate(filtered, params);
+}
+function sortEntries(entries, field, desc) {
+	const sorted = [...entries];
+	sorted.sort((a, b) => {
+		const va = a[field];
+		const vb = b[field];
+		if (va == null && vb == null) return 0;
+		if (va == null) return 1;
+		if (vb == null) return -1;
+		if (typeof va === "number" && typeof vb === "number") return desc ? vb - va : va - vb;
+		if (typeof va === "string" && typeof vb === "string") return desc ? vb.localeCompare(va) : va.localeCompare(vb);
+		return 0;
+	});
+	return sorted;
+}
+function paginate(entries, params) {
+	const limit = params.limit ?? 50;
+	const total = entries.length;
+	let start = 0;
+	if (params.cursor != null) {
+		const idx = entries.findIndex((e) => e.id === params.cursor);
+		start = idx === -1 ? 0 : idx + 1;
+	} else if (params.before != null) {
+		const idx = entries.findIndex((e) => e.id === params.before);
+		start = idx === -1 ? 0 : Math.max(0, idx - limit);
+	}
+	const data = entries.slice(start, start + limit);
+	const hasMore = start + limit < total;
+	return {
+		data,
+		total,
+		hasMore,
+		nextCursor: hasMore && data.length > 0 ? data[data.length - 1].id : null,
+		prevCursor: start > 0 && data.length > 0 ? data[0].id : null
+	};
+}
+//#endregion
+export { parseQueryParams, queryErrors, queryRequests, queryTasks };

package/dist/plugins/analytics/request-id.mjs

@@ -0,0 +1,34 @@
+//#region src/plugins/analytics/request-id.ts
+/**
+* Snowflake-style request ID generator.
+*
+* Layout: 42-bit timestamp (ms) | 12-bit counter | 10-bit random
+* - 42 bits timestamp → ~139 years from epoch
+* - 12 bits counter → 4096 IDs per ms (supports 4M req/sec)
+* - 10 bits random → collision resistance across processes
+*
+* Encoded as Base36 → 13 characters, lexicographically time-sorted
+* Speed: ~50ns (Date.now + Math.random, no crypto)
+*
+* References:
+* - Twitter Snowflake (2010): 41-bit ts | 10-bit machine | 12-bit seq
+* - RFC 9562 UUID v7: 48-bit ts | 74-bit random
+* - arXiv:2509.08969 — ULID vs UUID v7 comparative analysis
+*/
+let _lastTime = 0;
+let _counter = 0;
+function generateRequestId() {
+	let now = Date.now();
+	if (now === _lastTime) {
+		_counter = _counter + 1 & 4095;
+		if (_counter === 0) while (now === _lastTime) now = Date.now();
+	} else {
+		_counter = 0;
+		_lastTime = now;
+	}
+	const high = Math.floor(now / 1024);
+	const low = (now & 1023) << 22 | _counter << 10 | Math.random() * 1024 >>> 0;
+	return high.toString(36) + low.toString(36).padStart(7, "0");
+}
+//#endregion
+export { generateRequestId };

package/dist/plugins/analytics/routes.d.mts

@@ -0,0 +1,11 @@
+import { AnalyticsCollector } from "./collector.mjs";
+
+//#region src/plugins/analytics/routes.d.ts
+declare function analyticsHTML(): string;
+declare function checkAnalyticsAuth(request: Request, auth: string | ((req: Request) => boolean | Promise<boolean>)): boolean | Promise<boolean>;
+/** Return auth-failure response for analytics routes. */
+declare function analyticsAuthResponse(pathname: string): Response;
+/** Serve analytics dashboard and API routes. */
+declare function serveAnalyticsRoute(pathname: string, request: Request, collector: AnalyticsCollector, dashboardHtml: string | undefined): Promise<Response>;
+//#endregion
+export { analyticsAuthResponse, analyticsHTML, checkAnalyticsAuth, serveAnalyticsRoute };

package/dist/plugins/analytics/routes.mjs

@@ -0,0 +1,211 @@
+import { errorToMarkdown, requestToMarkdown } from "./export.mjs";
+import { parseQueryParams, queryErrors, queryRequests, queryTasks } from "./query.mjs";
+import { parse } from "cookie-es";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/plugins/analytics/routes.ts
+/**
+* Analytics HTTP routing — dashboard, API endpoints, auth.
+*/
+const __analytics_dirname = dirname(fileURLToPath(import.meta.url));
+let _dashboardCache;
+function analyticsHTML() {
+	if (_dashboardCache) return _dashboardCache;
+	const candidates = [
+		resolve(__analytics_dirname, "../../lib/dashboard/index.html"),
+		resolve(__analytics_dirname, "../lib/dashboard/index.html"),
+		resolve(__analytics_dirname, "../../../lib/dashboard/index.html")
+	];
+	for (const p of candidates) try {
+		_dashboardCache = readFileSync(p, "utf-8");
+		return _dashboardCache;
+	} catch {}
+	return FALLBACK_HTML;
+}
+const FALLBACK_HTML = `<!DOCTYPE html>
+<html lang="en"><head><meta charset="utf-8"><title>Silgi Analytics</title>
+<style>body{font-family:monospace;background:#0a0a0a;color:#e4e4e7;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
+.msg{text-align:center}.msg h1{color:#edc462;margin-bottom:8px}.msg p{color:#71717a;font-size:14px}</style></head>
+<body><div class="msg"><h1>silgi analytics</h1><p>Dashboard not built. Run <code>pnpm build:dashboard</code></p></div></body></html>`;
+function checkAnalyticsAuth(request, auth) {
+	if (typeof auth === "function") return auth(request);
+	const cookie = request.headers.get("cookie");
+	if (cookie) {
+		if (parse(cookie)["silgi-auth"] === auth) return true;
+	}
+	if (request.headers.get("authorization") === `Bearer ${auth}`) return true;
+	return false;
+}
+const analyticsLoginHTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Silgi Analytics</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:system-ui,-apple-system,sans-serif;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#0a0a0a;color:#e5e5e5}
+.c{width:100%;max-width:360px;padding:0 24px}
+.logo{display:flex;align-items:center;gap:8px;margin-bottom:20px}
+.logo svg{width:20px;height:20px;color:#c2822a}
+.logo span{font-size:14px;font-weight:600;letter-spacing:-.01em}
+p{font-size:13px;color:#737373;margin-bottom:16px;line-height:1.5}
+input{width:100%;height:40px;padding:0 12px;background:#171717;border:1px solid #262626;border-radius:6px;color:#e5e5e5;font-size:13px;outline:none}
+input:focus{border-color:#c2822a}
+input::placeholder{color:#525252}
+button{width:100%;height:36px;margin-top:10px;background:#c2822a;color:#0a0a0a;border:none;border-radius:6px;font-size:13px;font-weight:500;cursor:pointer}
+button:hover{background:#d4943b}
+.err{color:#ef4444;font-size:12px;margin-top:8px;display:none}
+</style>
+</head>
+<body>
+<div class="c">
+<div class="logo"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 12h-4l-3 9L9 3l-3 9H2"/></svg><span>Silgi Analytics</span></div>
+<p>Enter your access token to view the dashboard.</p>
+<form id="f"><input id="t" type="password" placeholder="Access token" autofocus><div class="err" id="e">Invalid token</div><button type="submit">Authenticate</button></form>
+</div>
+<script>
+document.getElementById('f').onsubmit=function(e){
+e.preventDefault();
+var t=document.getElementById('t').value.trim();
+if(!t)return;
+document.cookie='silgi-auth='+encodeURIComponent(t)+';path=/api/analytics;samesite=strict';
+fetch('/api/analytics/stats',{headers:{'cookie':'silgi-auth='+encodeURIComponent(t)}}).then(function(){
+location.reload();
+}).catch(function(){location.reload()});
+};
+<\/script>
+</body>
+</html>`;
+/** Return auth-failure response for analytics routes. */
+function analyticsAuthResponse(pathname) {
+	const jsonHeaders = { "content-type": "application/json" };
+	if (pathname !== "api/analytics" && pathname !== "api/analytics/") return new Response(JSON.stringify({
+		code: "UNAUTHORIZED",
+		status: 401,
+		message: "Invalid token"
+	}), {
+		status: 401,
+		headers: jsonHeaders
+	});
+	return new Response(analyticsLoginHTML, {
+		status: 401,
+		headers: { "content-type": "text/html" }
+	});
+}
+function parseAnalyticsDetailPath(pathname, prefix) {
+	if (!pathname.startsWith(prefix)) return null;
+	const rawId = pathname.slice(prefix.length);
+	if (!rawId || rawId.includes("/")) return null;
+	const id = Number(rawId);
+	return {
+		id: Number.isFinite(id) ? id : null,
+		rawId: decodeURIComponent(rawId)
+	};
+}
+function jsonResponse(data, headers) {
+	return new Response(JSON.stringify(data), { headers });
+}
+/** Serve analytics dashboard and API routes. */
+async function serveAnalyticsRoute(pathname, request, collector, dashboardHtml) {
+	const jsonCacheHeaders = {
+		"content-type": "application/json",
+		"cache-control": "no-cache"
+	};
+	const mdHeaders = {
+		"content-type": "text/markdown; charset=utf-8",
+		"cache-control": "no-cache"
+	};
+	const url = new URL(request.url);
+	if (pathname === "api/analytics" || pathname === "api/analytics/") return new Response(dashboardHtml, { headers: { "content-type": "text/html" } });
+	if (pathname === "api/analytics/stats") return jsonResponse(collector.toJSON(), jsonCacheHeaders);
+	if (pathname === "api/analytics/hidden") {
+		if (request.method === "GET") return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
+		if (request.method === "POST") {
+			const body = await request.json();
+			if (typeof body.path !== "string") return new Response("{\"error\":\"path required\"}", {
+				status: 400,
+				headers: jsonCacheHeaders
+			});
+			collector.addHiddenPath(body.path);
+			return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
+		}
+		if (request.method === "DELETE") {
+			const body = await request.json();
+			if (typeof body.path !== "string") return new Response("{\"error\":\"path required\"}", {
+				status: 400,
+				headers: jsonCacheHeaders
+			});
+			collector.removeHiddenPath(body.path);
+			return jsonResponse(collector.getHiddenPaths(), jsonCacheHeaders);
+		}
+	}
+	if (pathname === "api/analytics/errors") return jsonResponse(queryErrors((await collector.getErrors()).filter((e) => !collector.isHidden(e.procedure)), parseQueryParams(url.searchParams)), jsonCacheHeaders);
+	if (pathname === "api/analytics/requests") return jsonResponse(queryRequests((await collector.getRequests()).filter((r) => !collector.isHidden(r.path)), parseQueryParams(url.searchParams)), jsonCacheHeaders);
+	if (pathname === "api/analytics/tasks") return jsonResponse(queryTasks(await collector.getTaskExecutions(), parseQueryParams(url.searchParams)), jsonCacheHeaders);
+	if (pathname === "api/analytics/scheduled") {
+		const { getScheduledTasks } = await import("../../core/task.mjs");
+		return jsonResponse(getScheduledTasks(), jsonCacheHeaders);
+	}
+	if (pathname === "api/analytics/stream") {
+		const stream = collector.sseHub.createStream();
+		return new Response(stream, { headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			connection: "keep-alive"
+		} });
+	}
+	if (pathname === "api/analytics/timeseries") {
+		const range = url.searchParams.get("range") || "1h";
+		return jsonResponse(collector.timeseries.query(range), jsonCacheHeaders);
+	}
+	if (pathname === "api/analytics/alerts") return jsonResponse({
+		history: collector.alertEngine?.getHistory() ?? [],
+		states: collector.alertEngine?.getStates() ?? {}
+	}, jsonCacheHeaders);
+	if (pathname === "api/analytics/cost") return jsonResponse(collector.costTracker.getSummary(), jsonCacheHeaders);
+	if (pathname.startsWith("api/analytics/traces/")) {
+		const traceId = decodeURIComponent(pathname.slice(21));
+		if (traceId) return jsonResponse((await collector.getRequests()).filter((r) => r.traceId === traceId), jsonCacheHeaders);
+	}
+	if (pathname.startsWith("api/analytics/requests/") && pathname.endsWith("/md")) {
+		const rawId = pathname.slice(23, -3);
+		const parsedId = Number(rawId);
+		const requestId = decodeURIComponent(rawId);
+		const entry = (await collector.getRequests()).find((r) => r.id === parsedId || r.requestId === requestId);
+		if (entry) return new Response(requestToMarkdown(entry), { headers: mdHeaders });
+		return new Response("not found", { status: 404 });
+	}
+	const requestDetail = parseAnalyticsDetailPath(pathname, "api/analytics/requests/");
+	if (requestDetail) {
+		const entry = (await collector.getRequests()).find((r) => r.id === requestDetail.id || r.requestId === requestDetail.rawId);
+		return entry ? jsonResponse(entry, jsonCacheHeaders) : new Response("not found", { status: 404 });
+	}
+	if (pathname.startsWith("api/analytics/errors/") && pathname.endsWith("/md")) {
+		const rawId = pathname.slice(21, -3);
+		const id = Number(rawId);
+		const entry = (await collector.getErrors()).find((e) => e.id === id);
+		if (entry) return new Response(errorToMarkdown(entry), { headers: mdHeaders });
+		return new Response("not found", { status: 404 });
+	}
+	const errorDetail = parseAnalyticsDetailPath(pathname, "api/analytics/errors/");
+	if (errorDetail) {
+		const entry = (await collector.getErrors()).find((e) => e.id === errorDetail.id);
+		return entry ? jsonResponse(entry, jsonCacheHeaders) : new Response("not found", { status: 404 });
+	}
+	if (pathname === "api/analytics/errors/md") {
+		const errors = await collector.getErrors();
+		const md = errors.length === 0 ? "No errors.\n" : `# Errors (${errors.length})\n\n` + errors.map((e) => errorToMarkdown(e)).join("\n\n---\n\n");
+		return new Response(md, { headers: mdHeaders });
+	}
+	return new Response(JSON.stringify({
+		code: "NOT_FOUND",
+		status: 404,
+		message: "Analytics route not found"
+	}), {
+		status: 404,
+		headers: jsonCacheHeaders
+	});
+}
+//#endregion
+export { analyticsAuthResponse, analyticsHTML, checkAnalyticsAuth, serveAnalyticsRoute };

package/dist/plugins/analytics/sse.d.mts

@@ -0,0 +1,31 @@
+import { ErrorEntry, RequestEntry, TaskExecution } from "./types.mjs";
+
+//#region src/plugins/analytics/sse.d.ts
+type AnalyticsEvent = {
+  type: 'request';
+  data: RequestEntry;
+} | {
+  type: 'error';
+  data: ErrorEntry;
+} | {
+  type: 'task';
+  data: TaskExecution;
+} | {
+  type: 'stats';
+  data: unknown;
+};
+declare class AnalyticsSSEHub {
+  #private;
+  constructor();
+  /** Start periodic stats broadcast. */
+  startStatsBroadcast(getStats: () => unknown, intervalMs?: number): void;
+  /** Broadcast an event to all connected clients. */
+  broadcast(event: AnalyticsEvent): void;
+  /** Create an SSE ReadableStream for a new client connection. */
+  createStream(): ReadableStream<Uint8Array>;
+  /** Number of connected clients. */
+  get clientCount(): number;
+  dispose(): void;
+}
+//#endregion
+export { AnalyticsSSEHub };