@diousk/pi-usage-fast 0.1.0

package/src/providers/fireworks.ts

@@ -0,0 +1,291 @@
+import { sanitizeDisplayText } from "../core.js";
+import type {
+  FireworksAccountsPayload,
+  FireworksBillingSummaryPayload,
+  ResolvedUsageAuth,
+  UsageMetric,
+  UsageProviderAdapter,
+  UsageReport,
+} from "../types.js";
+
+const NANOS_PER_UNIT = 1_000_000_000n;
+const CURRENCY_PATTERN = /^[A-Z]{3}$/u;
+const ACCOUNT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,127}$/u;
+const INTEGER_PATTERN = /^-?\d+$/u;
+const INT64_MIN = -(2n ** 63n);
+const INT64_MAX = 2n ** 63n - 1n;
+const MAX_UNITS_CHARS = 20;
+const MAX_NANOS_CHARS = 11;
+const FIREWORKS_BILLING_SUMMARY_ORIGIN = "https://api.fireworks.ai";
+const FIREWORKS_SPEND_WINDOW_DAYS = 30;
+const FIREWORKS_MAX_ACCOUNT_PAGES = 5;
+
+const SERIES_KEYS = ["serverless", "dedicated", "training", "other"] as const;
+type SeriesKey = (typeof SERIES_KEYS)[number];
+
+const SERIES_LABELS: Readonly<Record<SeriesKey, string>> = {
+  serverless: "Serverless",
+  dedicated: "Dedicated deployments",
+  training: "Training",
+  other: "Other",
+};
+
+export function isFireworksAccountId(value: unknown): value is string {
+  return typeof value === "string" && ACCOUNT_ID_PATTERN.test(value);
+}
+
+export function normalizeFireworksAccountsPayload(payload: FireworksAccountsPayload): string[] {
+  if (!Array.isArray(payload.accounts)) {
+    throw new Error("Fireworks accounts response did not contain an accounts array.");
+  }
+  const accounts: string[] = [];
+  for (const raw of payload.accounts) {
+    const account = asObject(raw);
+    if (!account) throw new Error("Fireworks accounts response row was not an object.");
+    if (typeof account.name !== "string") {
+      throw new Error("Fireworks accounts response omitted the account resource name.");
+    }
+    const match = /^accounts\/([^/]+)$/u.exec(account.name);
+    if (!match || !isFireworksAccountId(match[1])) {
+      throw new Error("Fireworks accounts response returned an unsafe account resource name.");
+    }
+    const accountId = match[1];
+    if (accounts.includes(accountId)) {
+      throw new Error(`Fireworks accounts response repeated ${accountId}.`);
+    }
+    accounts.push(accountId);
+  }
+  return accounts;
+}
+
+type FetchProviderJson = (
+  url: string,
+  auth: ResolvedUsageAuth,
+  signal: AbortSignal,
+  timeoutMs: number,
+  description: string,
+  request?: { redirect?: RequestRedirect },
+) => Promise<Record<string, unknown>>;
+
+export function createFireworksAdapter(fetchProviderJson: FetchProviderJson): UsageProviderAdapter {
+  return {
+    id: "fireworks",
+    displayName: "Fireworks",
+    semantics: { kind: "api-key", label: "Fireworks API spend" },
+    targets: {
+      singularLabel: "account",
+      pluralLabel: "accounts",
+      async list(auth, signal, timeoutMs, guard) {
+        const startedAt = Date.now();
+        const accounts: string[] = [];
+        let pageToken: string | undefined;
+        for (let page = 0; page < FIREWORKS_MAX_ACCOUNT_PAGES; page += 1) {
+          await guard();
+          const payload = (await fetchProviderJson(
+            fireworksAccountsUrl(pageToken),
+            auth,
+            signal,
+            remainingTimeout(timeoutMs, startedAt, "fetching Fireworks accounts"),
+            "Fireworks accounts endpoint",
+            { redirect: "error" },
+          )) as FireworksAccountsPayload;
+          await guard();
+          for (const accountId of normalizeFireworksAccountsPayload(payload)) {
+            if (accounts.includes(accountId)) {
+              throw new Error(`Fireworks accounts listing repeated ${accountId}.`);
+            }
+            accounts.push(accountId);
+          }
+          pageToken = fireworksNextPageToken(payload.nextPageToken);
+          if (!pageToken) break;
+        }
+        if (pageToken) {
+          throw new Error(`Fireworks account listing exceeded ${FIREWORKS_MAX_ACCOUNT_PAGES} pages.`);
+        }
+        return accounts.map((id) => ({ id, label: id }));
+      },
+    },
+    async query(auth, signal, timeoutMs, guard, targetId) {
+      if (!guard) throw new Error("Fireworks API spend requires request-boundary revalidation.");
+      if (!isFireworksAccountId(targetId)) {
+        throw new Error("Fireworks billing requires a safe selected account slug.");
+      }
+      const startedAt = Date.now();
+      await guard();
+      const billingWindowAt = Date.now();
+      const payload = (await fetchProviderJson(
+        fireworksBillingSummaryUrl(targetId, billingWindowAt),
+        auth,
+        signal,
+        remainingTimeout(timeoutMs, startedAt, "fetching Fireworks rated spend"),
+        "Fireworks billing summary endpoint",
+        { redirect: "error" },
+      )) as FireworksBillingSummaryPayload;
+      await guard();
+      return normalizeFireworksBillingSummaryPayload(payload, targetId, Date.now());
+    },
+  };
+}
+
+export function normalizeFireworksBillingSummaryPayload(
+  payload: FireworksBillingSummaryPayload,
+  accountId: string,
+  capturedAt: number,
+): UsageReport {
+  if (!isFireworksAccountId(accountId)) {
+    throw new Error("Fireworks billing summary received an unsafe account identifier.");
+  }
+  if (payload.lineItems !== undefined && !Array.isArray(payload.lineItems)) {
+    throw new Error("Fireworks billing summary lineItems was not an array.");
+  }
+
+  const totals = new Map<string, Map<SeriesKey, bigint>>();
+  for (const raw of payload.lineItems ?? []) {
+    const lineItem = asObject(raw);
+    if (!lineItem) throw new Error("Fireworks billing line item was not an object.");
+    const cost = moneyAmount(lineItem.totalCost, "line item total cost");
+    const series = seriesKey(lineItem.series);
+    let amounts = totals.get(cost.currency);
+    if (!amounts) {
+      amounts = new Map<SeriesKey, bigint>();
+      totals.set(cost.currency, amounts);
+    }
+    amounts.set(series, (amounts.get(series) ?? 0n) + cost.amount);
+  }
+
+  const metrics: UsageMetric[] = [];
+  for (const [currency, amounts] of totals) {
+    metrics.push({
+      id: `${currency.toLowerCase()}-total`,
+      label: "Total spend",
+      value: formatMoneyAmount(sumSeries(amounts)),
+      unit: "currency",
+      currency,
+    });
+    for (const series of SERIES_KEYS) {
+      const amount = amounts.get(series);
+      if (amount === undefined) continue;
+      metrics.push({
+        id: `${currency.toLowerCase()}-${series}`,
+        label: SERIES_LABELS[series],
+        value: formatMoneyAmount(amount),
+        unit: "currency",
+        currency,
+      });
+    }
+  }
+
+  const notes = ["Rated line items may differ from the final invoice once credits or adjustments are applied."];
+  if (metrics.length === 0) {
+    notes.push("Fireworks returned no rated line items for the last 30 days.");
+  }
+
+  return {
+    providerId: "fireworks",
+    providerName: "Fireworks",
+    capturedAt,
+    source: "fireworks-billing-summary",
+    semantics: { kind: "api-key", label: "Fireworks API spend" },
+    accountLabel: sanitizeDisplayText(accountId, 80),
+    buckets: [],
+    metrics,
+    notes,
+  };
+}
+
+type RatedMoney = { currency: string; amount: bigint };
+
+function moneyAmount(value: unknown, description: string): RatedMoney {
+  const money = asObject(value);
+  if (!money) throw new Error(`Fireworks billing ${description} was not a money object.`);
+  const currency = typeof money.currencyCode === "string" ? money.currencyCode : undefined;
+  if (!currency || !CURRENCY_PATTERN.test(currency)) {
+    throw new Error(`Fireworks billing ${description} currency was not an ISO 4217 code.`);
+  }
+  // proto3 JSON omits zero-valued money fields, so absent components default to zero.
+  const units =
+    money.units === undefined ? 0n : integerComponent(money.units, description, "whole units", MAX_UNITS_CHARS);
+  if (units < INT64_MIN || units > INT64_MAX) {
+    throw new Error(`Fireworks billing ${description} whole units exceeded the int64 range.`);
+  }
+  const nanos =
+    money.nanos === undefined ? 0n : integerComponent(money.nanos, description, "nano units", MAX_NANOS_CHARS);
+  if (nanos <= -NANOS_PER_UNIT || nanos >= NANOS_PER_UNIT) {
+    throw new Error(`Fireworks billing ${description} nano units exceeded the Money range.`);
+  }
+  if ((units > 0n && nanos < 0n) || (units < 0n && nanos > 0n)) {
+    throw new Error(`Fireworks billing ${description} mixed unit and nano signs.`);
+  }
+  return { currency, amount: units * NANOS_PER_UNIT + nanos };
+}
+
+function integerComponent(value: unknown, description: string, component: string, maxChars: number): bigint {
+  const text =
+    typeof value === "number" && Number.isSafeInteger(value)
+      ? String(value)
+      : typeof value === "string" && INTEGER_PATTERN.test(value)
+        ? value
+        : undefined;
+  if (text === undefined || text.length > maxChars) {
+    throw new Error(`Fireworks billing ${description} ${component} was not a bounded integer.`);
+  }
+  return BigInt(text);
+}
+
+function seriesKey(value: unknown): SeriesKey {
+  if (value === undefined || value === null) return "other";
+  if (typeof value !== "string") throw new Error("Fireworks billing line item series was invalid.");
+  if (value === "SERVERLESS") return "serverless";
+  if (value === "DEDICATED_DEPLOYMENT") return "dedicated";
+  if (value === "TRAINING") return "training";
+  return "other";
+}
+
+function sumSeries(amounts: ReadonlyMap<SeriesKey, bigint>): bigint {
+  let total = 0n;
+  for (const amount of amounts.values()) total += amount;
+  return total;
+}
+
+function formatMoneyAmount(amount: bigint): string {
+  const negative = amount < 0n;
+  const magnitude = negative ? -amount : amount;
+  const units = magnitude / NANOS_PER_UNIT;
+  const nanos = (magnitude % NANOS_PER_UNIT).toString().padStart(9, "0").replace(/0+$/u, "");
+  return `${negative ? "-" : ""}${units.toString()}${nanos ? `.${nanos}` : ""}`;
+}
+
+function fireworksAccountsUrl(pageToken: string | undefined): string {
+  const url = new URL("/v1/accounts", FIREWORKS_BILLING_SUMMARY_ORIGIN);
+  url.searchParams.set("pageSize", "200");
+  if (pageToken !== undefined) url.searchParams.set("pageToken", pageToken);
+  return url.toString();
+}
+
+function fireworksNextPageToken(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "string" || !value || value.length > 512) {
+    throw new Error("Fireworks accounts listing returned an invalid page token.");
+  }
+  return value;
+}
+
+function fireworksBillingSummaryUrl(accountId: string, startedAt: number): string {
+  const dayMs = 24 * 60 * 60 * 1000;
+  const dayFloor = (time: number) => `${new Date(time).toISOString().slice(0, 10)}T00:00:00Z`;
+  const url = new URL(`/v1/accounts/${accountId}/billing/summary`, FIREWORKS_BILLING_SUMMARY_ORIGIN);
+  url.searchParams.set("startTime", dayFloor(startedAt - (FIREWORKS_SPEND_WINDOW_DAYS - 1) * dayMs));
+  url.searchParams.set("endTime", dayFloor(startedAt + dayMs));
+  return url.toString();
+}
+
+function remainingTimeout(timeoutMs: number, startedAt: number, description: string): number {
+  const remaining = timeoutMs - (Date.now() - startedAt);
+  if (remaining <= 0) throw new Error(`Timed out while ${description}.`);
+  return remaining;
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}

package/src/providers/github-copilot.ts

@@ -0,0 +1,114 @@
+import { sanitizeDisplayText } from "../core.js";
+import type { GitHubCopilotUsagePayload, UsageBucket, UsageReport } from "../types.js";
+
+export function normalizeGitHubCopilotUsagePayload(
+  payload: GitHubCopilotUsagePayload,
+  capturedAt: number,
+): UsageReport {
+  const snapshots = asObject(payload.quota_snapshots);
+  const premium = asObject(snapshots?.premium_interactions);
+  const metrics: UsageReport["metrics"] = [];
+  let semanticsLabel: string;
+  let bucket: UsageBucket;
+
+  if (premium) {
+    const tokenBasedBilling = premium.token_based_billing === true;
+    const id = tokenBasedBilling ? "ai-credits" : "premium-requests";
+    const label = tokenBasedBilling ? "AI credits" : "Premium requests";
+    semanticsLabel = tokenBasedBilling ? "GitHub Copilot AI Credits allowance" : "GitHub Copilot premium request quota";
+
+    if (premium.unlimited === true) {
+      bucket = { id, label, unit: "count" };
+    } else {
+      const entitlement = asNonnegativeNumber(premium.entitlement);
+      const rawRemaining = asFiniteNumber(premium.remaining) ?? asFiniteNumber(premium.quota_remaining);
+      if (entitlement === undefined || rawRemaining === undefined) {
+        throw new Error(`GitHub Copilot ${label.toLowerCase()} quota was incomplete.`);
+      }
+      const overageUsed = Math.max(asNonnegativeNumber(premium.overage_count) ?? 0, Math.max(0, -rawRemaining));
+      if (overageUsed > 0) {
+        metrics.push({
+          id: "overage-used",
+          label: "Additional usage",
+          value: overageUsed,
+          unit: "count",
+        });
+      }
+      bucket = {
+        id,
+        label,
+        used: asNonnegativeNumber(premium.credits_used) ?? Math.max(0, entitlement - rawRemaining),
+        remaining: Math.max(0, rawRemaining),
+        limit: entitlement,
+        unit: "count",
+        period: "monthly",
+        ...resetTimestamp(payload),
+      };
+    }
+  } else {
+    const limited = asObject(payload.limited_user_quotas);
+    const monthly = asObject(payload.monthly_quotas);
+    const remaining = asNonnegativeNumber(limited?.chat);
+    const entitlement = asNonnegativeNumber(monthly?.chat);
+    if (remaining === undefined || entitlement === undefined) {
+      throw new Error("GitHub Copilot usage response contained no supported quota.");
+    }
+    semanticsLabel = "GitHub Copilot Free chat quota";
+    bucket = {
+      id: "chat-requests",
+      label: "Chat requests",
+      used: Math.max(0, entitlement - remaining),
+      remaining,
+      limit: entitlement,
+      unit: "count",
+      period: "monthly",
+      ...resetTimestamp(payload),
+    };
+  }
+
+  const notes: string[] = [];
+  const plan = asString(payload.copilot_plan) ?? asString(payload.access_type_sku);
+  if (plan) notes.push(`Plan: ${plan}`);
+
+  return {
+    providerId: "github-copilot",
+    providerName: "GitHub Copilot",
+    capturedAt,
+    source: "github-copilot-user",
+    semantics: { kind: "consumer-subscription", label: semanticsLabel },
+    accountLabel: asString(payload.login),
+    buckets: [bucket],
+    metrics,
+    ...(notes.length > 0 ? { notes } : {}),
+  };
+}
+
+function resetTimestamp(payload: GitHubCopilotUsagePayload): { resetsAt?: number } {
+  const raw =
+    asString(payload.quota_reset_date_utc) ??
+    asString(payload.quota_reset_date) ??
+    asString(payload.limited_user_reset_date);
+  if (!raw) return {};
+  const milliseconds = Date.parse(raw);
+  return Number.isNaN(milliseconds) ? {} : { resetsAt: Math.floor(milliseconds / 1000) };
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+function asString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  return sanitizeDisplayText(value, 80) || undefined;
+}
+
+function asFiniteNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+  return value;
+}
+
+function asNonnegativeNumber(value: unknown): number | undefined {
+  const number = asFiniteNumber(value);
+  return number === undefined || number < 0 ? undefined : number;
+}

package/src/providers/kimi-coding.ts

@@ -0,0 +1,265 @@
+import { sanitizeDisplayText } from "../core.js";
+import type { KimiCodingUsagePayload, UsageBucket, UsageMetric, UsageReport } from "../types.js";
+
+const FIVE_HOUR_WINDOW_MINUTES = 300;
+const DAILY_WINDOW_MINUTES = 1_440;
+const WEEKLY_WINDOW_MINUTES = 10_080;
+const FIXED_POINT_UNITS_PER_CENT = 1_000_000;
+
+/**
+ * Source contract revalidated on 2026-08-27.
+ * Pi c49906ec77788625aacbdc53ebca6fbe65bd20f5 defines provider `kimi-coding`,
+ * `https://api.kimi.com/coding`, API-key auth, and OAuth Bearer auth:
+ * https://github.com/earendil-works/pi/blob/c49906ec77788625aacbdc53ebca6fbe65bd20f5/packages/ai/src/providers/kimi-coding.ts
+ * https://github.com/earendil-works/pi/blob/c49906ec77788625aacbdc53ebca6fbe65bd20f5/packages/ai/src/auth/oauth/kimi-coding.ts
+ * Kimi Code 676e4d82240855044fe809fea89ce1dbe8e512cf defines `GET /coding/v1/usages`,
+ * numeric-string plan rows, proto-style windows, and 1,000,000 fixed-point units per cent:
+ * https://github.com/MoonshotAI/kimi-code/blob/676e4d82240855044fe809fea89ce1dbe8e512cf/packages/oauth/src/managed-usage.ts
+ * Live responses observed on 2026-09-12 omit both `used` and `remaining` on untouched rows and may report only
+ * `remaining` once usage starts, so a row with a positive `limit` and no counters means zero usage, and when only
+ * one counter is present the other is derived from `limit`. Counters that are present but malformed stay rejected.
+ */
+export function normalizeKimiCodingUsagePayload(payload: KimiCodingUsagePayload, capturedAt: number): UsageReport {
+  const root = asObject(payload);
+  if (!root) throw new Error("Kimi Coding usage response was not an object.");
+
+  const candidates: UsageBucket[] = [];
+  let omittedWindow = false;
+  const summary = parseUsageRow(root.usage, WEEKLY_WINDOW_MINUTES, "Weekly window");
+  if (summary) candidates.push(summary);
+  else if (root.usage !== undefined) omittedWindow = true;
+
+  if (Array.isArray(root.limits)) {
+    for (const raw of root.limits) {
+      const item = asObject(raw);
+      const windowMinutes = parseWindowMinutes(item?.window);
+      const label = sanitizedLabel(item?.name);
+      const bucket =
+        windowMinutes === undefined
+          ? undefined
+          : parseUsageRow(item?.detail, windowMinutes, label ?? defaultWindowLabel(windowMinutes));
+      if (bucket) candidates.push(bucket);
+      else omittedWindow = true;
+    }
+  } else if (root.limits !== undefined) {
+    omittedWindow = true;
+  }
+
+  const buckets: UsageBucket[] = [];
+  const byWindow = new Map<number, UsageBucket[]>();
+  for (const bucket of candidates) {
+    const windowMinutes = bucket.windowMinutes as number;
+    byWindow.set(windowMinutes, [...(byWindow.get(windowMinutes) ?? []), bucket]);
+  }
+  for (const rows of byWindow.values()) {
+    if (rows.length === 1) buckets.push(rows[0] as UsageBucket);
+    else omittedWindow = true;
+  }
+  buckets.sort((left, right) => (left.windowMinutes ?? 0) - (right.windowMinutes ?? 0));
+
+  const metrics = parseBoosterWallet(root.boosterWallet);
+  if (buckets.length === 0 && metrics.length === 0) {
+    throw new Error("Kimi Coding usage endpoint returned no displayable usage data.");
+  }
+
+  return {
+    providerId: "kimi-coding",
+    providerName: "Kimi For Coding",
+    capturedAt,
+    source: "kimi-managed-usage",
+    semantics: { kind: "consumer-subscription", label: "Kimi Coding Plan usage" },
+    buckets,
+    metrics,
+    ...(omittedWindow ? { notes: ["Unsupported, malformed, or duplicate plan windows were unavailable."] } : {}),
+  };
+}
+
+function parseUsageRow(value: unknown, windowMinutes: number, label: string): UsageBucket | undefined {
+  const row = asObject(value);
+  if (!row) return undefined;
+  const limit = asNonnegativeInteger(row.limit);
+  if (limit === undefined || limit === 0) return undefined;
+  const usedRaw = asNonnegativeInteger(row.used);
+  const remainingRaw = asNonnegativeInteger(row.remaining);
+  // Counters that are present but malformed reject the row instead of silently inventing a count.
+  if (
+    (row.used !== undefined && usedRaw === undefined) ||
+    (row.remaining !== undefined && remainingRaw === undefined)
+  ) {
+    return undefined;
+  }
+  // Live responses omit both counters on untouched rows, so a bare `limit` means zero usage.
+  const used = usedRaw ?? (remainingRaw === undefined ? 0 : Math.max(0, limit - remainingRaw));
+  const remaining = remainingRaw ?? Math.max(0, limit - used);
+  const resetsAt = asIsoEpochSeconds(row.resetTime);
+  return {
+    id: windowId(windowMinutes),
+    label,
+    used,
+    remaining,
+    limit,
+    unit: "count",
+    windowMinutes,
+    ...(resetsAt !== undefined ? { resetsAt } : {}),
+  };
+}
+
+function parseWindowMinutes(value: unknown): number | undefined {
+  const window = asObject(value);
+  if (!window) return undefined;
+  const duration = asPositiveInteger(window.duration);
+  if (duration === undefined) return undefined;
+  const multiplier =
+    window.timeUnit === "TIME_UNIT_MINUTE"
+      ? 1
+      : window.timeUnit === "TIME_UNIT_HOUR"
+        ? 60
+        : window.timeUnit === "TIME_UNIT_DAY"
+          ? 1_440
+          : window.timeUnit === "TIME_UNIT_WEEK"
+            ? 10_080
+            : undefined;
+  if (multiplier === undefined) return undefined;
+  const minutes = duration * multiplier;
+  return Number.isSafeInteger(minutes) ? minutes : undefined;
+}
+
+function parseBoosterWallet(value: unknown): UsageMetric[] {
+  const wallet = asObject(value);
+  const balance = asObject(wallet?.balance);
+  if (!wallet || !balance || balance.type !== "BOOSTER") return [];
+  const totalRaw = asPositiveInteger(balance.amount);
+  if (totalRaw === undefined) return [];
+  const leftRaw = asNonnegativeInteger(balance.amountLeft) ?? 0;
+  const monthlyLimit = parseMoney(wallet.monthlyChargeLimit);
+  const monthlyUsed = parseMoney(wallet.monthlyUsed);
+  const currencies = new Set(
+    [monthlyLimit?.currency, monthlyUsed?.currency].filter((currency): currency is string => currency !== undefined),
+  );
+  if (currencies.size !== 1) return [];
+  const currency = currencies.values().next().value;
+  if (!currency) return [];
+  const total = fixedPointToMajor(totalRaw);
+  const left = fixedPointToMajor(leftRaw);
+  if (total === undefined || left === undefined) return [];
+
+  const metrics: UsageMetric[] = [
+    { id: "booster-balance", label: "Balance", value: left, unit: "currency", currency },
+    { id: "booster-total", label: "Total balance", value: total, unit: "currency", currency },
+  ];
+  if (monthlyUsed) {
+    metrics.push({
+      id: "booster-monthly-used",
+      label: "Used this month",
+      value: monthlyUsed.cents / 100,
+      unit: "currency",
+      currency,
+    });
+  }
+  if (wallet.monthlyChargeLimitEnabled === false) {
+    metrics.push({
+      id: "booster-monthly-limit",
+      label: "Monthly limit",
+      value: "unlimited",
+      unit: "currency",
+      currency,
+    });
+  } else if (wallet.monthlyChargeLimitEnabled === true && monthlyLimit) {
+    metrics.push({
+      id: "booster-monthly-limit",
+      label: "Monthly limit",
+      value: monthlyLimit.cents / 100,
+      unit: "currency",
+      currency,
+    });
+  }
+  return metrics;
+}
+
+function parseMoney(value: unknown): { cents: number; currency: string } | undefined {
+  const money = asObject(value);
+  if (!money) return undefined;
+  const cents = asNonnegativeInteger(money.priceInCents);
+  if (cents === undefined) return undefined;
+  const currency = asCurrency(money.currency);
+  if (!currency) return undefined;
+  return { cents, currency };
+}
+
+function fixedPointToMajor(value: number): number | undefined {
+  const cents = value / FIXED_POINT_UNITS_PER_CENT;
+  const roundedCents = cents > 0 && cents < 1 ? 1 : Math.round(cents);
+  const major = roundedCents / 100;
+  return Number.isSafeInteger(roundedCents) && Number.isFinite(major) ? major : undefined;
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+function asNonnegativeInteger(value: unknown): number | undefined {
+  if (typeof value === "string" && !/^\d+$/u.test(value)) return undefined;
+  const number = typeof value === "string" ? Number(value) : value;
+  if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0) return undefined;
+  return number;
+}
+
+function asPositiveInteger(value: unknown): number | undefined {
+  const number = asNonnegativeInteger(value);
+  return number !== undefined && number > 0 ? number : undefined;
+}
+
+function asIsoEpochSeconds(value: unknown): number | undefined {
+  if (typeof value !== "string") return undefined;
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|([+-])(\d{2}):(\d{2}))$/u.exec(value);
+  if (!match) return undefined;
+  const [, yearText, monthText, dayText, hourText, minuteText, secondText, , offsetHour, offsetMinute] = match;
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const hour = Number(hourText);
+  const minute = Number(minuteText);
+  const second = Number(secondText);
+  if (
+    month < 1 ||
+    month > 12 ||
+    day < 1 ||
+    day > new Date(Date.UTC(year, month, 0)).getUTCDate() ||
+    hour > 23 ||
+    minute > 59 ||
+    second > 59 ||
+    (offsetHour !== undefined && Number(offsetHour) > 23) ||
+    (offsetMinute !== undefined && Number(offsetMinute) > 59)
+  ) {
+    return undefined;
+  }
+  const millis = Date.parse(value);
+  return Number.isFinite(millis) && millis >= 0 ? Math.floor(millis / 1000) : undefined;
+}
+
+function sanitizedLabel(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  return sanitizeDisplayText(value, 80) || undefined;
+}
+
+function asCurrency(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const currency = sanitizeDisplayText(value, 3).toUpperCase();
+  return /^[A-Z]{3}$/u.test(currency) ? currency : undefined;
+}
+
+function windowId(minutes: number): string {
+  if (minutes === FIVE_HOUR_WINDOW_MINUTES) return "five-hour";
+  if (minutes === DAILY_WINDOW_MINUTES) return "daily";
+  if (minutes === WEEKLY_WINDOW_MINUTES) return "weekly";
+  return `window-${minutes}-minutes`;
+}
+
+function defaultWindowLabel(minutes: number): string {
+  if (minutes === WEEKLY_WINDOW_MINUTES) return "Weekly window";
+  if (minutes % 10_080 === 0) return `${minutes / 10_080}w window`;
+  if (minutes % 1_440 === 0) return `${minutes / 1_440}d window`;
+  if (minutes % 60 === 0) return `${minutes / 60}h window`;
+  return `${minutes}m window`;
+}