oc-codex-multi-auth 6.20.0 → 6.22.0

package/dist/lib/quota-overview.js

@@ -0,0 +1,707 @@
+/**
+ * One constant line describing the whole account pool.
+ *
+ * The prompt status line names whichever account served the most recent
+ * request, so on a pool of several accounts it changes identity as rotation
+ * moves - and a reader who wants to know where the pool stands has to watch it
+ * long enough to see every account go past. This module renders the pool
+ * instead: every account at once, in a fixed order, so the line only changes
+ * when the underlying quota does.
+ *
+ * ```text
+ * 24%: #1 5x 13%, #2 20x 100% 3d 1r, #3 1x 12%
+ * ```
+ *
+ * The leading figure is the pool total, and it is a WEIGHTED mean rather than
+ * a plain one. A Pro seat spent to 50% has given up twenty times the capacity
+ * a Business Standard seat does at 50%, so averaging the percentages
+ * unweighted describes a pool nobody has; `lib/plan-allotment.ts` supplies the
+ * per-plan ratio the mean is taken over.
+ *
+ * Percentages follow `quotaDisplay` like every other surface, so the same pool
+ * reads `24%` as headroom or `76%` as consumption. Only the wording changes:
+ * every decision here - which window governs an account, which account is
+ * closest to recovering, whether a reset time is worth the characters - stays
+ * keyed on the percentage remaining.
+ *
+ * Everything below is pure string work over already-gathered readings, so the
+ * whole rendering can be exercised without a network, a clock or a terminal.
+ */
+import { maskEmailForDisplay } from "./account-display.js";
+import { formatPlanMultiplier, getPlanWeight } from "./plan-allotment.js";
+import { formatQuotaPercent, toQuotaDisplayPercent, } from "./quota-display.js";
+const MS_PER_MINUTE = 60_000;
+const MS_PER_HOUR = 60 * MS_PER_MINUTE;
+const MS_PER_DAY = 24 * MS_PER_HOUR;
+/**
+ * Under `resetTimes: "low"`, only an account at or below this headroom gets
+ * its reset time printed.
+ *
+ * Every account has a reset, and printing all of them triples the length of
+ * the line to say "this account you are not waiting on recovers at some point
+ * too". The threshold matches the one the single-account status line already
+ * uses to decide the same question, so an account near exhaustion reads the
+ * same way in either mode. `resetTimes: "always"` opts out of the threshold,
+ * because 90% spent with an hour to go and 90% spent with six days to go are
+ * not the same situation.
+ */
+export const OVERVIEW_RESET_LEFT_PERCENT = 25;
+/** Smallest pool-total movement worth spending characters on. */
+const MIN_RECOVERY_DELTA_PERCENT = 1;
+function isPercent(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+/**
+ * Render a duration the way a countdown reads: the largest unit that fits,
+ * floored, so `2d` never claims more time remains than actually does. A gap
+ * under a minute still reads `1m` rather than `0m`, because a reset that has
+ * not happened yet is not zero away.
+ */
+export function formatCompactDuration(ms) {
+    if (!Number.isFinite(ms) || ms <= 0)
+        return undefined;
+    if (ms >= MS_PER_DAY)
+        return `${Math.floor(ms / MS_PER_DAY)}d`;
+    if (ms >= MS_PER_HOUR)
+        return `${Math.floor(ms / MS_PER_HOUR)}h`;
+    return `${Math.max(1, Math.floor(ms / MS_PER_MINUTE))}m`;
+}
+/**
+ * The window that decides what an account can still do.
+ *
+ * An account reports several windows at once - typically a 5-hour and a weekly
+ * one - and the one with the least headroom is the one that stops a request,
+ * so it is the one the account is described by. On a tie the window that
+ * blocks for longer governs: two windows both fully spent are not equally
+ * costly when one returns in four hours and the other in three days.
+ */
+export function resolveGoverningWindow(account) {
+    let governing;
+    for (const window of account.windows) {
+        if (!isPercent(window.leftPercent))
+            continue;
+        if (!governing) {
+            governing = window;
+            continue;
+        }
+        const governingLeft = governing.leftPercent ?? 100;
+        if (window.leftPercent < governingLeft) {
+            governing = window;
+            continue;
+        }
+        if (window.leftPercent === governingLeft &&
+            isPercent(window.resetAtMs) &&
+            (!isPercent(governing.resetAtMs) || window.resetAtMs > governing.resetAtMs)) {
+            governing = window;
+        }
+    }
+    return governing;
+}
+/**
+ * Weighted mean headroom across the pool, or `undefined` when no account
+ * reported a readable window.
+ *
+ * Accounts with no readable window are left out rather than counted as full:
+ * a quota we could not read is not capacity we know we have.
+ */
+export function computeWeightedLeftPercent(accounts) {
+    let weighted = 0;
+    let totalWeight = 0;
+    for (const account of accounts) {
+        const governing = resolveGoverningWindow(account);
+        if (!governing || !isPercent(governing.leftPercent))
+            continue;
+        const weight = getPlanWeight(account.planType);
+        if (!Number.isFinite(weight) || weight <= 0)
+            continue;
+        weighted += weight * governing.leftPercent;
+        totalWeight += weight;
+    }
+    return totalWeight > 0 ? Math.round(weighted / totalWeight) : undefined;
+}
+/**
+ * What the pool the percentage is taken over adds up to, in 1x seats.
+ *
+ * Deliberately the same sum {@link computeWeightedLeftPercent} divides by, and
+ * over the same accounts, so `66% of 65x` is one statement rather than two
+ * that can disagree. An account whose plan states no ratio therefore
+ * contributes its fallback weight here exactly as it does to the mean.
+ */
+export function computePoolAllotment(accounts) {
+    let total = 0;
+    for (const account of accounts) {
+        const governing = resolveGoverningWindow(account);
+        if (!governing || !isPercent(governing.leftPercent))
+            continue;
+        const weight = getPlanWeight(account.planType);
+        if (!Number.isFinite(weight) || weight <= 0)
+            continue;
+        total += weight;
+    }
+    return total > 0 ? total : undefined;
+}
+/**
+ * The next moment the pool gets capacity back, and how much.
+ *
+ * Only the window that actually resets is refilled, and the account's
+ * governing window is then resolved again: an account whose 5-hour window
+ * resets while its weekly window is still spent gains nothing, and reporting
+ * the 5-hour refill as pool recovery would promise headroom that does not
+ * arrive. Movement below one point is dropped rather than rendered as `+0%`.
+ */
+export function resolveQuotaOverviewRecovery(accounts, now = Date.now()) {
+    const current = computeWeightedLeftPercent(accounts);
+    if (current === undefined)
+        return undefined;
+    let earliest;
+    for (const account of accounts) {
+        for (const window of account.windows) {
+            if (!isPercent(window.leftPercent) || window.leftPercent >= 100)
+                continue;
+            const resetAtMs = window.resetAtMs;
+            if (!isPercent(resetAtMs) || resetAtMs <= now)
+                continue;
+            if (earliest === undefined || resetAtMs < earliest)
+                earliest = resetAtMs;
+        }
+    }
+    if (earliest === undefined)
+        return undefined;
+    const refilled = accounts.map((account) => ({
+        ...account,
+        windows: account.windows.map((window) => isPercent(window.resetAtMs) && window.resetAtMs <= earliest
+            ? { ...window, leftPercent: 100 }
+            : window),
+    }));
+    const recovered = computeWeightedLeftPercent(refilled);
+    if (recovered === undefined)
+        return undefined;
+    const deltaPercent = recovered - current;
+    if (deltaPercent < MIN_RECOVERY_DELTA_PERCENT)
+        return undefined;
+    return { deltaPercent, atMs: earliest };
+}
+/**
+ * Whether nothing in the pool has capacity left.
+ *
+ * This is the condition the reset-credit line exists for: while any account
+ * can still serve a request, which one recovers when is a detail, and once
+ * none can it is the only question left. Accounts whose quota could not be
+ * read do not count either way - an unknown reading is not evidence of
+ * exhaustion, but it is not capacity either, so a pool of nothing but
+ * unreadable accounts is reported as not spent rather than as dead.
+ */
+export function isPoolFullySpent(accounts) {
+    let readable = 0;
+    for (const account of accounts) {
+        const governing = resolveGoverningWindow(account);
+        if (!governing || !isPercent(governing.leftPercent))
+            continue;
+        readable += 1;
+        if (governing.leftPercent > 0)
+            return false;
+    }
+    return readable > 0;
+}
+/**
+ * Sort key for the reset-time orders.
+ *
+ * An account with no known reset sorts after every account that has one, in
+ * both directions. Not knowing when something returns is a different statement
+ * from knowing it returns soon, and a different statement from knowing it
+ * returns last.
+ */
+function governingResetAtMs(account) {
+    const governing = resolveGoverningWindow(account);
+    return governing && isPercent(governing.resetAtMs)
+        ? governing.resetAtMs
+        : undefined;
+}
+function governingLeftPercent(account) {
+    const governing = resolveGoverningWindow(account);
+    return governing && isPercent(governing.leftPercent)
+        ? governing.leftPercent
+        : undefined;
+}
+/**
+ * Arrange the accounts for display.
+ *
+ * Every comparison falls back to the account number, so two accounts reading
+ * the same percentage never trade places between renders. An order that let
+ * them would reintroduce exactly the movement this mode exists to remove.
+ */
+export function orderOverviewAccounts(accounts, order) {
+    const sorted = [...accounts];
+    if (order === "most-used" || order === "least-used") {
+        const direction = order === "most-used" ? 1 : -1;
+        return sorted.sort((left, right) => {
+            const leftPercent = governingLeftPercent(left);
+            const rightPercent = governingLeftPercent(right);
+            if (leftPercent === undefined && rightPercent === undefined) {
+                return left.index - right.index;
+            }
+            if (leftPercent === undefined)
+                return 1;
+            if (rightPercent === undefined)
+                return -1;
+            if (leftPercent !== rightPercent) {
+                return direction * (leftPercent - rightPercent);
+            }
+            return left.index - right.index;
+        });
+    }
+    if (order === "renewing-earliest" || order === "renewing-latest") {
+        const direction = order === "renewing-earliest" ? 1 : -1;
+        return sorted.sort((left, right) => {
+            const leftReset = governingResetAtMs(left);
+            const rightReset = governingResetAtMs(right);
+            if (leftReset === undefined && rightReset === undefined) {
+                return left.index - right.index;
+            }
+            if (leftReset === undefined)
+                return 1;
+            if (rightReset === undefined)
+                return -1;
+            if (leftReset !== rightReset)
+                return direction * (leftReset - rightReset);
+            return left.index - right.index;
+        });
+    }
+    // `number` and anything unrecognized: an order nobody asked for must not
+    // silently become one of the sorted ones, which would move accounts around
+    // under a reader who configured nothing.
+    return sorted.sort((left, right) => left.index - right.index);
+}
+const EMAIL_LIKE = /^[^\s@]+@[^\s@]+$/;
+/**
+ * The local part of an email, which is what a person calls the account.
+ *
+ * `damian@nowaker.net` -> `damian`. Masking is applied to the local part
+ * rather than to the whole address, because the domain is what
+ * {@link maskEmailForDisplay} keeps and there is no room for it here.
+ */
+function formatEmailLocalPart(email, maskEmail) {
+    const trimmed = email.trim();
+    if (!trimmed)
+        return undefined;
+    const local = trimmed.split("@")[0]?.trim();
+    if (!local)
+        return undefined;
+    if (!maskEmail)
+        return local;
+    return `${Array.from(local).slice(0, 2).join("")}***`;
+}
+/**
+ * What this account is called on the line.
+ *
+ * Under `label` a user-set label wins, because it is the one name the user
+ * chose; an account that only knows its email falls back to that email's local
+ * part, and an account with neither falls back to its number rather than
+ * rendering nothing - a nameless segment in a named line reads as a missing
+ * account.
+ */
+export function resolveAccountName(account, names, maskEmail = false) {
+    if (names === "none")
+        return undefined;
+    if (names === "number")
+        return `#${account.index}`;
+    const label = account.label?.trim();
+    if (label && !EMAIL_LIKE.test(label))
+        return label;
+    const email = label && EMAIL_LIKE.test(label) ? label : account.email;
+    const local = email ? formatEmailLocalPart(email, maskEmail) : undefined;
+    return local ?? `#${account.index}`;
+}
+/** The full email for the reset-credit line, masked when asked. */
+function resolveAccountEmail(account, maskEmail) {
+    const label = account.label?.trim();
+    const email = account.email?.trim() || (label && EMAIL_LIKE.test(label) ? label : undefined);
+    if (!email)
+        return undefined;
+    return maskEmail ? maskEmailForDisplay(email) : email;
+}
+function resolveResetCredits(account) {
+    const credits = account.resetCredits;
+    return typeof credits === "number" && Number.isFinite(credits) && credits > 0
+        ? Math.trunc(credits)
+        : 0;
+}
+function shouldPrintReset(leftPercent, resetTimes) {
+    if (resetTimes === "never")
+        return false;
+    if (resetTimes === "always")
+        return true;
+    return leftPercent <= OVERVIEW_RESET_LEFT_PERCENT;
+}
+/** The part of a segment that is not the account's name or its percentage. */
+function formatAccountAnnotations(account, governing, options) {
+    const parts = [];
+    const leftPercent = governing.leftPercent;
+    if (isPercent(leftPercent) &&
+        shouldPrintReset(leftPercent, options.resetTimes) &&
+        isPercent(governing.resetAtMs)) {
+        const reset = formatCompactDuration(governing.resetAtMs - options.now);
+        if (reset)
+            parts.push(reset);
+    }
+    if (options.resetCredits) {
+        const credits = resolveResetCredits(account);
+        if (credits > 0)
+            parts.push(`${credits}r`);
+    }
+    return parts;
+}
+function formatAccountSegment(account, options) {
+    const governing = resolveGoverningWindow(account);
+    if (!governing || !isPercent(governing.leftPercent))
+        return undefined;
+    const parts = [];
+    const name = resolveAccountName(account, options.names, options.maskEmail);
+    if (name)
+        parts.push(name);
+    if (options.multipliers) {
+        const multiplier = formatPlanMultiplier(account.planType);
+        if (multiplier)
+            parts.push(multiplier);
+    }
+    parts.push(formatQuotaPercent(governing.leftPercent, options.mode));
+    parts.push(...formatAccountAnnotations(account, governing, options));
+    return parts.join(" ");
+}
+/**
+ * Accounts reading the same percentage, collapsed into one segment.
+ *
+ * On a pool where several accounts are fully spent, `100% 3d, 100% 4d,
+ * 100% 5d` spends two thirds of its characters repeating a number that is the
+ * same every time. Grouping prints it once and keeps what differs:
+ *
+ * ```text
+ * 100% 3d 1r 4d 5d
+ * ```
+ *
+ * The group's size is stated explicitly - `100% x3 3d` - only when the
+ * annotations do not already reveal it, so a group of three accounts where one
+ * has no reset time to print cannot read as a group of two. A group of one is
+ * never counted, because there is nothing to count.
+ *
+ * Grouping discards identity by construction, so `names` has no effect here.
+ */
+function formatAggregateSegments(accounts, options) {
+    const groups = new Map();
+    for (const account of accounts) {
+        const governing = resolveGoverningWindow(account);
+        if (!governing || !isPercent(governing.leftPercent))
+            continue;
+        const percent = formatQuotaPercent(governing.leftPercent, options.mode);
+        const group = groups.get(percent) ?? {
+            percent,
+            size: 0,
+            annotations: [],
+        };
+        group.size += 1;
+        const annotations = formatAccountAnnotations(account, governing, options);
+        if (annotations.length > 0)
+            group.annotations.push(annotations.join(" "));
+        groups.set(percent, group);
+    }
+    return [...groups.values()].map((group) => {
+        const parts = [group.percent];
+        if (group.size > 1 && group.annotations.length < group.size) {
+            parts.push(`x${group.size}`);
+        }
+        parts.push(...group.annotations);
+        return parts.join(" ");
+    });
+}
+/**
+ * `+12% in 3d` / `-12% 3d`.
+ *
+ * The sign describes the direction the number beside it moves, not the
+ * direction of the user's fortunes: under `used` the pool total falls as
+ * capacity returns, and a `+` there would contradict the figure it annotates.
+ * The word `in` is the first thing dropped when the line is short, because it
+ * is the only part of the clause a reader can supply themselves.
+ */
+function formatRecovery(recovery, options) {
+    const at = formatCompactDuration(recovery.atMs - options.now);
+    if (!at)
+        return undefined;
+    const sign = options.mode === "used" ? "-" : "+";
+    return `${sign}${recovery.deltaPercent}% ${options.words ? "in " : ""}${at}`;
+}
+function formatAccountCount(count, style) {
+    if (style === "bare")
+        return `${count}`;
+    if (style === "short")
+        return `${count} acct.`;
+    return `${count} account${count === 1 ? "" : "s"}`;
+}
+/**
+ * Every annotation level to try, most informative first.
+ *
+ * One dimension is given up per rung and never restored within the ladder, so
+ * each rung is strictly shorter than the one above it. The order is by what a
+ * reader loses: the plan badge says nothing the account's own numbers do not,
+ * a long label can be replaced by the number that selects the same account,
+ * banked resets only matter once something is spent, and a reset countdown on
+ * a healthy account is the detail `resetTimes: "always"` opted into.
+ *
+ * Dropping the account's name entirely is the last rung, and it is offered
+ * only when position still identifies an account: under a sorted order, or
+ * with any account missing from the line, `39%, 8%, 91%` names nothing at all
+ * and a reader would attach those figures to the wrong seats.
+ */
+function annotationRungs(options, positionsAreComplete) {
+    const rungs = [];
+    let current = {
+        names: options.names,
+        multipliers: options.multipliers,
+        resetTimes: options.resetTimes,
+        resetCredits: options.resetCredits,
+    };
+    rungs.push(current);
+    const step = (next) => {
+        current = { ...current, ...next };
+        rungs.push(current);
+    };
+    if (current.multipliers)
+        step({ multipliers: false });
+    if (current.names === "label")
+        step({ names: "number" });
+    if (current.resetCredits)
+        step({ resetCredits: false });
+    if (current.resetTimes === "always")
+        step({ resetTimes: "low" });
+    if (current.resetTimes !== "never")
+        step({ resetTimes: "never" });
+    if (current.names !== "none" && positionsAreComplete)
+        step({ names: "none" });
+    return rungs;
+}
+/**
+ * Every rendering of this pool, longest first.
+ *
+ * The caller takes the first that fits its width. Detail is dropped in the
+ * order that costs a reader the least: the recovery clause and then the
+ * annotations (badges, banked resets) that sit beside a figure which stays
+ * either way, then the per-account breakdown, leaving the pool total - the one
+ * thing the line exists to say - as the last to go.
+ *
+ * Order is preference, NOT length: a stripped-down rung is occasionally a
+ * character or two longer than the rung above it. Sorting by length instead
+ * would let a form win or lose by two characters as a percentage crosses from
+ * `9%` to `10%`, and the line would change shape while the reader watches -
+ * the flicker this whole mode exists to remove.
+ *
+ * Candidates never exceed what {@link QuotaOverviewOptions} asked for, so a
+ * switch left off cannot reappear because the terminal happened to be wide.
+ */
+export function formatQuotaOverviewCandidates(accounts, options) {
+    const now = options.now ?? Date.now();
+    const maskEmail = options.maskEmail ?? false;
+    const total = computeWeightedLeftPercent(accounts);
+    if (total === undefined)
+        return [];
+    const totalText = formatQuotaPercent(total, options.mode);
+    const ordered = orderOverviewAccounts(accounts, options.order);
+    const usable = ordered.filter((account) => resolveGoverningWindow(account));
+    const recovery = options.recovery
+        ? resolveQuotaOverviewRecovery(accounts, now)
+        : undefined;
+    const recoveryForms = recovery
+        ? [true, false]
+            .map((words) => formatRecovery(recovery, { mode: options.mode, now, words }))
+            .filter((form) => Boolean(form))
+        : [];
+    const bodies = [];
+    if (options.layout !== "count") {
+        // Position identifies an account only when the accounts are in number
+        // order, none of them is missing from the line, and the numbers run
+        // 1..n with no gap - a deduplicated or disabled account leaves indices
+        // like #1, #3, where the second percentage is NOT account #2's.
+        const positionsAreComplete = options.order === "number" &&
+            usable.length === accounts.length &&
+            usable.every((account, position) => account.index === position + 1);
+        for (const rung of annotationRungs(options, positionsAreComplete)) {
+            const segmentOptions = {
+                ...rung,
+                mode: options.mode,
+                maskEmail,
+                now,
+            };
+            const segments = options.layout === "aggregate"
+                ? formatAggregateSegments(usable, segmentOptions)
+                : usable
+                    .map((account) => formatAccountSegment(account, segmentOptions))
+                    .filter((segment) => Boolean(segment));
+            if (segments.length === 0)
+                continue;
+            const text = segments.join(", ");
+            if (!bodies.includes(text))
+                bodies.push(text);
+        }
+    }
+    // `66% of 65x` before `66%`: the allotment is a small, near-static
+    // annotation, so it is given up early - but not before any account detail,
+    // which is what the line is read for.
+    const heads = [];
+    if (options.allotment) {
+        const allotment = computePoolAllotment(accounts);
+        if (allotment !== undefined)
+            heads.push(`${totalText} of ${allotment}x`);
+    }
+    if (!heads.includes(totalText))
+        heads.push(totalText);
+    const candidates = [];
+    const push = (head, ...tail) => {
+        const body = tail.filter((part) => Boolean(part));
+        const text = body.length > 0 ? `${head}: ${body.join(", ")}` : head;
+        if (!candidates.includes(text))
+            candidates.push(text);
+    };
+    for (const body of bodies) {
+        for (const head of heads) {
+            for (const form of recoveryForms)
+                push(head, body, form);
+            push(head, body);
+        }
+    }
+    for (const head of heads) {
+        // The count word is grammar, the recovery clause is information, so the
+        // word goes first. The count is the pool's size, not the number of
+        // accounts that could be read - `40%: 1 account` on a three-account
+        // pool would say a pool exists that does not.
+        if (recoveryForms.length > 0) {
+            for (const form of recoveryForms)
+                push(head, formatAccountCount(accounts.length, "long"), form);
+            const shortest = recoveryForms[recoveryForms.length - 1];
+            push(head, formatAccountCount(accounts.length, "short"), shortest);
+            push(head, formatAccountCount(accounts.length, "bare"), shortest);
+        }
+        push(head, formatAccountCount(accounts.length, "long"));
+        push(head, formatAccountCount(accounts.length, "short"));
+        push(head, formatAccountCount(accounts.length, "bare"));
+    }
+    for (const head of heads)
+        push(head);
+    return candidates;
+}
+/** The fullest rendering, for surfaces with a line to themselves. */
+export function formatQuotaOverviewText(accounts, options) {
+    return formatQuotaOverviewCandidates(accounts, options)[0] ?? "";
+}
+/**
+ * Every rendering of the banked reset credits, longest first.
+ *
+ * ```text
+ * Free resets: 6d 1r damian@nowaker.net, 4d 2r work@example.com
+ * ```
+ *
+ * Sorted by the LATEST reset first, which is redemption order rather than
+ * reading order: redeeming a credit on an account that renews by itself
+ * tomorrow throws the credit away, while the account six days out is the one
+ * worth spending it on.
+ *
+ * Returns nothing at all unless the pool is spent and something is redeemable.
+ * A reset credit is only an answer to "everything is used up"; offered while
+ * accounts still have headroom it is an invitation to waste it.
+ */
+export function formatQuotaResetsCandidates(accounts, options) {
+    if (!isPoolFullySpent(accounts))
+        return [];
+    const now = options.now ?? Date.now();
+    const maskEmail = options.maskEmail ?? false;
+    const redeemable = orderOverviewAccounts(accounts, "renewing-latest").filter((account) => resolveResetCredits(account) > 0);
+    if (redeemable.length === 0)
+        return [];
+    const durations = redeemable.map((account) => {
+        const resetAtMs = governingResetAtMs(account);
+        return resetAtMs === undefined
+            ? undefined
+            : formatCompactDuration(resetAtMs - now);
+    });
+    const credits = redeemable.map((account) => resolveResetCredits(account));
+    const everyAccountHasOneCredit = credits.every((count) => count === 1);
+    // The identity follows `accountNames` like the pool line does: the full
+    // address is the longest form of the `label` name and appears only there,
+    // `number` gives `#n`, and `none` names no account at all.
+    const names = options.names ?? "label";
+    const unnamed = redeemable.map(() => undefined);
+    const identities = names === "none"
+        ? [unnamed]
+        : names === "number"
+            ? [
+                redeemable.map((account) => resolveAccountName(account, "number", maskEmail)),
+            ]
+            : [
+                redeemable.map((account) => resolveAccountEmail(account, maskEmail)),
+                redeemable.map((account) => resolveAccountName(account, "label", maskEmail)),
+                redeemable.map((account) => resolveAccountName(account, "number", maskEmail)),
+            ];
+    const candidates = [];
+    const add = (text) => {
+        if (!candidates.includes(text))
+            candidates.push(text);
+    };
+    const push = (prefix, identity, withDuration, withCredits) => {
+        const segments = redeemable.map((_account, position) => {
+            const parts = [];
+            const duration = durations[position];
+            if (withDuration && duration)
+                parts.push(duration);
+            if (withCredits)
+                parts.push(`${credits[position]}r`);
+            const name = identity[position];
+            if (name)
+                parts.push(name);
+            return parts.join(" ");
+        });
+        // A form that would render one account as an empty segment is not a
+        // shorter rendering of this line, it is a different and wrong one.
+        if (segments.some((segment) => segment.length === 0))
+            return;
+        add(`${prefix} ${segments.join(", ")}`);
+    };
+    // The word `Free` is given up before any account detail is, and the
+    // identity then shortens from the fullest configured form - the full
+    // address under `label` - down to the number `codex-reset` takes.
+    push("Free resets:", identities[0] ?? unnamed, true, true);
+    for (const identity of identities)
+        push("Resets:", identity, true, true);
+    // Only once every identity form has been tried does the line start giving
+    // up facts: the countdown is the reason one account is a better redemption
+    // than another, and the credit count stops being news when every account
+    // holds exactly one.
+    for (const identity of identities) {
+        if (everyAccountHasOneCredit)
+            push("Resets:", identity, true, false);
+        push("Resets:", identity, false, true);
+        push("Resets:", identity, false, false);
+    }
+    add(`Resets: ${redeemable.length}`);
+    return candidates;
+}
+/**
+ * Headroom of the account with the most room left, for the caller that
+ * colours the line.
+ *
+ * Deliberately the best account rather than the worst: a pool is only in
+ * trouble when nothing in it has room left, and keying on the worst account
+ * would paint the line red for one spent seat that rotation has already
+ * stopped selecting while every other account serves requests normally.
+ */
+export function resolveQuotaOverviewTonePercent(accounts) {
+    let best;
+    for (const account of accounts) {
+        const governing = resolveGoverningWindow(account);
+        if (!governing || !isPercent(governing.leftPercent))
+            continue;
+        if (best === undefined || governing.leftPercent > best) {
+            best = governing.leftPercent;
+        }
+    }
+    return best;
+}
+/** Re-exported so callers rendering a bare total need only this module. */
+export { toQuotaDisplayPercent };
+//# sourceMappingURL=quota-overview.js.map