silgi 0.43.29 → 0.50.1

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/collector.d.mts

@@ -0,0 +1,38 @@
+import { CostTracker } from "./cost.mjs";
+import { AlertEngine } from "./alerts.mjs";
+import { AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, RequestEntry, TaskExecution } from "./types.mjs";
+import { AnalyticsSSEHub } from "./sse.mjs";
+import { TimeSeriesAggregator } from "./timeseries.mjs";
+
+//#region src/plugins/analytics/collector.d.ts
+declare class AnalyticsCollector {
+  #private;
+  /** SSE hub for real-time streaming */
+  sseHub: AnalyticsSSEHub;
+  /** Multi-tier time-series aggregation */
+  timeseries: TimeSeriesAggregator;
+  /** Alert engine */
+  alertEngine: AlertEngine | null;
+  /** Cost tracker */
+  costTracker: CostTracker;
+  constructor(options?: AnalyticsOptions);
+  /** Check if a path is server-side ignored (from config). */
+  isIgnored(pathname: string): boolean;
+  /** Check if a path is hidden in the dashboard (from runtime API). */
+  isHidden(pathname: string): boolean;
+  addHiddenPath(path: string): void;
+  removeHiddenPath(path: string): void;
+  getHiddenPaths(): string[];
+  record(path: string, durationMs: number): void;
+  recordError(path: string, durationMs: number, errorMsg: string): void;
+  recordDetailedError(entry: Omit<ErrorEntry, 'id'>): void;
+  recordDetailedRequest(entry: Omit<RequestEntry, 'id'>): void;
+  recordTask(entry: Omit<TaskExecution, 'id'>): void;
+  getTaskExecutions(): Promise<TaskExecution[]>;
+  getErrors(): Promise<ErrorEntry[]>;
+  getRequests(): Promise<RequestEntry[]>;
+  dispose(): Promise<void>;
+  toJSON(): AnalyticsSnapshot;
+}
+//#endregion
+export { AnalyticsCollector };

package/dist/plugins/analytics/collector.mjs

@@ -0,0 +1,275 @@
+import { matchesPathPrefix, round } from "./utils.mjs";
+import { AlertEngine } from "./alerts.mjs";
+import { CostTracker } from "./cost.mjs";
+import { AnalyticsSSEHub } from "./sse.mjs";
+import { AnalyticsStore } from "./store.mjs";
+import { TimeSeriesAggregator } from "./timeseries.mjs";
+import { RingBuffer } from "./types.mjs";
+//#region src/plugins/analytics/collector.ts
+/**
+* AnalyticsCollector — in-memory metrics aggregation.
+*
+* Tracks per-procedure counts, latencies, errors, tasks.
+* Backed by AnalyticsStore for persistence.
+*/
+/** Internal in-memory buffer caps — not user-configurable */
+const MEM_MAX_REQUESTS = 1e4;
+const MEM_MAX_ERRORS = 1e4;
+const MEM_MAX_TASKS = 1e4;
+var AnalyticsCollector = class {
+	#procedures = /* @__PURE__ */ new Map();
+	#startTime = Date.now();
+	#totalRequests = 0;
+	#totalErrors = 0;
+	#bufferSize;
+	#historySeconds;
+	#timeSeries = [];
+	#currentWindow;
+	#errors = [];
+	#nextErrorId = 1;
+	#requests = [];
+	#nextRequestId = 1;
+	#taskExecutions = [];
+	#nextTaskId = 1;
+	#taskStats = /* @__PURE__ */ new Map();
+	#store;
+	#counterFlushCounter = 0;
+	/** Server-side ignore — from config, prevents recording entirely */
+	#ignorePaths;
+	/** Client-side hide — from dashboard, filters display only */
+	#hiddenPaths = /* @__PURE__ */ new Set();
+	/** SSE hub for real-time streaming */
+	sseHub;
+	/** Multi-tier time-series aggregation */
+	timeseries;
+	/** Alert engine */
+	alertEngine = null;
+	/** Cost tracker */
+	costTracker;
+	constructor(options = {}) {
+		this.#bufferSize = options.bufferSize ?? 1024;
+		this.#historySeconds = options.historySeconds ?? 120;
+		this.#ignorePaths = new Set((options.ignorePaths ?? []).map((p) => p.startsWith("/") ? p.slice(1) : p));
+		this.#currentWindow = {
+			time: Math.floor(Date.now() / 1e3),
+			count: 0,
+			errors: 0
+		};
+		this.sseHub = new AnalyticsSSEHub();
+		this.sseHub.startStatsBroadcast(() => this.toJSON());
+		this.timeseries = new TimeSeriesAggregator();
+		this.costTracker = new CostTracker(options.budgets, (rule, current) => {
+			if (this.alertEngine) console.warn(`[silgi:budget] "${rule.name}" exceeded: $${current.toFixed(2)} / $${rule.limit}`);
+		});
+		if (options.alerts && options.alerts.length > 0) this.alertEngine = new AlertEngine(options.alerts);
+		this.#store = new AnalyticsStore(options.flushInterval ?? 5e3, options.retentionDays ?? 30);
+		this.#store.hydrate().then((c) => {
+			this.#totalRequests += c.totalRequests;
+			this.#totalErrors += c.totalErrors;
+		});
+		this.#store.loadHiddenPaths().then((paths) => {
+			for (const p of paths) this.#hiddenPaths.add(p);
+		});
+	}
+	/** Check if a path is server-side ignored (from config). */
+	isIgnored(pathname) {
+		if (this.#ignorePaths.size === 0) return false;
+		return matchesPathPrefix(pathname, this.#ignorePaths);
+	}
+	/** Check if a path is hidden in the dashboard (from runtime API). */
+	isHidden(pathname) {
+		if (this.#hiddenPaths.size === 0) return false;
+		return matchesPathPrefix(pathname, this.#hiddenPaths);
+	}
+	addHiddenPath(path) {
+		const normalized = path.startsWith("/") ? path.slice(1) : path;
+		this.#hiddenPaths.add(normalized);
+		this.#store.saveHiddenPaths([...this.#hiddenPaths]);
+	}
+	removeHiddenPath(path) {
+		const normalized = path.startsWith("/") ? path.slice(1) : path;
+		this.#hiddenPaths.delete(normalized);
+		this.#store.saveHiddenPaths([...this.#hiddenPaths]);
+	}
+	getHiddenPaths() {
+		return [...this.#hiddenPaths];
+	}
+	record(path, durationMs) {
+		this.#totalRequests++;
+		const entry = this.#getOrCreate(path);
+		entry.count++;
+		entry.latencies.push(durationMs);
+		this.#tick(false);
+		this.timeseries.record(durationMs, false);
+		this.alertEngine?.record(durationMs, false, path);
+	}
+	recordError(path, durationMs, errorMsg) {
+		this.#totalRequests++;
+		this.#totalErrors++;
+		const entry = this.#getOrCreate(path);
+		entry.count++;
+		entry.errors++;
+		entry.latencies.push(durationMs);
+		entry.lastError = errorMsg;
+		entry.lastErrorTime = Date.now();
+		this.#tick(true);
+		this.timeseries.record(durationMs, true);
+		this.alertEngine?.record(durationMs, true, path);
+	}
+	recordDetailedError(entry) {
+		const full = {
+			...entry,
+			id: this.#nextErrorId++
+		};
+		this.#errors.push(full);
+		if (this.#errors.length > MEM_MAX_ERRORS) this.#errors.shift();
+		this.#store.enqueueError(full);
+		this.sseHub.broadcast({
+			type: "error",
+			data: full
+		});
+	}
+	recordDetailedRequest(entry) {
+		const full = {
+			...entry,
+			id: this.#nextRequestId++
+		};
+		this.#requests.push(full);
+		if (this.#requests.length > MEM_MAX_REQUESTS) this.#requests.shift();
+		this.#store.enqueueRequest(full);
+		this.sseHub.broadcast({
+			type: "request",
+			data: full
+		});
+		this.#flushCountersIfNeeded();
+	}
+	recordTask(entry) {
+		const full = {
+			...entry,
+			id: this.#nextTaskId++
+		};
+		this.#taskExecutions.push(full);
+		if (this.#taskExecutions.length > MEM_MAX_TASKS) this.#taskExecutions.shift();
+		this.sseHub.broadcast({
+			type: "task",
+			data: full
+		});
+		let stats = this.#taskStats.get(entry.taskName);
+		if (!stats) {
+			stats = {
+				runs: 0,
+				errors: 0,
+				totalDuration: 0,
+				lastRun: 0
+			};
+			this.#taskStats.set(entry.taskName, stats);
+		}
+		stats.runs++;
+		if (entry.status === "error") stats.errors++;
+		stats.totalDuration += entry.durationMs;
+		stats.lastRun = entry.timestamp;
+	}
+	async getTaskExecutions() {
+		return [...this.#taskExecutions];
+	}
+	#getOrCreate(path) {
+		let entry = this.#procedures.get(path);
+		if (!entry) {
+			entry = {
+				count: 0,
+				errors: 0,
+				latencies: new RingBuffer(this.#bufferSize),
+				lastError: null,
+				lastErrorTime: 0
+			};
+			this.#procedures.set(path, entry);
+		}
+		return entry;
+	}
+	#tick(isError) {
+		const now = Math.floor(Date.now() / 1e3);
+		if (now !== this.#currentWindow.time) {
+			if (this.#currentWindow.count > 0) {
+				this.#timeSeries.push({ ...this.#currentWindow });
+				if (this.#timeSeries.length > this.#historySeconds) this.#timeSeries.shift();
+			}
+			this.#currentWindow = {
+				time: now,
+				count: 0,
+				errors: 0
+			};
+		}
+		this.#currentWindow.count++;
+		if (isError) this.#currentWindow.errors++;
+	}
+	getErrors() {
+		return this.#store.getErrors();
+	}
+	getRequests() {
+		return this.#store.getRequests();
+	}
+	#flushCountersIfNeeded() {
+		if (++this.#counterFlushCounter % 50 === 0) this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+	}
+	async dispose() {
+		await this.#store.saveCounters(this.#totalRequests, this.#totalErrors);
+		await this.#store.dispose();
+	}
+	toJSON() {
+		const uptimeSeconds = (Date.now() - this.#startTime) / 1e3;
+		const procedures = {};
+		let totalLatencySum = 0;
+		let totalLatencyCount = 0;
+		for (const [path, entry] of this.#procedures) {
+			const avg = entry.latencies.avg();
+			procedures[path] = {
+				count: entry.count,
+				errors: entry.errors,
+				errorRate: entry.count > 0 ? round(entry.errors / entry.count * 100) : 0,
+				latency: {
+					avg: round(avg),
+					p50: round(entry.latencies.percentile(50)),
+					p95: round(entry.latencies.percentile(95)),
+					p99: round(entry.latencies.percentile(99))
+				},
+				lastError: entry.lastError,
+				lastErrorTime: entry.lastErrorTime || null
+			};
+			totalLatencySum += avg * entry.latencies.count;
+			totalLatencyCount += entry.latencies.count;
+		}
+		return {
+			uptime: Math.round(uptimeSeconds),
+			totalRequests: this.#totalRequests,
+			totalErrors: this.#totalErrors,
+			errorRate: this.#totalRequests > 0 ? round(this.#totalErrors / this.#totalRequests * 100) : 0,
+			requestsPerSecond: uptimeSeconds > 0 ? round(this.#totalRequests / uptimeSeconds) : 0,
+			avgLatency: totalLatencyCount > 0 ? round(totalLatencySum / totalLatencyCount) : 0,
+			procedures,
+			timeSeries: this.#currentWindow.count > 0 ? [...this.#timeSeries, this.#currentWindow] : [...this.#timeSeries],
+			tasks: this.#taskSnapshotJSON()
+		};
+	}
+	#taskSnapshotJSON() {
+		let totalRuns = 0;
+		let totalErrors = 0;
+		const tasks = {};
+		for (const [name, s] of this.#taskStats) {
+			totalRuns += s.runs;
+			totalErrors += s.errors;
+			tasks[name] = {
+				runs: s.runs,
+				errors: s.errors,
+				avgDurationMs: s.runs > 0 ? round(s.totalDuration / s.runs) : 0,
+				lastRun: s.lastRun || null
+			};
+		}
+		return {
+			totalRuns,
+			totalErrors,
+			tasks
+		};
+	}
+};
+//#endregion
+export { AnalyticsCollector };

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/export.d.mts

@@ -0,0 +1,7 @@
+import { ErrorEntry, RequestEntry } from "./types.mjs";
+
+//#region src/plugins/analytics/export.d.ts
+declare function errorToMarkdown(e: ErrorEntry): string;
+declare function requestToMarkdown(r: RequestEntry): string;
+//#endregion
+export { errorToMarkdown, requestToMarkdown };