silgi 0.1.0-beta.14 → 0.1.0-beta.15

package/dist/core/handler.mjs

@@ -1,11 +1,11 @@
 import { routerCache } from "./router-utils.mjs";
 import { compileRouter, createContext, releaseContext } from "../compile.mjs";
 import { applyContext } from "./dispatch.mjs";
+import { iteratorToEventStream } from "./sse.mjs";
 import { analyticsTraceMap } from "../plugins/analytics.mjs";
 import { detectResponseFormat, encodeResponse, makeErrorResponse } from "./codec.mjs";
 import { runWithCtx } from "./context-bridge.mjs";
 import { parseInput } from "./input.mjs";
-import { iteratorToEventStream } from "./sse.mjs";
 //#region src/core/handler.ts
 /**
 * Fetch API handler — single unified request handler.

package/dist/core/sse.mjs

@@ -95,4 +95,4 @@ function iteratorToEventStream(iterator, options = {}) {
 	}).pipeThrough(new TextEncoderStream());
 }
 //#endregion
-export { getEventMeta, iteratorToEventStream, withEventMeta };
+export { encodeEventMessage, getEventMeta, iteratorToEventStream, withEventMeta };

package/dist/core/storage.mjs

@@ -30,8 +30,9 @@ import memoryDriver from "unstorage/drivers/memory";
 function _initStorage(config) {
 	if (config && "getItem" in config) return config;
 	const storage = createStorage({});
-	storage.mount("data", memoryDriver());
-	storage.mount("cache", memoryDriver());
+	const configKeys = config ? new Set(Object.keys(config)) : null;
+	if (!configKeys?.has("data")) storage.mount("data", memoryDriver());
+	if (!configKeys?.has("cache")) storage.mount("cache", memoryDriver());
 	if (config) for (const [path, driver] of Object.entries(config)) storage.mount(path, driver);
 	return storage;
 }

package/dist/index.mjs

@@ -2,9 +2,9 @@ import { ValidationError, type, validateSchema } from "./core/schema.mjs";
 import { collectCronTasks, getScheduledTasks, runTask, setTaskAnalytics, startCronJobs, stopCronJobs } from "./core/task.mjs";
 import { SilgiError, isDefinedError, toSilgiError } from "./core/error.mjs";
 import { compileProcedure, compileRouter, createContext } from "./compile.mjs";
-import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { AsyncIteratorClass, mapAsyncIterator } from "./core/iterator.mjs";
 import { getEventMeta, withEventMeta } from "./core/sse.mjs";
+import { initStorage, resetStorage, useStorage } from "./core/storage.mjs";
 import { silgi } from "./silgi.mjs";
 import { callable } from "./callable.mjs";
 import { lifecycleWrap } from "./lifecycle.mjs";

package/dist/plugins/analytics-alerts.d.mts

@@ -0,0 +1,59 @@
+//#region src/plugins/analytics-alerts.d.ts
+/**
+ * Analytics Alerts — configurable alerting with sliding window evaluation.
+ */
+interface AlertRule {
+  /** Unique name for this alert. */
+  name: string;
+  /** Condition to evaluate. */
+  condition: 'error_rate' | 'latency_p95' | 'latency_avg' | 'error_count' | 'request_count' | 'no_requests';
+  /** Threshold value. For rates: percentage (0-100). For latency: milliseconds. For counts: absolute number. */
+  threshold: number;
+  /** Evaluation window in seconds (default: 300 = 5 minutes). */
+  windowSeconds?: number;
+  /** Cooldown between repeated alerts in seconds (default: 3600 = 1 hour). */
+  cooldownSeconds?: number;
+  /** Optional: only evaluate for a specific procedure. */
+  procedure?: string;
+  /** Actions to execute when alert fires. */
+  actions: AlertAction[];
+}
+type AlertAction = {
+  type: 'webhook';
+  url: string;
+  headers?: Record<string, string>;
+} | {
+  type: 'slack';
+  webhookUrl: string;
+  channel?: string;
+} | {
+  type: 'console';
+};
+interface AlertEvent {
+  rule: string;
+  condition: string;
+  value: number;
+  threshold: number;
+  procedure?: string;
+  timestamp: number;
+  message: string;
+}
+interface AlertState {
+  lastFired: number;
+  lastValue: number;
+}
+declare class AlertEngine {
+  #private;
+  constructor(rules: AlertRule[]);
+  /** Record a sample for window evaluation. */
+  record(durationMs: number, isError: boolean, procedure: string): void;
+  /** Evaluate all rules against current window data. */
+  evaluate(): void;
+  /** Get alert history. */
+  getHistory(): AlertEvent[];
+  /** Get current alert states. */
+  getStates(): Record<string, AlertState>;
+  dispose(): void;
+}
+//#endregion
+export { AlertEngine, AlertRule };

package/dist/plugins/analytics-alerts.mjs

@@ -0,0 +1,140 @@
+//#region src/plugins/analytics-alerts.ts
+var AlertEngine = class {
+	#rules;
+	#state = /* @__PURE__ */ new Map();
+	#samples = [];
+	#maxWindowMs;
+	#timer = null;
+	#history = [];
+	constructor(rules) {
+		this.#rules = rules;
+		this.#maxWindowMs = Math.max(...rules.map((r) => (r.windowSeconds ?? 300) * 1e3), 3e5);
+		this.#timer = setInterval(() => this.evaluate(), 3e4);
+		if (typeof this.#timer === "object" && "unref" in this.#timer) this.#timer.unref();
+	}
+	/** Record a sample for window evaluation. */
+	record(durationMs, isError, procedure) {
+		const now = Date.now();
+		this.#samples.push({
+			timestamp: now,
+			durationMs,
+			isError,
+			procedure
+		});
+		const cutoff = now - this.#maxWindowMs;
+		while (this.#samples.length > 0 && this.#samples[0].timestamp < cutoff) this.#samples.shift();
+	}
+	/** Evaluate all rules against current window data. */
+	evaluate() {
+		const now = Date.now();
+		for (const rule of this.#rules) {
+			const windowMs = (rule.windowSeconds ?? 300) * 1e3;
+			const cooldownMs = (rule.cooldownSeconds ?? 3600) * 1e3;
+			const cutoff = now - windowMs;
+			const state = this.#state.get(rule.name);
+			if (state && now - state.lastFired < cooldownMs) continue;
+			let samples = this.#samples.filter((s) => s.timestamp >= cutoff);
+			if (rule.procedure) samples = samples.filter((s) => s.procedure.includes(rule.procedure));
+			const value = this.#computeValue(rule.condition, samples);
+			if (value === null) continue;
+			if (!this.#checkThreshold(rule.condition, value, rule.threshold)) continue;
+			const event = {
+				rule: rule.name,
+				condition: rule.condition,
+				value,
+				threshold: rule.threshold,
+				procedure: rule.procedure,
+				timestamp: now,
+				message: `Alert "${rule.name}": ${rule.condition} is ${formatValue(rule.condition, value)} (threshold: ${formatValue(rule.condition, rule.threshold)})`
+			};
+			this.#state.set(rule.name, {
+				lastFired: now,
+				lastValue: value
+			});
+			this.#history.push(event);
+			if (this.#history.length > 1e3) this.#history.shift();
+			for (const action of rule.actions) this.#executeAction(action, event);
+		}
+	}
+	#computeValue(condition, samples) {
+		if (samples.length === 0) return condition === "no_requests" ? 0 : null;
+		switch (condition) {
+			case "error_rate": return samples.filter((s) => s.isError).length / samples.length * 100;
+			case "error_count": return samples.filter((s) => s.isError).length;
+			case "request_count": return samples.length;
+			case "no_requests": return samples.length;
+			case "latency_avg": return samples.reduce((sum, s) => sum + s.durationMs, 0) / samples.length;
+			case "latency_p95": {
+				const sorted = samples.map((s) => s.durationMs).sort((a, b) => a - b);
+				const idx = Math.ceil(sorted.length * .95) - 1;
+				return sorted[Math.max(0, idx)];
+			}
+		}
+	}
+	#checkThreshold(condition, value, threshold) {
+		if (condition === "no_requests") return value <= threshold;
+		return value >= threshold;
+	}
+	async #executeAction(action, event) {
+		try {
+			switch (action.type) {
+				case "console":
+					console.warn(`[silgi:alert] ${event.message}`);
+					break;
+				case "webhook":
+					await fetch(action.url, {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							...action.headers
+						},
+						body: JSON.stringify(event)
+					});
+					break;
+				case "slack":
+					await fetch(action.webhookUrl, {
+						method: "POST",
+						headers: { "content-type": "application/json" },
+						body: JSON.stringify({
+							channel: action.channel,
+							text: event.message,
+							blocks: [{
+								type: "section",
+								text: {
+									type: "mrkdwn",
+									text: `🚨 *${event.rule}*\n${event.message}`
+								}
+							}]
+						})
+					});
+					break;
+			}
+		} catch (err) {
+			console.error(`[silgi:alert] Failed to execute ${action.type} action: ${err instanceof Error ? err.message : err}`);
+		}
+	}
+	/** Get alert history. */
+	getHistory() {
+		return this.#history;
+	}
+	/** Get current alert states. */
+	getStates() {
+		const result = {};
+		for (const [name, state] of this.#state) result[name] = state;
+		return result;
+	}
+	dispose() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = null;
+	}
+};
+function formatValue(condition, value) {
+	switch (condition) {
+		case "error_rate": return `${value.toFixed(1)}%`;
+		case "latency_avg":
+		case "latency_p95": return `${value.toFixed(1)}ms`;
+		default: return String(value);
+	}
+}
+//#endregion
+export { AlertEngine };

package/dist/plugins/analytics-cost.d.mts

@@ -0,0 +1,61 @@
+//#region src/plugins/analytics-cost.d.ts
+/**
+ * Analytics Cost Tracking — span cost metadata and budget monitoring.
+ */
+interface SpanCost {
+  /** Number of tokens/units consumed. */
+  units?: number;
+  /** Cost in dollars. */
+  amount: number;
+  /** Cost currency (default: USD). */
+  currency?: string;
+  /** Provider name (e.g., 'openai', 'anthropic', 'aws'). */
+  provider?: string;
+}
+interface CostBucket {
+  time: number;
+  totalAmount: number;
+  byProvider: Record<string, number>;
+  byProcedure: Record<string, number>;
+  byKind: Record<string, number>;
+}
+interface CostSummary {
+  totalAmount: number;
+  todayAmount: number;
+  byProvider: Record<string, number>;
+  byProcedure: Record<string, number>;
+  byKind: Record<string, number>;
+  dailyBuckets: CostBucket[];
+}
+interface BudgetRule {
+  /** Unique name. */
+  name: string;
+  /** Budget limit in dollars. */
+  limit: number;
+  /** Period: 'daily' | 'weekly' | 'monthly'. */
+  period: 'daily' | 'weekly' | 'monthly';
+  /** Optional: scope to a specific provider. */
+  provider?: string;
+  /** Optional: scope to a specific procedure. */
+  procedure?: string;
+}
+declare class CostTracker {
+  #private;
+  constructor(budgetRules?: BudgetRule[], onBudgetExceeded?: (rule: BudgetRule, current: number) => void);
+  /** Record a cost from a span. */
+  record(cost: SpanCost, procedure: string, kind: string): void;
+  /** Get cost summary. */
+  getSummary(): CostSummary;
+  /** Export for persistence. */
+  toJSON(): {
+    dailyBuckets: CostBucket[];
+    currentDay: CostBucket | null;
+  };
+  /** Restore from persistence. */
+  hydrate(data: {
+    dailyBuckets?: CostBucket[];
+    currentDay?: CostBucket | null;
+  }): void;
+}
+//#endregion
+export { BudgetRule, CostTracker, SpanCost };

package/dist/plugins/analytics-cost.mjs

@@ -0,0 +1,97 @@
+//#region src/plugins/analytics-cost.ts
+const DAY_MS = 864e5;
+const MAX_DAILY_BUCKETS = 30;
+var CostTracker = class {
+	#dailyBuckets = [];
+	#currentDay = null;
+	#budgetRules;
+	#onBudgetExceeded;
+	constructor(budgetRules = [], onBudgetExceeded) {
+		this.#budgetRules = budgetRules;
+		this.#onBudgetExceeded = onBudgetExceeded;
+	}
+	/** Record a cost from a span. */
+	record(cost, procedure, kind) {
+		const now = Date.now();
+		const dayStart = now - now % DAY_MS;
+		if (!this.#currentDay || this.#currentDay.time !== dayStart) {
+			if (this.#currentDay) {
+				this.#dailyBuckets.push(this.#currentDay);
+				if (this.#dailyBuckets.length > MAX_DAILY_BUCKETS) this.#dailyBuckets.shift();
+			}
+			this.#currentDay = {
+				time: dayStart,
+				totalAmount: 0,
+				byProvider: {},
+				byProcedure: {},
+				byKind: {}
+			};
+		}
+		this.#currentDay.totalAmount += cost.amount;
+		const provider = cost.provider ?? "unknown";
+		this.#currentDay.byProvider[provider] = (this.#currentDay.byProvider[provider] ?? 0) + cost.amount;
+		this.#currentDay.byProcedure[procedure] = (this.#currentDay.byProcedure[procedure] ?? 0) + cost.amount;
+		this.#currentDay.byKind[kind] = (this.#currentDay.byKind[kind] ?? 0) + cost.amount;
+		this.#checkBudgets();
+	}
+	/** Get cost summary. */
+	getSummary() {
+		const allBuckets = this.#currentDay ? [...this.#dailyBuckets, this.#currentDay] : [...this.#dailyBuckets];
+		const summary = {
+			totalAmount: 0,
+			todayAmount: this.#currentDay?.totalAmount ?? 0,
+			byProvider: {},
+			byProcedure: {},
+			byKind: {},
+			dailyBuckets: allBuckets
+		};
+		for (const bucket of allBuckets) {
+			summary.totalAmount += bucket.totalAmount;
+			for (const [k, v] of Object.entries(bucket.byProvider)) summary.byProvider[k] = (summary.byProvider[k] ?? 0) + v;
+			for (const [k, v] of Object.entries(bucket.byProcedure)) summary.byProcedure[k] = (summary.byProcedure[k] ?? 0) + v;
+			for (const [k, v] of Object.entries(bucket.byKind)) summary.byKind[k] = (summary.byKind[k] ?? 0) + v;
+		}
+		return summary;
+	}
+	/** Export for persistence. */
+	toJSON() {
+		return {
+			dailyBuckets: this.#dailyBuckets,
+			currentDay: this.#currentDay
+		};
+	}
+	/** Restore from persistence. */
+	hydrate(data) {
+		if (Array.isArray(data.dailyBuckets)) this.#dailyBuckets = data.dailyBuckets;
+		if (data.currentDay) this.#currentDay = data.currentDay;
+	}
+	#checkBudgets() {
+		if (!this.#onBudgetExceeded) return;
+		const now = Date.now();
+		for (const rule of this.#budgetRules) {
+			let amount = 0;
+			const buckets = this.#currentDay ? [...this.#dailyBuckets, this.#currentDay] : this.#dailyBuckets;
+			let cutoff;
+			switch (rule.period) {
+				case "daily":
+					cutoff = now - DAY_MS;
+					break;
+				case "weekly":
+					cutoff = now - 7 * DAY_MS;
+					break;
+				case "monthly":
+					cutoff = now - 30 * DAY_MS;
+					break;
+			}
+			for (const bucket of buckets) {
+				if (bucket.time < cutoff) continue;
+				if (rule.provider) amount += bucket.byProvider[rule.provider] ?? 0;
+				else if (rule.procedure) amount += bucket.byProcedure[rule.procedure] ?? 0;
+				else amount += bucket.totalAmount;
+			}
+			if (amount >= rule.limit) this.#onBudgetExceeded(rule, amount);
+		}
+	}
+};
+//#endregion
+export { CostTracker };

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-sse.d.mts

@@ -0,0 +1,31 @@
+import { ErrorEntry, RequestEntry, TaskExecution } from "./analytics.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 };

package/dist/plugins/analytics-sse.mjs

@@ -0,0 +1,74 @@
+import { encodeEventMessage } from "../core/sse.mjs";
+//#region src/plugins/analytics-sse.ts
+/**
+* Analytics SSE — real-time event streaming for the analytics dashboard.
+*/
+var AnalyticsSSEHub = class {
+	#clients = /* @__PURE__ */ new Set();
+	#statsInterval = null;
+	#getStats = null;
+	constructor() {}
+	/** Start periodic stats broadcast. */
+	startStatsBroadcast(getStats, intervalMs = 5e3) {
+		this.#getStats = getStats;
+		this.#statsInterval = setInterval(() => {
+			if (this.#clients.size > 0 && this.#getStats) this.broadcast({
+				type: "stats",
+				data: this.#getStats()
+			});
+		}, intervalMs);
+		if (typeof this.#statsInterval === "object" && "unref" in this.#statsInterval) this.#statsInterval.unref();
+	}
+	/** Broadcast an event to all connected clients. */
+	broadcast(event) {
+		if (this.#clients.size === 0) return;
+		const message = encodeEventMessage({
+			event: event.type,
+			data: JSON.stringify(event.data)
+		});
+		for (const controller of this.#clients) try {
+			controller.enqueue(message);
+		} catch {
+			this.#clients.delete(controller);
+		}
+	}
+	/** Create an SSE ReadableStream for a new client connection. */
+	createStream() {
+		let controller;
+		let keepAliveTimer;
+		return new ReadableStream({
+			start: (ctrl) => {
+				controller = ctrl;
+				this.#clients.add(controller);
+				controller.enqueue(encodeEventMessage({ comment: "connected" }));
+				keepAliveTimer = setInterval(() => {
+					try {
+						controller.enqueue(encodeEventMessage({ comment: "keepalive" }));
+					} catch {
+						clearInterval(keepAliveTimer);
+						this.#clients.delete(controller);
+					}
+				}, 15e3);
+				if (typeof keepAliveTimer === "object" && "unref" in keepAliveTimer) keepAliveTimer.unref();
+			},
+			cancel: () => {
+				clearInterval(keepAliveTimer);
+				this.#clients.delete(controller);
+			}
+		}).pipeThrough(new TextEncoderStream());
+	}
+	/** Number of connected clients. */
+	get clientCount() {
+		return this.#clients.size;
+	}
+	dispose() {
+		if (this.#statsInterval) clearInterval(this.#statsInterval);
+		this.#statsInterval = null;
+		for (const controller of this.#clients) try {
+			controller.close();
+		} catch {}
+		this.#clients.clear();
+	}
+};
+//#endregion
+export { AnalyticsSSEHub };