@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/main-B-hZbKK1.mjs

@@ -0,0 +1,340 @@
+import { a as createLocalJsonlJournal, o as defaultHistoryDirectory, r as createQuotaService, t as PROVIDER_METADATA } from "./bin.mjs";
+import { c as windowProfile, n as calculatePace, t as buildForecastV1 } from "./dist-CIjerpSd.mjs";
+import { Effect } from "effect";
+import { Box, Panel, Text, render, useInput } from "@uniview/tui-react";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+// ../tui/dist/main.mjs
+const BLOCKS = "▁▂▃▄▅▆▇█";
+const clampPct = (value) => Math.min(100, Math.max(0, value));
+/** Absolute 0–100% scale so the shape never exaggerates small movements. Newest `width` points. */
+function sparkline(values, width) {
+	return values.filter((value) => Number.isFinite(value)).slice(-Math.max(0, width)).map((value) => BLOCKS[Math.round(clampPct(value) / 100 * 7)]).join("");
+}
+/**
+* One cell per column; the single `marker` cell is the white ideal-pace tick (time budget, not a forecast).
+* Fill represents remaining quota (`% left`), matching physical battery / tank intuition.
+*/
+function barCells(remainingPercent, idealRemainingPercent, width) {
+	const filled = Math.round(clampPct(remainingPercent) / 100 * width);
+	const cells = Array.from({ length: width }, (_, i) => i < filled ? "fill" : "empty");
+	if (idealRemainingPercent !== null && width > 0) cells[Math.round(clampPct(idealRemainingPercent) / 100 * (width - 1))] = "marker";
+	return cells;
+}
+function describeExhaustion(forecast) {
+	if (!forecast) return "No forecast yet · run `kuota collect --once`";
+	if (forecast.quality === "unsupported") return forecast.reasons.includes("ROLLING_WINDOW_UNMODELED") ? "Forecast unavailable · rolling window is not modeled" : "Forecast unavailable · window semantics unknown";
+	if (forecast.reasons.includes("ALREADY_EXHAUSTED")) return "Quota exhausted";
+	if (forecast.quality === "insufficient") return "Collecting data for a forecast…";
+	if (forecast.exhaustedAt) return `Est. exhaustion ${forecast.exhaustedAt} · confidence ${forecast.quality}`;
+	if (forecast.reasons.includes("STABLE_AT_CURRENT_ACTIVITY")) return "Stable at current activity";
+	return `On pace · not expected to exhaust before reset · confidence ${forecast.quality}`;
+}
+/** Ideal pace is shown only for windows whose fixed cadence is known; never guessed. */
+function windowPace(provider, window, now) {
+	const profile = windowProfile(provider, window.windowId);
+	const reset = window.resetAt ? new Date(window.resetAt) : null;
+	const start = reset && profile.durationMs !== null ? new Date(reset.getTime() - profile.durationMs) : null;
+	return calculatePace({
+		now,
+		startAt: start,
+		resetAt: reset,
+		usedPercent: window.usedPercent,
+		semantics: profile.semantics,
+		startSource: start ? "inferred" : "unknown"
+	});
+}
+/** Cycles through windows, then back to "all" (null). */
+function nextWindow(windowIds, current) {
+	if (windowIds.length === 0) return null;
+	if (current === null) return windowIds[0];
+	const index = windowIds.indexOf(current);
+	return index < 0 || index === windowIds.length - 1 ? null : windowIds[index + 1];
+}
+const seriesKey = (provider, windowId) => `${provider}/${windowId}`;
+const LABELS = {
+	codex: "Codex",
+	claude: "Claude Code",
+	antigravity: "Antigravity"
+};
+/** Strip control characters before potentially untrusted provider text reaches a terminal. */
+function safeTerminalText(value) {
+	return value.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+}
+const PROVIDER_ORDER = [
+	"codex",
+	"claude",
+	"antigravity"
+];
+const BAR_WIDTH = 24;
+/** Color of remaining balance fill: red when quota is low/critical, yellow when cautious, green when healthy. */
+function fillColor(remaining) {
+	return remaining <= 15 ? "red" : remaining <= 35 ? "yellow" : "green";
+}
+function bar(cells, remaining) {
+	const runs = [];
+	for (const kind of cells) {
+		const last = runs[runs.length - 1];
+		if (last && last.kind === kind) last.length += 1;
+		else runs.push({
+			kind,
+			length: 1
+		});
+	}
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "row",
+		children: runs.map((run, index) => run.kind === "marker" ? /* @__PURE__ */ jsx(Text, {
+			color: "white",
+			bold: true,
+			children: "┃".repeat(run.length)
+		}, index) : run.kind === "fill" ? /* @__PURE__ */ jsx(Text, {
+			color: fillColor(remaining),
+			children: "█".repeat(run.length)
+		}, index) : /* @__PURE__ */ jsx(Text, {
+			dim: true,
+			children: "░".repeat(run.length)
+		}, index))
+	});
+}
+function QuotaApp(props) {
+	const [inspectSnapshot, setInspectSnapshot] = React.useState(false);
+	useInput((input) => {
+		if (input === "q") props.onQuit();
+		else if (input === "r") props.onRefresh();
+		else if (input === "a") props.onSelect(null);
+		else if (input === "1") props.onSelect("codex");
+		else if (input === "2") props.onSelect("claude");
+		else if (input === "3") props.onSelect("antigravity");
+		else if (input === "s") setInspectSnapshot((prev) => !prev);
+		else if (input === "p") {
+			const index = props.selected ? PROVIDER_ORDER.indexOf(props.selected) : -1;
+			props.onSelect(index === PROVIDER_ORDER.length - 1 ? null : PROVIDER_ORDER[index + 1]);
+		} else if (input === "w") {
+			const ids = visible.flatMap((snapshot) => snapshot.windows.map((w) => w.windowId));
+			props.onSelectWindow?.(nextWindow([...new Set(ids)], props.selectedWindow ?? null));
+		}
+	});
+	const visible = props.selected ? props.snapshots.filter((snapshot) => snapshot.provider === props.selected) : props.snapshots;
+	const now = props.now ?? /* @__PURE__ */ new Date();
+	const showWindow = (w) => !props.selectedWindow || w.windowId === props.selectedWindow;
+	return /* @__PURE__ */ jsx(Panel, {
+		title: inspectSnapshot ? "Kuota · Snapshot Provenance Inspector" : "Kuota · AI subscription usage",
+		focused: true,
+		children: /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			children: [
+				/* @__PURE__ */ jsx(Text, {
+					bold: true,
+					children: inspectSnapshot ? "Raw Snapshot Inspector" : "Kuota"
+				}),
+				/* @__PURE__ */ jsx(Text, { children: inspectSnapshot ? "Field provenance, data source freshness, and raw timestamps" : props.loading ? "Refreshing provider quotas…" : "Live local provider snapshots" }),
+				/* @__PURE__ */ jsx(Text, { children: " " }),
+				visible.length === 0 && /* @__PURE__ */ jsx(Text, { children: props.loading ? "Loading…" : "No provider results" }),
+				inspectSnapshot ? visible.map((snapshot) => /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							color: "cyan",
+							children: `${LABELS[snapshot.provider]} · status: ${snapshot.status}`
+						}),
+						/* @__PURE__ */ jsx(Text, { children: `  source: ${snapshot.source} · fetchedAt: ${snapshot.fetchedAt}` }),
+						snapshot.errorCode && /* @__PURE__ */ jsx(Text, {
+							color: "red",
+							children: `  errorCode: ${safeTerminalText(snapshot.errorCode)}`
+						}),
+						snapshot.windows.filter(showWindow).map((window) => {
+							const profile = windowProfile(snapshot.provider, window.windowId);
+							return /* @__PURE__ */ jsxs(Box, {
+								flexDirection: "column",
+								children: [
+									/* @__PURE__ */ jsx(Text, { children: `  [window] ${safeTerminalText(window.windowId)}` }),
+									/* @__PURE__ */ jsx(Text, {
+										dim: true,
+										children: `    used: ${window.usedPercent ?? "null"}% | remaining: ${window.remainingPercent ?? "null"}%`
+									}),
+									/* @__PURE__ */ jsx(Text, {
+										dim: true,
+										children: `    resetAt: ${window.resetAt ?? "none"} | semantics: ${profile.semantics}`
+									})
+								]
+							}, window.windowId);
+						}),
+						/* @__PURE__ */ jsx(Text, { children: " " })
+					]
+				}, snapshot.provider)) : visible.map((snapshot) => /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							bold: true,
+							children: `${LABELS[snapshot.provider]} · ${snapshot.status}`
+						}),
+						snapshot.windows.length === 0 && /* @__PURE__ */ jsx(Text, { children: snapshot.errorCode ? safeTerminalText(snapshot.errorCode) : "quota unknown" }),
+						snapshot.windows.filter(showWindow).map((window) => {
+							const pace = windowPace(snapshot.provider, window, now);
+							const remaining = window.remainingPercent ?? (window.usedPercent !== null ? 100 - window.usedPercent : null);
+							const idealRemaining = pace ? 100 - pace.idealUsedPercent : null;
+							const history = props.series?.[seriesKey(snapshot.provider, window.windowId)] ?? [];
+							const forecast = props.forecasts?.find((f) => f.provider === snapshot.provider && f.windowId === window.windowId);
+							return /* @__PURE__ */ jsxs(Box, {
+								flexDirection: "column",
+								children: [
+									/* @__PURE__ */ jsx(Text, { children: `  ${safeTerminalText(window.windowId)}: ${remaining === null ? "unknown" : `${Math.round(remaining)}% remaining`}${window.resetAt ? ` · resets ${window.resetAt}` : ""}` }),
+									remaining !== null && /* @__PURE__ */ jsxs(Box, {
+										flexDirection: "row",
+										children: [
+											/* @__PURE__ */ jsx(Text, { children: "  " }),
+											bar(barCells(remaining, idealRemaining, BAR_WIDTH), remaining),
+											/* @__PURE__ */ jsx(Text, { children: ` ${Math.round(remaining)}% left${idealRemaining !== null && pace ? ` · ideal ${Math.round(idealRemaining)}% left (${pace.quality})` : ""}` })
+										]
+									}),
+									props.forecasts !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [history.length > 0 && /* @__PURE__ */ jsx(Text, {
+										dim: true,
+										children: `  trend ${sparkline(history, 30)}`
+									}), /* @__PURE__ */ jsx(Text, {
+										dim: true,
+										children: `  ${describeExhaustion(forecast)}`
+									})] })
+								]
+							}, window.windowId);
+						}),
+						/* @__PURE__ */ jsx(Text, { children: " " })
+					]
+				}, snapshot.provider)),
+				/* @__PURE__ */ jsx(Text, { children: "r refresh · 1/2/3/p provider · a all · w window · s snapshot inspect · q quit" })
+			]
+		})
+	});
+}
+const DAY = 864e5;
+/** Read-only: the TUI never writes the journal; `kuota collect --once` owns appends. */
+async function loadHistoryView(directory, now) {
+	try {
+		const { events } = await createLocalJsonlJournal({ directory }).readAll({
+			from: (/* @__PURE__ */ new Date(now.getTime() - 30 * DAY)).toISOString(),
+			to: now.toISOString()
+		});
+		const series = {};
+		const keys = /* @__PURE__ */ new Map();
+		for (const event of [...events].sort((a, b) => a.observedAt.localeCompare(b.observedAt))) {
+			if (event.kind !== "quota_observed" || event.usedPercent === null) continue;
+			const key = seriesKey(event.provider, event.windowId);
+			(series[key] ??= []).push(event.usedPercent);
+			keys.set(key, event);
+		}
+		return {
+			series,
+			forecasts: [...keys.values()].map((k) => buildForecastV1({
+				now,
+				provider: k.provider,
+				windowId: k.windowId,
+				observations: events,
+				mode: "all-window"
+			}))
+		};
+	} catch {
+		return {
+			series: {},
+			forecasts: []
+		};
+	}
+}
+function ensureInteractiveTerminal(inputIsTty, outputIsTty) {
+	if (!inputIsTty || !outputIsTty) throw new Error("Kuota TUI requires an interactive terminal; run `kuota status --json` instead.");
+}
+/** Interactive entrypoint. Consumers of @kuota/core never import or start this. */
+async function startTui() {
+	ensureInteractiveTerminal(Boolean(process.stdin.isTTY), Boolean(process.stdout.isTTY));
+	return new Promise((resolve, reject) => {
+		let stopped = false;
+		let loading = true;
+		let selected = null;
+		let selectedWindow = null;
+		let history = {
+			series: {},
+			forecasts: []
+		};
+		let snapshots = [];
+		let app;
+		const service = createQuotaService();
+		const rerender = () => {
+			if (!app || stopped) return;
+			app.render(/* @__PURE__ */ jsx(QuotaApp, {
+				snapshots,
+				loading,
+				selected,
+				selectedWindow,
+				series: history.series,
+				forecasts: history.forecasts,
+				onSelectWindow: (windowId) => {
+					selectedWindow = windowId;
+					rerender();
+				},
+				onRefresh: () => {
+					refresh();
+				},
+				onQuit: quit,
+				onSelect: (provider) => {
+					selected = provider;
+					selectedWindow = null;
+					rerender();
+				}
+			}));
+		};
+		const quit = () => {
+			if (stopped) return;
+			stopped = true;
+			process.off("SIGINT", quit);
+			queueMicrotask(() => {
+				try {
+					app?.destroy();
+					resolve();
+				} catch (error) {
+					reject(error);
+				}
+			});
+		};
+		const refresh = async () => {
+			if (stopped || loading) return;
+			loading = true;
+			rerender();
+			try {
+				snapshots = (await Effect.runPromise(service.read(PROVIDER_METADATA.map(({ id }) => id), { force: true }))).map((observation) => observation.snapshot);
+				history = await loadHistoryView(defaultHistoryDirectory(), /* @__PURE__ */ new Date());
+			} catch {} finally {
+				loading = false;
+				rerender();
+			}
+		};
+		try {
+			app = render(/* @__PURE__ */ jsx(QuotaApp, {
+				snapshots,
+				loading: true,
+				selected,
+				selectedWindow,
+				series: history.series,
+				forecasts: history.forecasts,
+				onSelectWindow: (windowId) => {
+					selectedWindow = windowId;
+					rerender();
+				},
+				onRefresh: () => {
+					refresh();
+				},
+				onQuit: quit,
+				onSelect: (provider) => {
+					selected = provider;
+					selectedWindow = null;
+					rerender();
+				}
+			}));
+			process.on("SIGINT", quit);
+			loading = false;
+			refresh();
+		} catch (error) {
+			process.off("SIGINT", quit);
+			reject(error);
+		}
+	});
+}
+export { startTui };

package/dist/metrics-Bzmrfgn-.mjs

@@ -0,0 +1,307 @@
+import "./src-y_QKmTyj.mjs";
+// ../core/src/normalize.ts
+function safePercent(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100 ? value : null;
+}
+function safeIsoDate(value) {
+	if (typeof value !== "string" && typeof value !== "number") return null;
+	const date = new Date(value);
+	return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+function normalizeWindow(input) {
+	const usedPercent = safePercent(input.usedPercent);
+	return {
+		windowId: input.windowId,
+		usedPercent,
+		remainingPercent: usedPercent === null ? null : Number((100 - usedPercent).toFixed(2)),
+		resetAt: safeIsoDate(input.resetAt)
+	};
+}
+/** Whitelist public response fields: never forward token-like keys or provider raw payloads. */
+function redactSnapshot(input) {
+	const provider = input.provider;
+	const status = input.status;
+	return {
+		provider: provider === "claude" || provider === "antigravity" ? provider : "codex",
+		status: status === "ok" || status === "partial" || status === "unauthenticated" || status === "unavailable" || status === "unsupported" || status === "error" ? status : "error",
+		fetchedAt: safeIsoDate(input.fetchedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+		source: typeof input.source === "string" ? input.source : "unknown",
+		windows: Array.isArray(input.windows) ? input.windows.flatMap((window) => {
+			if (!window || typeof window !== "object") return [];
+			const value = window;
+			if (typeof value.windowId !== "string") return [];
+			return [normalizeWindow({
+				windowId: value.windowId,
+				usedPercent: value.usedPercent,
+				resetAt: value.resetAt
+			})];
+		}) : [],
+		errorCode: typeof input.errorCode === "string" ? input.errorCode : null
+	};
+}
+function makeUnavailableSnapshot(provider, errorCode, status = "unavailable") {
+	return {
+		provider,
+		status,
+		fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "local-probe",
+		windows: [],
+		errorCode
+	};
+}
+// ../core/src/metrics/pace.ts
+/** Returns null when the provider has not proved a comparable fixed window. */
+function calculatePace(input) {
+	if (input.semantics === "rolling" || input.semantics === "unknown" || input.startSource === "unknown" || input.semantics === "first_use" && input.startSource !== "provider" || input.startAt === null || input.resetAt === null || input.usedPercent === null || !Number.isFinite(input.usedPercent) || input.usedPercent < 0 || input.usedPercent > 100) return null;
+	const now = input.now.getTime();
+	const start = input.startAt.getTime();
+	const reset = input.resetAt.getTime();
+	if (!Number.isFinite(now) || !Number.isFinite(start) || !Number.isFinite(reset) || reset <= start || now < start) return null;
+	const elapsedFraction = Math.min(1, (now - start) / (reset - start));
+	const idealUsedPercent = elapsedFraction * 100;
+	return {
+		elapsedFraction,
+		idealUsedPercent,
+		idealRemainingPercent: 100 - idealUsedPercent,
+		actualUsedPercent: input.usedPercent,
+		paceDeltaPoints: input.usedPercent - idealUsedPercent,
+		paceRatio: idealUsedPercent === 0 ? null : input.usedPercent / idealUsedPercent,
+		remainingHours: Math.max(0, reset - now) / 36e5,
+		quality: input.startSource === "provider" ? "exact" : "inferred"
+	};
+}
+// ../core/src/observation.ts
+function iso(ms) {
+	return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+/**
+* Pure constructor. If `snapshot.fetchedAt` is not a valid timestamp we fall back to the
+* injected `checkedAtMs` as the observation time, so no NaN / Invalid Date is ever emitted.
+*/
+function makeObservation(input) {
+	const parsed = Date.parse(input.snapshot.fetchedAt);
+	const observedMs = Number.isFinite(parsed) ? parsed : input.checkedAtMs;
+	const next = input.nextAttemptAtMs;
+	return {
+		snapshot: input.snapshot,
+		freshness: input.freshness,
+		observedAt: iso(observedMs),
+		checkedAt: iso(input.checkedAtMs),
+		ageMs: Math.max(0, input.nowMs - observedMs),
+		nextAttemptAt: next === null || next === void 0 || !Number.isFinite(next) ? null : iso(next),
+		latestErrorCode: input.latestErrorCode ?? null
+	};
+}
+// ../core/src/forecast/forecast.ts
+const H = 36e5;
+const EPOCH_TOLERANCE_MS = 6e5;
+const DECREASE_TOLERANCE = .5;
+const GAP_CAP_HOURS = 6;
+const RECENT_HOURS = 24;
+const STALE_LATEST_MS = 6 * H;
+const SLOPE_EPSILON = 1e-6;
+const LEVELS = [
+	"low",
+	"medium",
+	"high"
+];
+const ms = (iso) => iso === null ? NaN : Date.parse(iso);
+const boundary = (e) => {
+	const reset = ms(e.resetAt);
+	return Number.isFinite(reset) ? reset : ms(e.epochId);
+};
+function isMeasurable(e) {
+	return e.kind === "quota_observed" && (e.state === "ok" || e.state === "partial" || e.state === "stale") && e.usedPercent !== null && Number.isFinite(e.usedPercent) && Number.isFinite(ms(e.observedAt));
+}
+/**
+* Reset/epoch detection. A new segment starts when the provider-reported reset boundary moves
+* (beyond jitter tolerance) or when used% drops (credit / unannounced reset). Fixed windows only
+* ever compare points inside one segment.
+*/
+function detectEpochs(events) {
+	const sorted = events.filter(isMeasurable).map((e, i) => ({
+		e,
+		i
+	})).sort((a, b) => ms(a.e.observedAt) - ms(b.e.observedAt) || a.i - b.i).map(({ e }) => e);
+	const segments = [];
+	let lastTime = NaN;
+	for (const event of sorted) {
+		const time = ms(event.observedAt);
+		if (time === lastTime) continue;
+		lastTime = time;
+		const current = segments[segments.length - 1];
+		const prev = current?.events[current.events.length - 1];
+		if (!current || !prev) {
+			segments.push({
+				events: [event],
+				reason: null
+			});
+			continue;
+		}
+		const a = boundary(prev);
+		const b = boundary(event);
+		if (Number.isFinite(a) && Number.isFinite(b) && Math.abs(a - b) > EPOCH_TOLERANCE_MS) segments.push({
+			events: [event],
+			reason: "EPOCH_RESET_DETECTED"
+		});
+		else if (event.usedPercent < prev.usedPercent - DECREASE_TOLERANCE) segments.push({
+			events: [event],
+			reason: "USAGE_DECREASE_SPLIT"
+		});
+		else current.events.push(event);
+	}
+	return segments;
+}
+function weightedMedian(items) {
+	const sorted = [...items].sort((a, b) => a.value - b.value);
+	const total = sorted.reduce((sum, item) => sum + item.weight, 0);
+	let acc = 0;
+	for (const item of sorted) {
+		acc += item.weight;
+		if (acc >= total / 2) return item.value;
+	}
+	return 0;
+}
+const unsupported = (reasons) => ({
+	slopePercentPerHour: null,
+	exhaustedAt: null,
+	projectedUsedAtResetPercent: null,
+	sampleCount: 0,
+	observedSpanHours: 0,
+	quality: "unsupported",
+	reasons
+});
+function forecastQuota(input) {
+	const segments = detectEpochs(input.observations);
+	const last = segments[segments.length - 1];
+	if (!last) return {
+		...unsupported([]),
+		quality: "insufficient",
+		reasons: ["NO_OBSERVATIONS"]
+	};
+	const latest = last.events[last.events.length - 1];
+	if (latest.semantics === "rolling") return unsupported(["ROLLING_WINDOW_UNMODELED"]);
+	if (latest.semantics === "unknown") return unsupported(["WINDOW_SEMANTICS_UNKNOWN"]);
+	const reasons = [];
+	if (last.reason) reasons.push(last.reason);
+	let samples = last.events;
+	const latestMs = ms(latest.observedAt);
+	if (input.mode === "recent-activity") samples = samples.filter((e) => ms(e.observedAt) >= latestMs - RECENT_HOURS * H);
+	const first = samples[0];
+	const spanHours = (latestMs - ms(first.observedAt)) / H;
+	const used = latest.usedPercent;
+	const base = {
+		sampleCount: samples.length,
+		observedSpanHours: spanHours
+	};
+	if (samples.length < 3 || spanHours < 2) return {
+		...base,
+		slopePercentPerHour: null,
+		exhaustedAt: used >= 100 ? latest.observedAt : null,
+		projectedUsedAtResetPercent: null,
+		quality: "insufficient",
+		reasons: [
+			...reasons,
+			"INSUFFICIENT_DATA",
+			...used >= 100 ? ["ALREADY_EXHAUSTED"] : []
+		]
+	};
+	const intervals = [];
+	let changes = 0;
+	for (let i = 1; i < samples.length; i++) {
+		const dt = (ms(samples[i].observedAt) - ms(samples[i - 1].observedAt)) / H;
+		const du = samples[i].usedPercent - samples[i - 1].usedPercent;
+		if (dt <= 0 || du < 0) continue;
+		if (du > 0) changes++;
+		intervals.push({
+			value: du / dt,
+			weight: Math.min(dt, GAP_CAP_HOURS)
+		});
+	}
+	const slope = input.mode === "all-window" ? (used - first.usedPercent) / spanHours : weightedMedian(intervals);
+	const positive = intervals.filter((i) => i.value > 0).map((i) => i.value);
+	const mean = positive.reduce((a, b) => a + b, 0) / (positive.length || 1);
+	const variance = positive.reduce((a, b) => a + (b - mean) ** 2, 0) / (positive.length || 1);
+	const lowVariability = mean > 0 && Math.sqrt(variance) / mean < .5;
+	let level = 0;
+	if (spanHours >= 24 && used >= 10) level = 1;
+	if (spanHours >= 72 && changes >= 20 && lowVariability && used >= 10) level = 2;
+	else if (spanHours >= 24 && changes < 6) level = 0;
+	if (samples.some((s) => s.state === "stale")) {
+		reasons.push("STALE_INPUT");
+		level = Math.max(0, level - 1);
+	}
+	if (input.now.getTime() - latestMs > STALE_LATEST_MS) {
+		reasons.push("LATEST_SAMPLE_OLD");
+		level = Math.max(0, level - 1);
+	}
+	const quality = LEVELS[level];
+	const resetMs = input.resetAt ? input.resetAt.getTime() : boundary(latest);
+	const hasReset = Number.isFinite(resetMs);
+	const roundedSlope = Math.max(0, slope);
+	let exhaustedAt = null;
+	let projected = null;
+	if (used >= 100) {
+		exhaustedAt = latest.observedAt;
+		projected = 100;
+		reasons.push("ALREADY_EXHAUSTED");
+	} else if (roundedSlope <= SLOPE_EPSILON) {
+		reasons.push("STABLE_AT_CURRENT_ACTIVITY");
+		projected = used;
+	} else {
+		const exhaustMs = latestMs + (100 - used) / roundedSlope * H;
+		projected = Math.min(100, used + roundedSlope * (hasReset ? Math.max(0, resetMs - latestMs) / H : 0));
+		if (!hasReset || exhaustMs <= resetMs) {
+			exhaustedAt = new Date(exhaustMs).toISOString();
+			reasons.push("EXHAUSTION_BEFORE_RESET");
+		} else reasons.push("ON_PACE");
+		if (!hasReset) projected = null;
+	}
+	return {
+		...base,
+		slopePercentPerHour: roundedSlope,
+		exhaustedAt,
+		projectedUsedAtResetPercent: projected,
+		quality,
+		reasons
+	};
+}
+/** Account-safe wrapper: only events sharing the newest event's accountScope are considered. */
+function buildForecastV1(input) {
+	const scoped = input.observations.filter((e) => e.provider === input.provider && e.windowId === input.windowId && isMeasurable(e)).sort((a, b) => ms(a.observedAt) - ms(b.observedAt));
+	const newest = scoped[scoped.length - 1];
+	const events = newest ? scoped.filter((e) => e.accountScope === newest.accountScope) : [];
+	const result = forecastQuota({
+		now: input.now,
+		resetAt: null,
+		observations: events,
+		mode: input.mode
+	});
+	const latest = events[events.length - 1];
+	const pace = latest ? calculatePace({
+		now: input.now,
+		startAt: latest.startAt ? new Date(latest.startAt) : null,
+		resetAt: latest.resetAt ? new Date(latest.resetAt) : null,
+		usedPercent: latest.usedPercent,
+		semantics: latest.semantics,
+		startSource: latest.startAt ? "inferred" : "unknown"
+	}) : null;
+	return {
+		schemaVersion: 1,
+		provider: input.provider,
+		windowId: input.windowId,
+		computedAt: input.now.toISOString(),
+		currentUsedPercent: latest ? latest.usedPercent : null,
+		idealUsedPercent: pace ? pace.idealUsedPercent : null,
+		observedSpanHours: result.observedSpanHours,
+		sampleCount: result.sampleCount,
+		slopePercentPerHour: result.slopePercentPerHour,
+		exhaustedAt: result.exhaustedAt,
+		projectedUsedAtResetPercent: result.projectedUsedAtResetPercent,
+		expectedTimeToLimitHours: result.exhaustedAt ? Math.max(0, (Date.parse(result.exhaustedAt) - input.now.getTime()) / H) : null,
+		mode: input.mode,
+		quality: result.quality,
+		reasons: [...result.reasons]
+	};
+}
+export { makeObservation as a, normalizeWindow as c, isMeasurable as i, redactSnapshot as l, detectEpochs as n, calculatePace as o, forecastQuota as r, makeUnavailableSnapshot as s, buildForecastV1 as t };

package/dist/metrics-D7oNul_9.d.mts

@@ -0,0 +1,30 @@
+import "./index-NHzh2TGn.mjs";
+/** A linear *time budget* reference; this is not a statistically inferred forecast. */
+interface PaceInput {
+  now: Date;
+  startAt: Date | null;
+  resetAt: Date | null;
+  usedPercent: number | null;
+  semantics: "fixed" | "rolling" | "first_use" | "unknown";
+  startSource: "provider" | "inferred" | "unknown";
+}
+interface PaceResult {
+  /** 0 at the window start, 1 at the reset boundary. */
+  elapsedFraction: number;
+  /** Position of the white tick on a *used* progress bar. */
+  idealUsedPercent: number;
+  /** Position of the white tick on a *remaining* progress bar. */
+  idealRemainingPercent: number;
+  actualUsedPercent: number;
+  /** Positive means consumption is ahead of linear elapsed-time pace. */
+  paceDeltaPoints: number;
+  paceRatio: number | null;
+  remainingHours: number;
+  /** "inferred" is never presented as an exact provider-reported epoch. */
+  quality: "exact" | "inferred";
+}
+/** Returns null when the provider has not proved a comparable fixed window. */
+declare function calculatePace(input: PaceInput): PaceResult | null;
+/** Dependency-free SHA-256 (hex). Keeps @kuota/core free of node:crypto so it stays browser-safe. */
+declare function sha256Hex(text: string): string;
+export { calculatePace as i, PaceInput as n, PaceResult as r, sha256Hex as t };

package/dist/metrics.d.mts

@@ -0,0 +1,3 @@
+import { _ as normalizeWindow, a as detectEpochs, g as makeUnavailableSnapshot, h as makeObservation, i as buildForecastV1, n as ForecastQuality, o as forecastQuota, p as windowProfile, r as QuotaForecastV1, s as isMeasurable, t as ForecastMode, u as WindowProfile, v as redactSnapshot } from "./index-NHzh2TGn.mjs";
+import { i as calculatePace, n as PaceInput, r as PaceResult, t as sha256Hex } from "./metrics-D7oNul_9.mjs";
+export { type ForecastMode, type ForecastQuality, type PaceInput, type PaceResult, type QuotaForecastV1, type WindowProfile, buildForecastV1, calculatePace, detectEpochs, forecastQuota, isMeasurable, makeObservation, makeUnavailableSnapshot, normalizeWindow, redactSnapshot, sha256Hex, windowProfile };

package/dist/metrics.mjs

@@ -0,0 +1,3 @@
+import { a as sha256Hex, i as windowProfile } from "./src-y_QKmTyj.mjs";
+import { a as makeObservation, c as normalizeWindow, i as isMeasurable, l as redactSnapshot, n as detectEpochs, o as calculatePace, r as forecastQuota, s as makeUnavailableSnapshot, t as buildForecastV1 } from "./metrics-Bzmrfgn-.mjs";
+export { buildForecastV1, calculatePace, detectEpochs, forecastQuota, isMeasurable, makeObservation, makeUnavailableSnapshot, normalizeWindow, redactSnapshot, sha256Hex, windowProfile };