token-usage-dashboard 1.0.6

package/build/server/chunks/chunks/internal2.js-BlXt2rfE.js

@@ -0,0 +1,22 @@
+//#region node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js
+var base = "";
+var assets = base;
+var app_dir = "_app";
+var initial = {
+	base,
+	assets
+};
+/**
+* @param {{ base: string, assets: string }} paths
+*/
+function override(paths) {
+	base = paths.base;
+	assets = paths.assets;
+}
+function reset() {
+	base = initial.base;
+	assets = initial.assets;
+}
+
+export { assets as a, base as b, app_dir as c, override as o, reset as r };
+//# sourceMappingURL=internal2.js-BlXt2rfE.js.map

package/build/server/chunks/chunks/queries.js-aTxz7ubg.js

@@ -0,0 +1,676 @@
+import { t as totalOf, c as costOf } from './range.js-CLYFtcRE.js';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { dirname, join, basename } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+//#region src/lib/server/config.ts
+var home = homedir();
+var env = (name, fallback) => (process.env[name] || "").trim() || fallback;
+var dataHome = env("XDG_DATA_HOME", join(home, ".local", "share"));
+var config = {
+	dbPath: env("AIUSAGE_DB", join(dataHome, "ai-usage-dashboard", "usage.db")),
+	claudeDir: env("AIUSAGE_CLAUDE_DIR", join(home, ".claude")),
+	codexDir: env("AIUSAGE_CODEX_DIR", join(home, ".codex")),
+	openCodeDir: env("AIUSAGE_OPENCODE_DIR", join(dataHome, "opencode")),
+	geminiDir: env("AIUSAGE_GEMINI_DIR", join(home, ".gemini")),
+	openRouterKey: env("OPENROUTER_API_KEY", ""),
+	scanIntervalMs: Number(env("AIUSAGE_SCAN_INTERVAL", "120")) * 1e3
+};
+//#endregion
+//#region src/lib/server/db.ts
+/** Bump to throw away scanned rows and read every source file again. */
+var SCHEMA = 2;
+var META = "create table if not exists meta (key text primary key, value text not null)";
+var TABLES = `
+create table if not exists events (
+  id text primary key,
+  tool text not null,
+  model text not null,
+  session text not null,
+  project text not null,
+  ts integer not null,
+  day text not null,
+  dow integer not null,
+  hour integer not null,
+  input integer not null default 0,
+  output integer not null default 0,
+  cache_read integer not null default 0,
+  cache_write integer not null default 0,
+  reasoning integer not null default 0
+);
+create index if not exists events_ts on events (ts);
+create index if not exists events_day on events (day);
+create table if not exists files (
+  path text primary key,
+  tool text not null,
+  size integer not null,
+  mtime integer not null,
+  events integer not null default 0,
+  scanned_at integer not null
+);
+create table if not exists windows (
+  id text primary key,
+  tool text not null,
+  label text not null,
+  used_percent real not null,
+  window_minutes integer,
+  resets_at integer,
+  detail text not null default '',
+  seen_at integer not null
+);
+`;
+var handle = null;
+function db() {
+	if (handle) return handle;
+	mkdirSync(dirname(config.dbPath), { recursive: true });
+	handle = new DatabaseSync(config.dbPath);
+	handle.exec("pragma journal_mode = wal");
+	handle.exec("pragma synchronous = normal");
+	handle.exec(META);
+	if (readMeta("schema") !== String(SCHEMA)) {
+		handle.exec("drop table if exists events; drop table if exists files");
+		writeMeta("schema", String(SCHEMA));
+	}
+	handle.exec(TABLES);
+	rebucket(handle);
+	return handle;
+}
+var REBUCKET = `
+update events set
+  day = date(ts / 1000, 'unixepoch', 'localtime'),
+  dow = cast(strftime('%w', ts / 1000, 'unixepoch', 'localtime') as integer),
+  hour = cast(strftime('%H', ts / 1000, 'unixepoch', 'localtime') as integer)
+`;
+/** Move the machine and every stored day is an hour or a date out, so redo them once. */
+function rebucket(handle) {
+	const zone = Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown";
+	if (readMeta("timezone") === zone) return;
+	handle.exec(REBUCKET);
+	writeMeta("timezone", zone);
+}
+function readMeta(key) {
+	return db().prepare("select value from meta where key = ?").get(key)?.value ?? null;
+}
+function writeMeta(key, value) {
+	db().prepare("insert into meta (key, value) values (?, ?) on conflict(key) do update set value = excluded.value").run(key, value);
+}
+//#endregion
+//#region src/lib/server/sources/types.ts
+/** Lines that can't be parsed are skipped: a half-written tail is normal, not a fault. */
+function* jsonLines(text, needle) {
+	for (const line of text.split("\n")) {
+		if (line.length < 2 || needle && !line.includes(needle)) continue;
+		try {
+			yield JSON.parse(line);
+		} catch {
+			continue;
+		}
+	}
+}
+var num = (value) => typeof value === "number" && value > 0 ? value : 0;
+//#endregion
+//#region src/lib/server/sources/claude.ts
+/**
+* A streaming message is rewritten in place under one `message.id`, so the caller keeps the
+* highest value it has seen per field. Session comes off the line, never the filename, or a
+* subagent's tokens land under the wrong session.
+*/
+var claudeCode = {
+	id: "claude-code",
+	label: "Claude Code",
+	root: join(config.claudeDir, "projects"),
+	ext: ".jsonl",
+	parse(path, text) {
+		const events = [];
+		for (const line of jsonLines(text, "\"usage\"")) {
+			const message = line.message;
+			const usage = message?.usage;
+			if (line.type !== "assistant" || !usage || !message.id || !message.model) continue;
+			if (message.model.startsWith("<")) continue;
+			const ts = Date.parse(String(line.timestamp));
+			if (Number.isNaN(ts)) continue;
+			const details = usage.output_tokens_details;
+			events.push({
+				id: `claude-code:${message.id}`,
+				model: message.model,
+				session: String(line.sessionId || line.session_id || ""),
+				project: String(line.cwd || ""),
+				ts,
+				input: num(usage.input_tokens),
+				output: num(usage.output_tokens),
+				cache_read: num(usage.cache_read_input_tokens),
+				cache_write: num(usage.cache_creation_input_tokens),
+				reasoning: num(details?.thinking_tokens)
+			});
+		}
+		return { events };
+	}
+};
+//#endregion
+//#region src/lib/server/sources/codex.ts
+var label = (minutes) => {
+	if (minutes === 300) return "Codex 5-hour";
+	if (minutes === 10080) return "Codex weekly";
+	return minutes ? `Codex ${minutes}-minute` : "Codex";
+};
+function window(id, limit, plan, seenAt) {
+	if (!limit || typeof limit.used_percent !== "number") return null;
+	return {
+		id: `codex-${id}`,
+		label: label(limit.window_minutes),
+		used_percent: limit.used_percent,
+		window_minutes: limit.window_minutes ?? null,
+		resets_at: limit.resets_at ? limit.resets_at * 1e3 : null,
+		detail: plan ? `${plan} plan` : "",
+		seen_at: seenAt
+	};
+}
+//#endregion
+//#region src/lib/server/sources/index.ts
+var SOURCES = [
+	claudeCode,
+	{
+		id: "codex",
+		label: "Codex",
+		root: join(config.codexDir, "sessions"),
+		ext: ".jsonl",
+		parse(path, text) {
+			const events = [];
+			let windows = [];
+			const rollout = basename(path, ".jsonl");
+			let session = "";
+			let project = "";
+			let model = "unknown";
+			for (const line of jsonLines(text)) {
+				const payload = line.payload ?? {};
+				const kind = line.type === "event_msg" ? payload.type : line.type;
+				if (kind === "session_meta") {
+					session = String(payload.session_id || payload.id || "");
+					project = String(payload.cwd || "");
+					continue;
+				}
+				if (kind === "turn_context" && payload.model) {
+					model = String(payload.model);
+					continue;
+				}
+				if (kind !== "token_count") continue;
+				const info = payload.info;
+				const turn = info?.last_token_usage;
+				const running = info?.total_token_usage;
+				if (!turn || !running) continue;
+				const ts = Date.parse(String(line.timestamp));
+				if (Number.isNaN(ts)) continue;
+				events.push({
+					id: `codex:${rollout}:${num(running.total_tokens)}`,
+					model,
+					session: session || rollout,
+					project,
+					ts,
+					input: Math.max(0, num(turn.input_tokens) - num(turn.cached_input_tokens)),
+					output: num(turn.output_tokens),
+					cache_read: num(turn.cached_input_tokens),
+					cache_write: num(turn.cache_write_input_tokens),
+					reasoning: num(turn.reasoning_output_tokens)
+				});
+				const limits = payload.rate_limits;
+				if (!limits) continue;
+				const plan = typeof limits.plan_type === "string" ? limits.plan_type : "";
+				windows = [window("primary", limits.primary, plan, ts), window("secondary", limits.secondary, plan, ts)].filter((entry) => entry !== null);
+			}
+			return {
+				events,
+				windows
+			};
+		}
+	},
+	{
+		id: "opencode",
+		label: "OpenCode",
+		root: join(config.openCodeDir, "storage", "message"),
+		ext: ".json",
+		parse(path, text) {
+			let message;
+			try {
+				message = JSON.parse(text);
+			} catch {
+				return { events: [] };
+			}
+			const tokens = message.tokens;
+			const created = message.time?.created;
+			if (message.role !== "assistant" || !tokens || !created) return { events: [] };
+			const model = message.providerID ? `${message.providerID}/${message.modelID}` : message.modelID;
+			if (!model) return { events: [] };
+			return { events: [{
+				id: `opencode:${message.id || basename(path, ".json")}`,
+				model,
+				session: String(message.sessionID || ""),
+				project: String(message.path?.cwd || message.path?.root || ""),
+				ts: created < 0xe8d4a51000 ? created * 1e3 : created,
+				input: num(tokens.input),
+				output: num(tokens.output),
+				cache_read: num(tokens.cache?.read),
+				cache_write: num(tokens.cache?.write),
+				reasoning: num(tokens.reasoning)
+			}] };
+		}
+	}
+];
+//#endregion
+//#region src/lib/server/problems.ts
+var seen = /* @__PURE__ */ new Map();
+/** Keyed on id so a fault that repeats every scan stays one row in the panel. */
+function report(problem) {
+	seen.set(problem.id, {
+		...problem,
+		at: Date.now()
+	});
+}
+function resolve(id) {
+	seen.delete(id);
+}
+var problems = () => [...seen.values()].sort((a, b) => b.at - a.at);
+var describe = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
+//#region src/lib/server/scan.ts
+var running = null;
+var last = [];
+var finishedAt = 0;
+async function listFiles(source) {
+	return (await readdir(source.root, {
+		recursive: true,
+		withFileTypes: true
+	})).filter((entry) => entry.isFile() && entry.name.endsWith(source.ext)).map((entry) => join(entry.parentPath, entry.name));
+}
+var INSERT = "insert into events (id, tool, model, session, project, ts, day, dow, hour, input, output, cache_read, cache_write, reasoning) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) on conflict(id) do update set input = max(input, excluded.input), output = max(output, excluded.output), cache_read = max(cache_read, excluded.cache_read), cache_write = max(cache_write, excluded.cache_write), reasoning = max(reasoning, excluded.reasoning)";
+var INSERT_WINDOW = "insert into windows (id, tool, label, used_percent, window_minutes, resets_at, detail, seen_at) values (?, ?, ?, ?, ?, ?, ?, ?) on conflict(id) do update set used_percent = excluded.used_percent, resets_at = excluded.resets_at, detail = excluded.detail, seen_at = excluded.seen_at where excluded.seen_at >= windows.seen_at";
+async function scanSource(source) {
+	const state = {
+		id: source.id,
+		label: source.label,
+		root: source.root,
+		present: true,
+		files: 0,
+		events: 0
+	};
+	let paths;
+	try {
+		paths = await listFiles(source);
+	} catch {
+		state.present = false;
+		return state;
+	}
+	const handle = db();
+	const known = new Map(handle.prepare("select path, size, mtime, events from files where tool = ?").all(source.id).map((row) => [row.path, row]));
+	const insert = handle.prepare(INSERT);
+	const insertWindow = handle.prepare(INSERT_WINDOW);
+	const touch = handle.prepare("insert into files (path, tool, size, mtime, events, scanned_at) values (?, ?, ?, ?, ?, ?) on conflict(path) do update set size = excluded.size, mtime = excluded.mtime, events = excluded.events, scanned_at = excluded.scanned_at");
+	let failures = 0;
+	const now = Date.now();
+	for (const path of paths) {
+		state.files += 1;
+		let size = 0;
+		let mtime = 0;
+		try {
+			const info = await lstatOf(path);
+			size = info.size;
+			mtime = info.mtime;
+		} catch {
+			continue;
+		}
+		const cached = known.get(path);
+		if (cached && cached.size === size && cached.mtime === mtime) {
+			state.events += cached.events;
+			continue;
+		}
+		try {
+			const parsed = source.parse(path, await readFile(path, "utf8"));
+			handle.exec("begin");
+			for (const event of parsed.events) {
+				const at = new Date(event.ts);
+				insert.run(event.id, source.id, event.model, event.session, event.project, event.ts, localDay(at), at.getDay(), at.getHours(), event.input, event.output, event.cache_read, event.cache_write, event.reasoning);
+			}
+			for (const window of parsed.windows ?? []) insertWindow.run(window.id, source.id, window.label, window.used_percent, window.window_minutes, window.resets_at, window.detail, window.seen_at);
+			touch.run(path, source.id, size, mtime, parsed.events.length, now);
+			handle.exec("commit");
+			state.events += parsed.events.length;
+		} catch (error) {
+			try {
+				handle.exec("rollback");
+			} catch {}
+			failures += 1;
+			if (failures === 1) report({
+				id: `scan:${source.id}`,
+				level: "warn",
+				scope: source.label,
+				message: `Could not read ${path}`,
+				hint: describe(error)
+			});
+		}
+	}
+	if (!failures) resolve(`scan:${source.id}`);
+	if (state.files && !state.events) report({
+		id: `empty:${source.id}`,
+		level: "warn",
+		scope: source.label,
+		message: `Found ${state.files} files under ${source.root} but no usage in any of them`,
+		hint: "The format may have moved on. Open an issue with a sample and we will follow it."
+	});
+	else resolve(`empty:${source.id}`);
+	return state;
+}
+var pad = (value) => String(value).padStart(2, "0");
+/** Local, not UTC, so a day on the calendar is the day the user had. */
+var localDay = (at) => `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}`;
+async function lstatOf(path) {
+	const info = await stat(path);
+	return {
+		size: info.size,
+		mtime: Math.round(info.mtimeMs)
+	};
+}
+async function run() {
+	const stats = [];
+	for (const source of SOURCES) stats.push(await scanSource(source));
+	last = stats;
+	finishedAt = Date.now();
+	writeMeta("scanned_at", String(finishedAt));
+	return stats;
+}
+/**
+* One scan at a time; a caller arriving mid-scan waits on the one already going. Rows are never
+* removed when their file goes: outliving the tools' own pruning is what the database is for.
+*/
+function scan() {
+	if (!running) running = run().finally(() => running = null);
+	return running;
+}
+var scanState = () => ({
+	sources: last,
+	scannedAt: finishedAt,
+	busy: running !== null
+});
+//#endregion
+//#region src/lib/server/settings.ts
+var DEFAULTS = {
+	theme: "auto",
+	range: "30d",
+	metric: "tokens",
+	scanIntervalSec: 120,
+	claudeWindows: true,
+	prices: {}
+};
+var cached = null;
+function settings() {
+	if (cached) return cached;
+	let stored = {};
+	try {
+		stored = JSON.parse(readMeta("settings") ?? "{}");
+	} catch {
+		stored = {};
+	}
+	cached = {
+		...DEFAULTS,
+		...stored
+	};
+	return cached;
+}
+function saveSettings(patch) {
+	const next = {
+		...settings(),
+		...patch
+	};
+	writeMeta("settings", JSON.stringify(next));
+	cached = next;
+	return next;
+}
+var priceOverrides = () => settings().prices;
+//#endregion
+//#region src/lib/server/queries.ts
+var empty = () => ({
+	input: 0,
+	output: 0,
+	cache_read: 0,
+	cache_write: 0
+});
+function where(filters, dated = true) {
+	const clauses = [];
+	const params = [];
+	if (dated) {
+		clauses.push("ts >= ?", "ts < ?");
+		params.push(filters.from, filters.to);
+	}
+	for (const [column, values] of [
+		["tool", filters.tools],
+		["model", filters.models],
+		["project", filters.projects]
+	]) {
+		if (!values.length) continue;
+		clauses.push(`${column} in (${values.map(() => "?").join(", ")})`);
+		params.push(...values);
+	}
+	return {
+		sql: clauses.length ? `where ${clauses.join(" and ")}` : "",
+		params
+	};
+}
+var SUMS = "sum(input) input, sum(output) output, sum(cache_read) cache_read, sum(cache_write) cache_write, sum(reasoning) reasoning, count(*) events, count(distinct tool || ':' || session) sessions";
+/** Rows arrive split by model so each slice can be priced at its own rate. */
+function fold(rows, overrides) {
+	const slices = /* @__PURE__ */ new Map();
+	const sessions = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = String(row.key ?? "");
+		let slice = slices.get(key);
+		if (!slice) {
+			slice = {
+				key,
+				tokens: empty(),
+				total: 0,
+				reasoning: 0,
+				cost: 0,
+				events: 0,
+				sessions: 0
+			};
+			slices.set(key, slice);
+			sessions.set(key, /* @__PURE__ */ new Set());
+		}
+		const tokens = {
+			input: Number(row.input) || 0,
+			output: Number(row.output) || 0,
+			cache_read: Number(row.cache_read) || 0,
+			cache_write: Number(row.cache_write) || 0
+		};
+		for (const field of Object.keys(tokens)) slice.tokens[field] += tokens[field];
+		slice.total += totalOf(tokens);
+		slice.reasoning += Number(row.reasoning) || 0;
+		slice.events += Number(row.events) || 0;
+		slice.sessions += Number(row.sessions) || 0;
+		const cost = costOf(String(row.model ?? ""), tokens, overrides);
+		if (cost === null) slice.cost = null;
+		else if (slice.cost !== null) slice.cost += cost;
+	}
+	return slices;
+}
+var blank = (key) => ({
+	key,
+	tokens: empty(),
+	total: 0,
+	reasoning: 0,
+	cost: 0,
+	events: 0,
+	sessions: 0
+});
+function grouped(column, filters, overrides) {
+	const clause = where(filters);
+	return [...fold(db().prepare(`select ${column} key, model, ${SUMS} from events ${clause.sql} group by ${column}, model`).all(...clause.params), overrides).values()].sort((a, b) => b.total - a.total);
+}
+function totals(filters, overrides) {
+	const clause = where(filters);
+	const slice = fold(db().prepare(`select '' key, model, ${SUMS} from events ${clause.sql} group by model`).all(...clause.params), overrides).get("") ?? blank("");
+	const distinct = db().prepare(`select count(distinct tool || ':' || session) sessions from events ${clause.sql}`).get(...clause.params);
+	slice.sessions = Number(distinct?.sessions) || 0;
+	return slice;
+}
+function series(filters, column, overrides) {
+	const clause = where(filters);
+	const rows = db().prepare(`select day, ${column} key, model, ${SUMS} from events ${clause.sql} group by day, ${column}, model order by day`).all(...clause.params);
+	const points = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = `${row.day}|${row.key}`;
+		const point = points.get(id) ?? {
+			day: String(row.day),
+			key: String(row.key ?? ""),
+			total: 0,
+			cost: 0
+		};
+		const tokens = {
+			input: Number(row.input) || 0,
+			output: Number(row.output) || 0,
+			cache_read: Number(row.cache_read) || 0,
+			cache_write: Number(row.cache_write) || 0
+		};
+		point.total += totalOf(tokens);
+		const cost = costOf(String(row.model ?? ""), tokens, overrides);
+		if (cost === null) point.cost = null;
+		else if (point.cost !== null) point.cost += cost;
+		points.set(id, point);
+	}
+	return [...points.values()];
+}
+/** The calendar ignores the date filter, since a year of squares is the whole point. */
+function calendar(filters, overrides) {
+	const clause = where(filters, false);
+	const rows = db().prepare(`select day, model, ${SUMS} from events ${clause.sql} group by day, model order by day`).all(...clause.params);
+	const days = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const day = String(row.day);
+		const entry = days.get(day) ?? {
+			day,
+			total: 0,
+			cost: 0,
+			events: 0
+		};
+		const tokens = {
+			input: Number(row.input) || 0,
+			output: Number(row.output) || 0,
+			cache_read: Number(row.cache_read) || 0,
+			cache_write: Number(row.cache_write) || 0
+		};
+		entry.total += totalOf(tokens);
+		entry.events += Number(row.events) || 0;
+		const cost = costOf(String(row.model ?? ""), tokens, overrides);
+		if (cost === null) entry.cost = null;
+		else if (entry.cost !== null) entry.cost += cost;
+		days.set(day, entry);
+	}
+	return [...days.values()];
+}
+function clock(filters) {
+	const clause = where(filters);
+	return db().prepare(`select dow day, hour, sum(input + output + cache_read + cache_write) total from events ${clause.sql} group by dow, hour`).all(...clause.params).map((row) => ({
+		day: Number(row.day),
+		hour: Number(row.hour),
+		total: Number(row.total) || 0
+	}));
+}
+function sessions(filters, overrides, limit = 60) {
+	const clause = where(filters);
+	const rows = db().prepare(`select session key, tool, project, model, min(ts) started, max(ts) ended, sum(input) input, sum(output) output, sum(cache_read) cache_read, sum(cache_write) cache_write, sum(reasoning) reasoning, count(*) events, count(distinct tool || ':' || session) sessions from events ${clause.sql} group by session, tool, project, model`).all(...clause.params);
+	const merged = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = String(row.key);
+		const at = `${row.tool}:${id}`;
+		const entry = merged.get(at) ?? {
+			id,
+			tool: String(row.tool),
+			project: String(row.project),
+			models: /* @__PURE__ */ new Set(),
+			started: Number(row.started),
+			ended: Number(row.ended),
+			total: 0,
+			cost: 0
+		};
+		const tokens = {
+			input: Number(row.input) || 0,
+			output: Number(row.output) || 0,
+			cache_read: Number(row.cache_read) || 0,
+			cache_write: Number(row.cache_write) || 0
+		};
+		entry.models.add(String(row.model));
+		entry.started = Math.min(entry.started, Number(row.started));
+		entry.ended = Math.max(entry.ended, Number(row.ended));
+		entry.total += totalOf(tokens);
+		const cost = costOf(String(row.model), tokens, overrides);
+		if (cost === null) entry.cost = null;
+		else if (entry.cost !== null) entry.cost += cost;
+		merged.set(at, entry);
+	}
+	return [...merged.values()].sort((a, b) => b.ended - a.ended).slice(0, limit).map(({ models, ...row }) => ({
+		...row,
+		models: [...models].sort().join(", ")
+	}));
+}
+var distinct = (column) => db().prepare(`select distinct ${column} value from events order by value`).all().map((row) => String(row.value)).filter(Boolean);
+var memo = /* @__PURE__ */ new Map();
+var memoFor = -1;
+/** One rollup per filter set per scan, since nothing under it can move in between. */
+var clearUsageMemo = () => memo.clear();
+function usage(filters) {
+	const { scannedAt } = scanState();
+	if (scannedAt !== memoFor || memo.size > 32) {
+		memo.clear();
+		memoFor = scannedAt;
+	}
+	const key = JSON.stringify(filters);
+	const hit = memo.get(key);
+	if (hit) return {
+		...hit,
+		problems: problems()
+	};
+	const fresh = rollup(filters);
+	memo.set(key, fresh);
+	return fresh;
+}
+function rollup(filters) {
+	const overrides = priceOverrides();
+	const span = filters.to - filters.from;
+	const previous = {
+		...filters,
+		from: filters.from - span,
+		to: filters.from
+	};
+	const byModel = grouped("model", filters, overrides);
+	const oldest = db().prepare("select min(ts) ts from events").get()?.ts;
+	const state = scanState();
+	return {
+		generatedAt: Date.now(),
+		filters,
+		totals: totals(filters, overrides),
+		previous: totals(previous, overrides),
+		days: Math.max(1, Math.round(span / 864e5)),
+		byTool: grouped("tool", filters, overrides),
+		byModel,
+		byProject: grouped("project", filters, overrides),
+		series: series(filters, "tool", overrides),
+		seriesByModel: series(filters, "model", overrides),
+		calendar: calendar(filters, overrides),
+		clock: clock(filters),
+		sessions: sessions(filters, overrides),
+		windows: db().prepare("select * from windows order by window_minutes, tool").all(),
+		options: {
+			tools: distinct("tool"),
+			models: distinct("model"),
+			projects: distinct("project")
+		},
+		unpriced: byModel.filter((slice) => slice.cost === null).map((slice) => slice.key),
+		sources: state.sources,
+		scannedAt: Number(readMeta("scanned_at")) || state.scannedAt,
+		oldest: oldest === null || oldest === void 0 ? null : Number(oldest),
+		problems: problems()
+	};
+}
+
+export { scan as a, db as b, resolve as c, describe as d, config as e, saveSettings as f, clearUsageMemo as g, report as r, settings as s, usage as u };
+//# sourceMappingURL=queries.js-aTxz7ubg.js.map