dsh-plugin-subscription-oauth 0.7.0 → 0.8.0

package/lib/auth/allowance-scheduler.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Cross-request memory of when each provider account's allowance resets.
+ *
+ * This is what lets one model id draw on the whole account pool without a wasted
+ * request: when the default account's allowance runs out, the moment it will refill is
+ * remembered, and until then the scheduler sends work straight to another account
+ * instead of trying the spent one, failing, and only then moving on. When the reset
+ * time passes the spent account is first choice again.
+ *
+ * The holder is shared by the route's reader (which learns reset times from usage
+ * reads) and its streamer (which consults them when picking an account), so the
+ * scheduler's view is exactly the last read's.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/allowance-scheduler
+ */
+/** One account's remembered allowance state. */
+export interface AllowanceState {
+    /** Epoch milliseconds at which the account's allowance resets, when known. */
+    resetsAt?: number;
+    /** Epoch milliseconds at which this state was last learned. */
+    learnedAt: number;
+}
+/** In-memory, per-provider memory of account reset times. */
+export declare class AllowanceScheduler {
+    private readonly byProvider;
+    /** One provider's account states, creating the map on first use. */
+    private provider;
+    /**
+     * Record that one account's allowance resets at a given moment.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @param resetsAt - epoch milliseconds of the allowance reset, when known.
+     */
+    noteReset(provider: string, account: string, resetsAt?: number): void;
+    /**
+     * Whether one account's allowance is known to be spent now.
+     *
+     * True when the account was recorded with a reset time that is still in the future:
+     * its allowance is spent and will not refill until then, so a request should go to a
+     * different account rather than fail against this one.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns whether the account's allowance is spent until its remembered reset.
+     */
+    isSpentUntilReset(provider: string, account: string): boolean;
+    /**
+     * The moment one account's allowance is known to reset, when it was recorded.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns the reset instant, or undefined when unknown or already passed.
+     */
+    resetAt(provider: string, account: string): number | undefined;
+}
+/** The one shared scheduler every route reads and writes. */
+export declare const allowanceScheduler: AllowanceScheduler;

package/lib/auth/allowance-scheduler.js

@@ -0,0 +1,72 @@
+/**
+ * Cross-request memory of when each provider account's allowance resets.
+ *
+ * This is what lets one model id draw on the whole account pool without a wasted
+ * request: when the default account's allowance runs out, the moment it will refill is
+ * remembered, and until then the scheduler sends work straight to another account
+ * instead of trying the spent one, failing, and only then moving on. When the reset
+ * time passes the spent account is first choice again.
+ *
+ * The holder is shared by the route's reader (which learns reset times from usage
+ * reads) and its streamer (which consults them when picking an account), so the
+ * scheduler's view is exactly the last read's.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/allowance-scheduler
+ */
+/** In-memory, per-provider memory of account reset times. */
+export class AllowanceScheduler {
+    byProvider = new Map();
+    /** One provider's account states, creating the map on first use. */
+    provider(provider) {
+        let map = this.byProvider.get(provider);
+        if (map === undefined) {
+            map = new Map();
+            this.byProvider.set(provider, map);
+        }
+        return map;
+    }
+    /**
+     * Record that one account's allowance resets at a given moment.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @param resetsAt - epoch milliseconds of the allowance reset, when known.
+     */
+    noteReset(provider, account, resetsAt) {
+        this.provider(provider).set(account, { ...resetsAt === undefined ? {} : { resetsAt }, learnedAt: Date.now() });
+    }
+    /**
+     * Whether one account's allowance is known to be spent now.
+     *
+     * True when the account was recorded with a reset time that is still in the future:
+     * its allowance is spent and will not refill until then, so a request should go to a
+     * different account rather than fail against this one.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns whether the account's allowance is spent until its remembered reset.
+     */
+    isSpentUntilReset(provider, account) {
+        const state = this.byProvider.get(provider)?.get(account);
+        if (state === undefined)
+            return false;
+        if (state.resetsAt === undefined)
+            return false;
+        return Date.now() < state.resetsAt;
+    }
+    /**
+     * The moment one account's allowance is known to reset, when it was recorded.
+     *
+     * @param provider - the provider route id.
+     * @param account - the account key.
+     * @returns the reset instant, or undefined when unknown or already passed.
+     */
+    resetAt(provider, account) {
+        const state = this.byProvider.get(provider)?.get(account);
+        if (state === undefined || state.resetsAt === undefined)
+            return undefined;
+        return Date.now() < state.resetsAt ? state.resetsAt : undefined;
+    }
+}
+/** The one shared scheduler every route reads and writes. */
+export const allowanceScheduler = new AllowanceScheduler();

package/lib/client/UsageChip.d.ts

@@ -117,10 +117,12 @@ export declare function balanceOf(value: {
  * Format one wallet for the chip's compact line.
  *
  * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
- * the currency prefix keeps two currencies from being mistaken for one sum.
+ * the currency prefix keeps two currencies from being mistaken for one sum. The amount
+ * is rounded to two decimal places (a balance reads to the cent, and a figure like
+ * `1.1` for `1.10` would mislead) and always carries both places.
  *
  * @param wallet - the wallet to show.
- * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ * @returns the short form, e.g. `¥6.89` or `+$2.00` for a bonus wallet.
  */
 export declare function formatBalance(wallet: ChipBalance): string;
 /**
@@ -157,6 +159,60 @@ export declare function pickWindow(windows: readonly UsageWindow[]): UsageWindow
  * @param usage - the accounts the route answered for.
  * @returns the reading, or undefined when the route stated no figure.
  */
+/** What one account's allowance reduces to for the chip. */
+export interface AccountReading {
+    /** Which account these figures belong to. */
+    account: string;
+    /** Plan name, when the provider stated one. */
+    plan?: string;
+    /** Every metered window, in the order the route stated them. */
+    windows: readonly UsageWindow[];
+}
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say), and the chip
+ * shows each one's allowance on its own line, the way the settings cards do — a merged
+ * figure would hide that one account is exhausted while the other is free.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states a figure, in the route's order.
+ */
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say). Every account's
+ * windows are kept as the route stated them — a percentage-metered quota and a credit
+ * balance (`credits`) alike — so the per-account panel shows the real figures, and the
+ * compact line's merge decides which to integrate.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states any window, in the route's order.
+ */
+export declare function accountReadingsOf(usage: readonly ProviderUsage[]): readonly AccountReading[];
+/**
+ * Merge every account's percentage-metered windows into one figure per label.
+ *
+ * The chip's compact line integrates the whole pool: two accounts at 50 percent read as
+ * one window at 50 percent (the same allowance spent twice as wide), not two lines. A
+ * credit balance (`credits`) is money, not a share of a shared allowance, so it is not
+ * merged — it stays on the per-account panel, where it reads correctly. Only windows
+ * that state a `usedPercent` (a share of an allowance) merge.
+ *
+ * @param readings - one per account, from {@link accountReadingsOf}.
+ * @returns one merged window per percentage-metered label, most-spent first.
+ */
+export declare function mergeAccountWindows(readings: readonly AccountReading[]): readonly UsageWindow[];
+/**
+ * Reduce one route's usage to the single line the compact chip renders.
+ *
+ * Kept for the balance-free providers that still show one merged line.
+ *
+ * @param provider - the route id.
+ * @param label - the route's display name.
+ * @param usage - the accounts the route answered for.
+ * @returns the first account's reading, or undefined when none states a figure.
+ */
 export declare function readingOf(provider: string, label: string, usage: readonly ProviderUsage[]): ChipReading | undefined;
 /**
  * Format a window's reset the way the settings cards do.

package/lib/client/UsageChip.js

@@ -82,14 +82,16 @@ export function balanceOf(value) {
  * Format one wallet for the chip's compact line.
  *
  * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
- * the currency prefix keeps two currencies from being mistaken for one sum.
+ * the currency prefix keeps two currencies from being mistaken for one sum. The amount
+ * is rounded to two decimal places (a balance reads to the cent, and a figure like
+ * `1.1` for `1.10` would mislead) and always carries both places.
  *
  * @param wallet - the wallet to show.
- * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ * @returns the short form, e.g. `¥6.89` or `+$2.00` for a bonus wallet.
  */
 export function formatBalance(wallet) {
     const amount = Number.parseFloat(wallet.balance);
-    const trimmed = Number.isFinite(amount) ? String(Math.round(amount * 100) / 100) : wallet.balance;
+    const trimmed = Number.isFinite(amount) ? amount.toFixed(2) : wallet.balance;
     const symbol = wallet.currency === 'CNY' ? '¥' : wallet.currency === 'USD' ? '$' : `${wallet.currency} `;
     return `${wallet.bonus ? '+' : ''}${symbol}${trimmed}`;
 }
@@ -142,12 +144,90 @@ export function pickWindow(windows) {
     return best;
 }
 /**
- * Reduce one route's usage to what the chip renders.
+ * Reduce a route's per-account usage to one reading per account.
  *
- * @param provider - the route the figures came from.
+ * A provider can hold several accounts (two Antigravity sign-ins, say), and the chip
+ * shows each one's allowance on its own line, the way the settings cards do — a merged
+ * figure would hide that one account is exhausted while the other is free.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states a figure, in the route's order.
+ */
+/**
+ * Reduce a route's per-account usage to one reading per account.
+ *
+ * A provider can hold several accounts (two Antigravity sign-ins, say). Every account's
+ * windows are kept as the route stated them — a percentage-metered quota and a credit
+ * balance (`credits`) alike — so the per-account panel shows the real figures, and the
+ * compact line's merge decides which to integrate.
+ *
+ * @param usage - every account the route answered for.
+ * @returns one reading per account that states any window, in the route's order.
+ */
+export function accountReadingsOf(usage) {
+    const out = [];
+    for (const entry of usage) {
+        if (entry.windows.length === 0)
+            continue;
+        out.push({ account: entry.account, windows: entry.windows, ...entry.plan === undefined ? {} : { plan: entry.plan } });
+    }
+    return out;
+}
+/**
+ * Merge every account's percentage-metered windows into one figure per label.
+ *
+ * The chip's compact line integrates the whole pool: two accounts at 50 percent read as
+ * one window at 50 percent (the same allowance spent twice as wide), not two lines. A
+ * credit balance (`credits`) is money, not a share of a shared allowance, so it is not
+ * merged — it stays on the per-account panel, where it reads correctly. Only windows
+ * that state a `usedPercent` (a share of an allowance) merge.
+ *
+ * @param readings - one per account, from {@link accountReadingsOf}.
+ * @returns one merged window per percentage-metered label, most-spent first.
+ */
+export function mergeAccountWindows(readings) {
+    const byLabel = new Map();
+    for (const reading of readings) {
+        for (const window of reading.windows) {
+            // Only a percentage-metered window merges. A credit balance (a bare used/limit
+            // pair) is money, not a share of a shared allowance, and averaging it across
+            // accounts would misread money as a quota.
+            if (window.usedPercent === undefined)
+                continue;
+            const list = byLabel.get(window.label) ?? [];
+            list.push(window);
+            byLabel.set(window.label, list);
+        }
+    }
+    const merged = [];
+    for (const [label, list] of byLabel) {
+        // Percentages average across accounts: the pool's spent share is the mean of each
+        // account's spent share (accounts share an allowance, they do not add to it).
+        const withPercent = list.filter((window) => window.usedPercent !== undefined);
+        if (withPercent.length === 0)
+            continue;
+        const usedPercent = withPercent.reduce((sum, window) => sum + (window.usedPercent ?? 0), 0) / withPercent.length;
+        // The pool's reset is the soonest account reset: the window refills when the first
+        // account's does.
+        const resets = list.map((window) => window.resetsAt).filter((at) => typeof at === 'number');
+        merged.push({
+            label,
+            usedPercent: Math.max(0, Math.min(100, usedPercent)),
+            ...resets.length === 0 ? {} : { resetsAt: Math.min(...resets) },
+        });
+    }
+    // Most-spent first, so the line leads with the window that will stop work soonest.
+    return merged.sort((left, right) => (right.usedPercent ?? 0) - (left.usedPercent ?? 0));
+}
+/**
+ * Reduce one route's usage to the single line the compact chip renders.
+ *
+ * Kept for the balance-free providers that still show one merged line.
+ *
+ * @param provider - the route id.
  * @param label - the route's display name.
  * @param usage - the accounts the route answered for.
- * @returns the reading, or undefined when the route stated no figure.
+ * @returns the first account's reading, or undefined when none states a figure.
  */
 export function readingOf(provider, label, usage) {
     for (const entry of usage) {
@@ -197,6 +277,7 @@ export function formatReset(at, now) {
  */
 export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, useProjection }) {
     const [reading, setReading] = useState(undefined);
+    const [accountReadings, setAccountReadings] = useState(undefined);
     const [balance, setBalance] = useState(undefined);
     const [ccBalance, setCcBalance] = useState(undefined);
     const [now, setNow] = useState(() => Date.now());
@@ -239,8 +320,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
     const load = useCallback(async (target) => {
         try {
             const result = await call('usage', { provider: target });
-            const label = result.status.providers.find((entry) => entry.provider === target)?.displayName ?? target;
-            return readingOf(target, label, result.usage);
+            return accountReadingsOf(result.usage);
         }
         catch {
             // A failed read is not worth a chip of its own: the settings page is where a user
@@ -276,7 +356,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
             // Not one of ours (or none selected): keep showing the last own reading.
             : lastOwn.current;
         if (target === undefined) {
-            setReading(undefined);
+            setAccountReadings(undefined);
             return;
         }
         let live = true;
@@ -286,7 +366,7 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
                 if (!live || next === undefined)
                     return;
                 lastOwn.current = target;
-                setReading(next);
+                setAccountReadings(next);
             });
         };
         refresh();
@@ -327,20 +407,22 @@ export function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBala
                         setOpen((was) => !was);
                     }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-cell", children: _jsx("span", { className: "dsh-subscription-usage-chip-value", children: formatBalance(wallet) }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: 'DeepSeek Account' }) }), balance.map((wallet) => (_jsx("span", { className: "dsh-subscription-usage-chip-meter", children: _jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: `${wallet.bonus ? 'Bonus · ' : ''}${wallet.currency}` }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: formatBalance(wallet) })] }) }, `${wallet.currency}${wallet.bonus ? ':bonus' : ''}`)))] }))] }));
     }
-    if (reading === undefined)
-        return null;
-    const percent = reading.window.usedPercent;
-    if (percent === undefined)
+    if (accountReadings === undefined || accountReadings.length === 0)
         return null;
-    const reset = formatReset(reading.window.resetsAt, now);
-    const clamped = Math.max(0, Math.min(100, percent));
-    const short = shortLabel(reading.provider, reading.label);
-    return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: reading.label }), onClick: (event) => {
+    const short = shortLabel(selected ?? '', selected ?? '');
+    // The compact line integrates the whole pool; the panel shows each account's own
+    // figures, so a merged glance hides nothing a per-account look cannot recover.
+    const merged = mergeAccountWindows(accountReadings);
+    return (_jsxs("span", { className: "dsh-subscription-usage-chip", children: [_jsx("style", { children: usageChipCss }), _jsxs("button", { type: "button", className: "dsh-subscription-usage-chip-trigger", "aria-expanded": open, title: t('usageChipTitle', { provider: selected ?? '' }), onClick: (event) => {
                     // The document listener would otherwise close what this click just opened.
                     event.stopPropagation();
                     setOpen((was) => !was);
-                }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), reading.windows.map((window) => (_jsxs("span", { className: "dsh-subscription-usage-chip-cell", children: [_jsx("span", { className: "dsh-subscription-usage-chip-window", children: shortWindow(window.label) }), _jsx("span", { className: "dsh-subscription-usage-chip-value", children: `${String(Math.round(window.usedPercent ?? 0))}%` })] }, window.label)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: reading.label }) }), reading.windows.map((window) => {
-                        const windowReset = formatReset(window.resetsAt, now);
-                        return (_jsxs("span", { className: "dsh-subscription-usage-chip-meter", children: [_jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: window.label }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: `${String(Math.round(window.usedPercent ?? 0))}%${windowReset === undefined ? '' : ` · ${windowReset}`}` })] }), _jsx("span", { className: "dsh-subscription-usage-chip-track", "aria-hidden": "true", children: _jsx("span", { className: "dsh-subscription-usage-chip-fill", style: { width: `${String(Math.max(0, Math.min(100, window.usedPercent ?? 0)))}%` } }) })] }, window.label));
-                    }), reading.plan === undefined ? null : (_jsx("span", { className: "dsh-subscription-usage-chip-detail", children: reading.plan }))] }))] }));
+                }, children: [_jsx("span", { className: "dsh-subscription-usage-chip-label", children: short }), merged.map((window) => (_jsxs("span", { className: "dsh-subscription-usage-chip-cell", children: [_jsx("span", { className: "dsh-subscription-usage-chip-window", children: shortWindow(window.label) }), _jsx("span", { className: "dsh-subscription-usage-chip-value", children: `${String(Math.round(window.usedPercent ?? 0))}%` })] }, window.label)))] }), open && (_jsxs("span", { className: "dsh-subscription-usage-chip-panel", role: "status", children: [_jsx("span", { className: "dsh-subscription-usage-chip-full", children: t('usageChipFull', { provider: selected ?? '' }) }), accountReadings.map((account) => (_jsxs("span", { className: "dsh-subscription-usage-chip-account", children: [_jsx("span", { className: "dsh-subscription-usage-chip-meterHead", children: _jsx("span", { children: account.plan ?? account.account }) }), account.windows.map((window) => {
+                                const windowReset = formatReset(window.resetsAt, now);
+                                // A credit balance reads as money (`used`/`limit`), a quota as a percent.
+                                const amount = window.usedPercent === undefined && window.used !== undefined && window.limit !== undefined
+                                    ? `${String(window.used)}/${String(window.limit)}`
+                                    : `${String(Math.round(window.usedPercent ?? 0))}%`;
+                                return (_jsxs("span", { className: "dsh-subscription-usage-chip-meter", children: [_jsxs("span", { className: "dsh-subscription-usage-chip-meterHead", children: [_jsx("span", { children: window.label }), _jsx("span", { className: "dsh-subscription-usage-chip-detail", children: `${amount}${windowReset === undefined ? '' : ` · ${windowReset}`}` })] }), window.usedPercent !== undefined && (_jsx("span", { className: "dsh-subscription-usage-chip-track", "aria-hidden": "true", children: _jsx("span", { className: "dsh-subscription-usage-chip-fill", style: { width: `${String(Math.max(0, Math.min(100, window.usedPercent ?? 0)))}%` } }) }))] }, window.label));
+                            })] }, account.account)))] }))] }));
 }

package/lib/client.js

@@ -2300,14 +2300,16 @@ function balanceOf(value) {
 * Format one wallet for the chip's compact line.
 *
 * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
-* the currency prefix keeps two currencies from being mistaken for one sum.
+* the currency prefix keeps two currencies from being mistaken for one sum. The amount
+* is rounded to two decimal places (a balance reads to the cent, and a figure like
+* `1.1` for `1.10` would mislead) and always carries both places.
 *
 * @param wallet - the wallet to show.
-* @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+* @returns the short form, e.g. `¥6.89` or `+$2.00` for a bonus wallet.
 */
 function formatBalance(wallet) {
 	const amount = Number.parseFloat(wallet.balance);
-	const trimmed = Number.isFinite(amount) ? String(Math.round(amount * 100) / 100) : wallet.balance;
+	const trimmed = Number.isFinite(amount) ? amount.toFixed(2) : wallet.balance;
 	const symbol = wallet.currency === "CNY" ? "¥" : wallet.currency === "USD" ? "$" : `${wallet.currency} `;
 	return `${wallet.bonus ? "+" : ""}${symbol}${trimmed}`;
 }
@@ -2336,43 +2338,71 @@ function shortWindow(label) {
 	return label.length <= 4 ? label : label.slice(0, 4);
 }
 /**
-* Pick the window a single line should show.
+* Reduce a route's per-account usage to one reading per account.
 *
-* A plan can meter several windows at once (a rolling five-hour one and a weekly one).
-* The most constrained is the one that will stop work soonest, so it earns the space;
-* ties fall to the earlier window, which is the order the providers state them in.
+* A provider can hold several accounts (two Antigravity sign-ins, say), and the chip
+* shows each one's allowance on its own line, the way the settings cards do — a merged
+* figure would hide that one account is exhausted while the other is free.
 *
-* @param windows - the route's metered windows.
-* @returns the window to show, or undefined when none states a figure.
+* @param usage - every account the route answered for.
+* @returns one reading per account that states a figure, in the route's order.
 */
-function pickWindow(windows) {
-	let best;
-	for (const window$1 of windows) {
-		if (window$1.usedPercent === void 0) continue;
-		if (best?.usedPercent === void 0 || window$1.usedPercent > best.usedPercent) best = window$1;
+/**
+* Reduce a route's per-account usage to one reading per account.
+*
+* A provider can hold several accounts (two Antigravity sign-ins, say). Every account's
+* windows are kept as the route stated them — a percentage-metered quota and a credit
+* balance (`credits`) alike — so the per-account panel shows the real figures, and the
+* compact line's merge decides which to integrate.
+*
+* @param usage - every account the route answered for.
+* @returns one reading per account that states any window, in the route's order.
+*/
+function accountReadingsOf(usage) {
+	const out = [];
+	for (const entry of usage) {
+		if (entry.windows.length === 0) continue;
+		out.push({
+			account: entry.account,
+			windows: entry.windows,
+			...entry.plan === void 0 ? {} : { plan: entry.plan }
+		});
 	}
-	return best;
+	return out;
 }
 /**
-* Reduce one route's usage to what the chip renders.
+* Merge every account's percentage-metered windows into one figure per label.
+*
+* The chip's compact line integrates the whole pool: two accounts at 50 percent read as
+* one window at 50 percent (the same allowance spent twice as wide), not two lines. A
+* credit balance (`credits`) is money, not a share of a shared allowance, so it is not
+* merged — it stays on the per-account panel, where it reads correctly. Only windows
+* that state a `usedPercent` (a share of an allowance) merge.
 *
-* @param provider - the route the figures came from.
-* @param label - the route's display name.
-* @param usage - the accounts the route answered for.
-* @returns the reading, or undefined when the route stated no figure.
+* @param readings - one per account, from {@link accountReadingsOf}.
+* @returns one merged window per percentage-metered label, most-spent first.
 */
-function readingOf(provider, label, usage) {
-	for (const entry of usage) {
-		const window$1 = pickWindow(entry.windows);
-		if (window$1 === void 0) continue;
-		return {
-			provider,
+function mergeAccountWindows(readings) {
+	const byLabel = /* @__PURE__ */ new Map();
+	for (const reading of readings) for (const window$1 of reading.windows) {
+		if (window$1.usedPercent === void 0) continue;
+		const list = byLabel.get(window$1.label) ?? [];
+		list.push(window$1);
+		byLabel.set(window$1.label, list);
+	}
+	const merged = [];
+	for (const [label, list] of byLabel) {
+		const withPercent = list.filter((window$1) => window$1.usedPercent !== void 0);
+		if (withPercent.length === 0) continue;
+		const usedPercent = withPercent.reduce((sum, window$1) => sum + (window$1.usedPercent ?? 0), 0) / withPercent.length;
+		const resets = list.map((window$1) => window$1.resetsAt).filter((at) => typeof at === "number");
+		merged.push({
 			label,
-			windows: entry.windows.filter((candidate) => candidate.usedPercent !== void 0),
-			window: window$1,
-			...entry.plan === void 0 ? {} : { plan: entry.plan }
-		};
+			usedPercent: Math.max(0, Math.min(100, usedPercent)),
+			...resets.length === 0 ? {} : { resetsAt: Math.min(...resets) }
+		});
 	}
+	return merged.sort((left, right) => (right.usedPercent ?? 0) - (left.usedPercent ?? 0));
 }
 /**
 * Format a window's reset the way the settings cards do.
@@ -2402,6 +2432,7 @@ function formatReset(at, now) {
 */
 function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, useProjection }) {
 	const [reading, setReading] = (0, react.useState)(void 0);
+	const [accountReadings, setAccountReadings] = (0, react.useState)(void 0);
 	const [balance, setBalance] = (0, react.useState)(void 0);
 	const [ccBalance, setCcBalance] = (0, react.useState)(void 0);
 	const [now, setNow] = (0, react.useState)(() => Date.now());
@@ -2438,8 +2469,7 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 	]);
 	const load = (0, react.useCallback)(async (target) => {
 		try {
-			const result = await call("usage", { provider: target });
-			return readingOf(target, result.status.providers.find((entry) => entry.provider === target)?.displayName ?? target, result.usage);
+			return accountReadingsOf((await call("usage", { provider: target })).usage);
 		} catch {
 			return;
 		}
@@ -2465,7 +2495,7 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 	(0, react.useEffect)(() => {
 		const target = selected !== void 0 && isOwnProvider(selected) ? selected : lastOwn.current;
 		if (target === void 0) {
-			setReading(void 0);
+			setAccountReadings(void 0);
 			return;
 		}
 		let live = true;
@@ -2474,7 +2504,7 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 			load(target).then((next) => {
 				if (!live || next === void 0) return;
 				lastOwn.current = target;
-				setReading(next);
+				setAccountReadings(next);
 			});
 		};
 		refresh();
@@ -2592,10 +2622,9 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 			]
 		});
 	}
-	if (reading === void 0) return null;
-	if (reading.window.usedPercent === void 0) return null;
-	formatReset(reading.window.resetsAt, now);
-	const short = shortLabel(reading.provider, reading.label);
+	if (accountReadings === void 0 || accountReadings.length === 0) return null;
+	const short = shortLabel(selected ?? "", selected ?? "");
+	const merged = mergeAccountWindows(accountReadings);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 		className: "dsh-subscription-usage-chip",
 		children: [
@@ -2604,7 +2633,7 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 				type: "button",
 				className: "dsh-subscription-usage-chip-trigger",
 				"aria-expanded": open,
-				title: t("usageChipTitle", { provider: reading.label }),
+				title: t("usageChipTitle", { provider: selected ?? "" }),
 				onClick: (event) => {
 					event.stopPropagation();
 					setOpen((was) => !was);
@@ -2612,7 +2641,7 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 					className: "dsh-subscription-usage-chip-label",
 					children: short
-				}), reading.windows.map((window$1) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+				}), merged.map((window$1) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 					className: "dsh-subscription-usage-chip-cell",
 					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 						className: "dsh-subscription-usage-chip-window",
@@ -2626,22 +2655,26 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 			open && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 				className: "dsh-subscription-usage-chip-panel",
 				role: "status",
-				children: [
-					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-						className: "dsh-subscription-usage-chip-full",
-						children: t("usageChipFull", { provider: reading.label })
-					}),
-					reading.windows.map((window$1) => {
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dsh-subscription-usage-chip-full",
+					children: t("usageChipFull", { provider: selected ?? "" })
+				}), accountReadings.map((account) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+					className: "dsh-subscription-usage-chip-account",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-subscription-usage-chip-meterHead",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: account.plan ?? account.account })
+					}), account.windows.map((window$1) => {
 						const windowReset = formatReset(window$1.resetsAt, now);
+						const amount = window$1.usedPercent === void 0 && window$1.used !== void 0 && window$1.limit !== void 0 ? `${String(window$1.used)}/${String(window$1.limit)}` : `${String(Math.round(window$1.usedPercent ?? 0))}%`;
 						return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 							className: "dsh-subscription-usage-chip-meter",
 							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 								className: "dsh-subscription-usage-chip-meterHead",
 								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: window$1.label }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 									className: "dsh-subscription-usage-chip-detail",
-									children: `${String(Math.round(window$1.usedPercent ?? 0))}%${windowReset === void 0 ? "" : ` · ${windowReset}`}`
+									children: `${amount}${windowReset === void 0 ? "" : ` · ${windowReset}`}`
 								})]
-							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							}), window$1.usedPercent !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 								className: "dsh-subscription-usage-chip-track",
 								"aria-hidden": "true",
 								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
@@ -2650,12 +2683,8 @@ function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, us
 								})
 							})]
 						}, window$1.label);
-					}),
-					reading.plan === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-						className: "dsh-subscription-usage-chip-detail",
-						children: reading.plan
-					})
-				]
+					})]
+				}, account.account))]
 			})
 		]
 	});