@modelprofile.com/authswitch 3.2.0 → 4.0.0

package/dist_ts/00_commitinfo_data.js

@@ -2,8 +2,8 @@
  * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
-    name: '@modelprofile.com/authswitch',
-    version: '3.2.0',
-    description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
+    name: "@modelprofile.com/authswitch",
+    version: "4.0.0",
+    description: "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status"
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSw4QkFBOEI7SUFDcEMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZGQUE2RjtDQUMzRyxDQUFBIn0=

package/dist_ts/accounts.d.ts

@@ -1,10 +1,13 @@
-import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessUsageWindow } from './interfaces.harness.js';
+import type { IAccountType, IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessStatusOptions, IHarnessUsageWindow } from './interfaces.harness.js';
 export interface IAccountRow {
     harness: IAuthHarness;
     account: IHarnessAccount;
     status?: IHarnessAccountStatus;
 }
+/** A provider window length or a whole-minute bound: `5h`, `7d`, `2m`. */
 export declare const duration: (secondsArg: number) => string;
+/** The same for a chosen duration that need not be whole minutes: `90s` reads `1m 30s`, never `1.5m`. */
+export declare const durationText: (secondsArg: number) => string;
 /** A countdown is a snapshot of the provider's deadline, not proof a quota has reset. */
 export declare const until: (timestampArg: string | null, nowArg: number) => string;
 export declare const compactUntil: (timestampArg: string | null, nowArg: number, unavailableArg?: string) => string;
@@ -16,22 +19,47 @@ export declare const compactUntil: (timestampArg: string | null, nowArg: number,
  * exactly as `compactUntil` reports one.
  */
 export declare const compactSince: (timestampArg: string | null, nowArg: number, unavailableArg?: string) => string;
+export declare const localDate: (timestampArg: string | null, unavailableArg?: string) => string;
+export declare const localDateTime: (timestampArg: string | null, unavailableArg?: string) => string;
+/** A moment's local time of day with seconds, `14:02:07`, for a log line whose date is implied. */
+export declare const localTime: (timeArg: number) => string;
+/** Provider text with every ISO 8601 timestamp in it rewritten as local date and time. */
+export declare const localiseTimestamps: (textArg: string) => string;
 /**
  * One sentence for a credential file that no longer holds the account the last switch wrote.
  *
- * It names what the file holds now and how to put the intended account back, because the usual
- * cause -- a harness instance that kept running through the switch and then refreshed its
- * in-memory login -- leaves no other trace.
+ * It names what the file holds now and how to keep or undo that. A harness that picks up swaps live is only ever
+ * changed by a new login; one that does not can also have a running instance write its previous login back.
  */
-export declare const credentialDriftNote: (harnessIdArg: string, driftArg: IHarnessCredentialDrift) => string;
+export declare const credentialDriftNote: (harnessArg: Pick<IAuthHarness, "id" | "liveSwap">, driftArg: IHarnessCredentialDrift) => string;
+/**
+ * The same finding as one table cell: which account was expected, what the slot holds now, and then every action
+ * that resolves it, one per line -- the same actions the sentence names, so the two views advise the same thing in a
+ * cell that has to stay narrow.
+ */
+export declare const credentialDriftProblem: (harnessIdArg: string, driftArg: IHarnessCredentialDrift) => string;
+/** An account as prompts and reports name it: its label, qualified by its credential slot when it has one. */
+export declare const accountName: (accountArg: Pick<IHarnessAccount, "label" | "slotId">) => string;
+/**
+ * How an account type reads in every view: the provider's plan name with its first letter capitalised
+ * (`max` reads `Max`), and a plan taken from the stored login marked `Plus, unverified`. The text holds no
+ * parentheses, so it reads the same inside a badge part. Nothing is invented: an unknown type is null, and
+ * each view decides how to show that.
+ */
+export declare const accountTypeText: (typeArg: IAccountType | null | undefined) => string | null;
 export declare const accountPlan: (rowArg: IAccountRow) => string;
 type TAccountStatusRow = Pick<IAccountRow, 'status'>;
+/** How a single-value summary names a window among the windows it shows: `Weekly`, `5h`, or its label. */
+export declare const usageWindowName: (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]) => string;
 /**
- * How a single-value summary names a window among the windows it shows. An account window is named by
- * its period while it is the only shown account window of that period; a feature window, or an account
- * window sharing its period with another, is named by its own label, so no meter reads as another's.
+ * How every view prints a provider's usage reading: the nearest whole percent, except that a window the provider
+ * reports below 100% never reads as `100%` -- that is the one reading acted on as exhausted, and a window with
+ * capacity left must not claim it. The tables, the switch badge and the watch share this text, so none of them
+ * shows a different number for the same window.
  */
-export declare const usageWindowName: (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]) => string;
+export declare const usagePercentText: (usedPercentArg: number) => string;
+/** A shown window in one compact line: `weekly 4% · 5d 1h`, `Fable weekly 100% · 2d`. */
+export declare const compactUsageLine: (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[], nowArg: number) => string;
 /** Order by scope and actual duration: a provider's primary slot need not be five hours. */
 export declare const orderedUsageWindows: (windowsArg?: readonly IHarnessUsageWindow[]) => IHarnessUsageWindow[];
 /**
@@ -43,13 +71,35 @@ export declare const accountUsage: (rowArg: TAccountStatusRow) => string;
 export declare const accountResets: (rowArg: IAccountRow) => string;
 export declare const accountNextReset: (rowArg: TAccountStatusRow, nowArg?: number) => string;
 export declare const accountQuotaSummary: (rowArg: TAccountStatusRow, nowArg: number) => string;
+/**
+ * What a switch activates, in one line: ` (type:Max) (5h:63%) (w:88%)`, appended to the account label.
+ *
+ * Each part is the provider's own reading as a whole percent, and is omitted when it was not
+ * reported; with no part known the badge is empty, so a missing reading never reads as zero usage.
+ */
+export declare const accountBadge: (statusArg: IHarnessAccountStatus | undefined) => string;
+/**
+ * The badge of every named account whose status answered before one shared deadline.
+ *
+ * Never fatal, and it never changes which account is in use: a switch must not wait on a provider past this deadline, nor fail because
+ * usage could not be read, so a lookup that fails or misses the deadline contributes no badge and the
+ * caller shows the label alone. At the deadline every lookup still running is cancelled, so no request
+ * outlives the call and keeps the command from exiting.
+ */
+export declare const readAccountBadges: (harnessArg: IAuthHarness, accountIdsArg: readonly string[], timeoutMsArg?: number) => Promise<Map<string, string>>;
 export declare const accountState: (rowArg: IAccountRow) => string;
 export declare const accountDetails: (rowArg: IAccountRow) => string;
-/** Read-only, bounded parallel status lookup. No account is switched to inspect it. */
-export declare const readAccountRows: (harnessArg: IAuthHarness, optionsArg?: {
-    signal?: AbortSignal;
+export interface IAccountRowsOptions extends IHarnessStatusOptions {
     onUpdate?: (rowsArg: IAccountRow[], stateArg: IHarnessState) => void | Promise<void>;
-}) => Promise<{
+    /** Which accounts' statuses to read; every account by default. A row that is not read keeps no status. */
+    lookup?: (accountArg: IHarnessAccount) => boolean;
+}
+/**
+ * Bounded parallel status lookup. No account is activated, switched or cleared to inspect it -- an adapter may renew
+ * the tokens of the saved copy it reads, and nothing else; the signal cancels lookups in flight, and a session lets
+ * the adapters reuse slow-changing lookups across repeated reads.
+ */
+export declare const readAccountRows: (harnessArg: IAuthHarness, optionsArg?: IAccountRowsOptions) => Promise<{
     rows: IAccountRow[];
     state: IHarnessState;
 }>;

package/dist_ts/accounts.js

@@ -1,5 +1,9 @@
 import { plainText } from './formatting.js';
+/** A provider window length or a whole-minute bound: `5h`, `7d`, `2m`. */
 export const duration = (secondsArg) => secondsArg % 86400 === 0 ? `${secondsArg / 86400}d` : secondsArg % 3600 === 0 ? `${secondsArg / 3600}h` : `${secondsArg / 60}m`;
+/** The same for a chosen duration that need not be whole minutes: `90s` reads `1m 30s`, never `1.5m`. */
+export const durationText = (secondsArg) => secondsArg % 60 === 0 ? duration(secondsArg)
+    : secondsArg < 60 ? `${secondsArg}s` : `${Math.floor(secondsArg / 60)}m ${secondsArg % 60}s`;
 /** A countdown is a snapshot of the provider's deadline, not proof a quota has reset. */
 export const until = (timestampArg, nowArg) => {
     if (timestampArg === null)
@@ -58,30 +62,105 @@ export const compactSince = (timestampArg, nowArg, unavailableArg = 'n/a') => {
         return unavailableArg;
     return elapsed < 60000 ? '<1m' : twoUnits(elapsed);
 };
+const twoDigits = (valueArg) => String(valueArg).padStart(2, '0');
+/**
+ * A timestamp in local calendar time: `2026-10-08`, or `2026-10-08 23:14` with the time. Human output never prints
+ * a raw ISO timestamp; an unknown or unparseable one reads as the caller's unavailable marker.
+ */
+const localTimestamp = (timestampArg, withTimeArg, unavailableArg) => {
+    const time = timestampArg === null ? Number.NaN : Date.parse(timestampArg);
+    if (!Number.isFinite(time))
+        return unavailableArg;
+    const date = new Date(time);
+    const day = `${date.getFullYear()}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+    return withTimeArg ? `${day} ${twoDigits(date.getHours())}:${twoDigits(date.getMinutes())}` : day;
+};
+export const localDate = (timestampArg, unavailableArg = 'n/a') => localTimestamp(timestampArg, false, unavailableArg);
+export const localDateTime = (timestampArg, unavailableArg = 'n/a') => localTimestamp(timestampArg, true, unavailableArg);
+/** A moment's local time of day with seconds, `14:02:07`, for a log line whose date is implied. */
+export const localTime = (timeArg) => {
+    const date = new Date(timeArg);
+    return [date.getHours(), date.getMinutes(), date.getSeconds()].map(twoDigits).join(':');
+};
+const ISO_TIMESTAMP = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})/g;
+/** Provider text with every ISO 8601 timestamp in it rewritten as local date and time. */
+export const localiseTimestamps = (textArg) => textArg.replace(ISO_TIMESTAMP, match => localDateTime(match, match));
 /**
  * One sentence for a credential file that no longer holds the account the last switch wrote.
  *
- * It names what the file holds now and how to put the intended account back, because the usual
- * cause -- a harness instance that kept running through the switch and then refreshed its
- * in-memory login -- leaves no other trace.
+ * It names what the file holds now and how to keep or undo that. A harness that picks up swaps live is only ever
+ * changed by a new login; one that does not can also have a running instance write its previous login back.
+ */
+export const credentialDriftNote = (harnessArg, driftArg) => {
+    const id = plainText(harnessArg.id);
+    const cause = harnessArg.liveSwap === true ? 'for example a new login' : 'for example a new login, or a running instance that wrote its previous login back';
+    const now = driftArg.currentLabel === null ? 'No login is active in that slot now'
+        : `It now holds ${plainText(driftArg.currentLabel)}, which is ${driftArg.currentIsSaved ? '' : 'not '}saved`;
+    const keep = driftArg.currentLabel !== null && !driftArg.currentIsSaved ? `authswitch ${id} stash --keep saves it, and ` : '';
+    const back = driftArg.expectedLabel === null ? 'switching to the intended account restores it' : `authswitch ${id} use ${plainText(driftArg.expectedLabel)} switches back`;
+    return `The active login changed outside authswitch since the last switch (${cause}). ${now}; ${keep}${back}.`;
+};
+/**
+ * The same finding as one table cell: which account was expected, what the slot holds now, and then every action
+ * that resolves it, one per line -- the same actions the sentence names, so the two views advise the same thing in a
+ * cell that has to stay narrow.
+ */
+export const credentialDriftProblem = (harnessIdArg, driftArg) => {
+    const id = plainText(harnessIdArg);
+    const expected = driftArg.expectedLabel === null ? 'a login that is no longer saved' : plainText(driftArg.expectedLabel);
+    const now = driftArg.currentLabel === null ? 'none' : `${plainText(driftArg.currentLabel)} (${driftArg.currentIsSaved ? 'saved' : 'not saved'})`;
+    const actions = [
+        ...(driftArg.currentLabel !== null && !driftArg.currentIsSaved ? [`authswitch ${id} stash --keep saves it`] : []),
+        driftArg.expectedLabel === null ? 'switching to the intended account restores it' : `authswitch ${id} use ${plainText(driftArg.expectedLabel)} switches back`,
+    ];
+    return [`Active login changed outside authswitch: expected ${expected},`, `now ${now}`, ...actions.map(action => `— ${action}`)].join('\n');
+};
+/** An account as prompts and reports name it: its label, qualified by its credential slot when it has one. */
+export const accountName = (accountArg) => `${plainText(accountArg.label)}${accountArg.slotId ? ` (${plainText(accountArg.slotId)})` : ''}`;
+/**
+ * How every view marks a plan that comes from the saved login because the provider did not confirm it: the
+ * word both earlier plan cells used, kept short so the type line of a limits cell does not wrap.
+ */
+const STORED_PLAN_MARK = 'unverified';
+/**
+ * How an account type reads in every view: the provider's plan name with its first letter capitalised
+ * (`max` reads `Max`), and a plan taken from the stored login marked `Plus, unverified`. The text holds no
+ * parentheses, so it reads the same inside a badge part. Nothing is invented: an unknown type is null, and
+ * each view decides how to show that.
+ */
+export const accountTypeText = (typeArg) => {
+    if (!typeArg)
+        return null;
+    const plan = plainText(typeArg.plan);
+    return `${plan.charAt(0).toUpperCase()}${plan.slice(1)}${typeArg.source === 'stored' ? `, ${STORED_PLAN_MARK}` : ''}`;
+};
+export const accountPlan = (rowArg) => accountTypeText(rowArg.status?.summary?.subscription) ?? (rowArg.status ? 'Unavailable' : 'Loading');
+/**
+ * Whether a window among the shown ones is named by its label. An account window is named by its period while it is
+ * the only shown account window of that period; a feature window, or an account window sharing its period with
+ * another, is named by its own label, so no meter reads as another's.
  */
-export const credentialDriftNote = (harnessIdArg, driftArg) => 'The credential file changed since the last switch (likely a running instance refreshed the previous login). '
-    + (driftArg.currentLabel === null ? 'No login is active in that slot now. '
-        : `It now holds ${plainText(driftArg.currentLabel)}${driftArg.currentIsSaved ? ', which is saved' : ', which is not saved'}. `)
-    + (driftArg.expectedLabel === null ? 'Switch to the intended account again.'
-        : `Run authswitch ${plainText(harnessIdArg)} use ${plainText(driftArg.expectedLabel)} again.`);
-export const accountPlan = (rowArg) => {
-    const subscription = rowArg.status?.summary?.subscription;
-    return subscription ? `${plainText(subscription.plan)}${subscription.source === 'stored' ? ' (stored; unverified)' : ' (live)'}` : rowArg.status ? 'Unavailable' : 'Loading';
+const namedByLabel = (windowArg, shownArg) => windowArg.scope === 'feature' || shownArg.some(other => other !== windowArg && other.scope !== 'feature' && other.durationSeconds === windowArg.durationSeconds);
+const periodName = (secondsArg) => secondsArg === 604800 ? 'weekly' : duration(secondsArg);
+/** How a single-value summary names a window among the windows it shows: `Weekly`, `5h`, or its label. */
+export const usageWindowName = (windowArg, shownArg) => {
+    if (namedByLabel(windowArg, shownArg))
+        return plainText(windowArg.label);
+    const period = periodName(windowArg.durationSeconds);
+    return `${period.charAt(0).toUpperCase()}${period.slice(1)}`;
 };
 /**
- * How a single-value summary names a window among the windows it shows. An account window is named by
- * its period while it is the only shown account window of that period; a feature window, or an account
- * window sharing its period with another, is named by its own label, so no meter reads as another's.
+ * How every view prints a provider's usage reading: the nearest whole percent, except that a window the provider
+ * reports below 100% never reads as `100%` -- that is the one reading acted on as exhausted, and a window with
+ * capacity left must not claim it. The tables, the switch badge and the watch share this text, so none of them
+ * shows a different number for the same window.
  */
-export const usageWindowName = (windowArg, shownArg) => windowArg.scope === 'feature' || shownArg.some(other => other !== windowArg && other.scope !== 'feature' && other.durationSeconds === windowArg.durationSeconds)
-    ? plainText(windowArg.label)
-    : windowArg.durationSeconds === 604800 ? 'Weekly' : duration(windowArg.durationSeconds);
+export const usagePercentText = (usedPercentArg) => {
+    const whole = Math.round(usedPercentArg);
+    return `${whole >= 100 && usedPercentArg < 100 ? 99 : whole}%`;
+};
+/** A shown window in one compact line: `weekly 4% · 5d 1h`, `Fable weekly 100% · 2d`. */
+export const compactUsageLine = (windowArg, shownArg, nowArg) => `${namedByLabel(windowArg, shownArg) ? plainText(windowArg.label) : periodName(windowArg.durationSeconds)} ${usagePercentText(windowArg.usedPercent)} · ${compactUntil(windowArg.resetAt, nowArg)}`;
 /** Order by scope and actual duration: a provider's primary slot need not be five hours. */
 export const orderedUsageWindows = (windowsArg = []) => [...windowsArg].sort((left, right) => Number(left.scope === 'feature') - Number(right.scope === 'feature') ||
     Number(left.durationSeconds !== 604800) - Number(right.durationSeconds !== 604800) || right.durationSeconds - left.durationSeconds);
@@ -113,31 +192,120 @@ export const accountQuotaSummary = (rowArg, nowArg) => {
             ...windows.slice(1).filter(window => window.usedPercent >= 100).map(window => `${usageWindowName(window, windows)} exhausted\nResets in: ${until(window.resetAt, nowArg)}`),
         ] : [])].join('\n');
 };
+/** The badge's usage meters: the general account windows a switch decision weighs, never a feature quota. */
+const BADGE_WINDOWS = [['5h', 18000], ['w', 604800]];
+/**
+ * The account window a badge part reads: the only account window of that period, or the provider's headline
+ * pick among several. Any other choice would be a guess, so the part is left out and no meter reads as another's.
+ */
+const badgeWindow = (windowsArg, secondsArg) => {
+    const matches = windowsArg.filter(window => window.scope !== 'feature' && window.durationSeconds === secondsArg);
+    const candidates = matches.length > 1 ? matches.filter(window => window.headline === true) : matches;
+    return candidates.length === 1 ? candidates[0] : undefined;
+};
+/**
+ * What a switch activates, in one line: ` (type:Max) (5h:63%) (w:88%)`, appended to the account label.
+ *
+ * Each part is the provider's own reading as a whole percent, and is omitted when it was not
+ * reported; with no part known the badge is empty, so a missing reading never reads as zero usage.
+ */
+export const accountBadge = (statusArg) => {
+    const type = accountTypeText(statusArg?.summary?.subscription);
+    const windows = statusArg?.summary?.usageWindows ?? [];
+    return [
+        ...(type === null ? [] : [`type:${type}`]),
+        ...BADGE_WINDOWS.flatMap(([name, seconds]) => {
+            const window = badgeWindow(windows, seconds);
+            return window === undefined ? [] : [`${name}:${usagePercentText(window.usedPercent)}`];
+        }),
+    ].map(part => ` (${part})`).join('');
+};
+/** How many accounts' statuses are read at once, so a long account list never floods a provider. */
+const STATUS_LOOKUP_CONCURRENCY = 4;
+/**
+ * Bounded status lookups: at most four accounts at a time, started in order, each handed the caller's signal.
+ * A lookup that fails reports undefined; once the signal aborts, no further lookup starts. A callback that throws
+ * rejects the call, and no other lookup starts after it. No lookup activates, switches or clears a login, though an
+ * adapter may renew the tokens of the saved copy it reads (`IAuthHarness.readAccountStatus`).
+ */
+const lookupStatuses = async (harnessArg, accountIdsArg, optionsArg) => {
+    let next = 0;
+    let failed = false;
+    const worker = async () => {
+        while (!failed && next < accountIdsArg.length && !optionsArg.signal?.aborted) {
+            const index = next++;
+            let status;
+            try {
+                status = await harnessArg.readAccountStatus(accountIdsArg[index], { signal: optionsArg.signal, session: optionsArg.session });
+            }
+            catch {
+                status = undefined;
+            }
+            try {
+                await optionsArg.onStatus(index, status);
+            }
+            catch (error) {
+                failed = true;
+                throw error;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(STATUS_LOOKUP_CONCURRENCY, accountIdsArg.length) }, worker));
+};
+/** How long a switch waits for the badges of the accounts it offers or activates. */
+const ACCOUNT_BADGE_TIMEOUT_MS = 2500;
+/**
+ * The badge of every named account whose status answered before one shared deadline.
+ *
+ * Never fatal, and it never changes which account is in use: a switch must not wait on a provider past this deadline, nor fail because
+ * usage could not be read, so a lookup that fails or misses the deadline contributes no badge and the
+ * caller shows the label alone. At the deadline every lookup still running is cancelled, so no request
+ * outlives the call and keeps the command from exiting.
+ */
+export const readAccountBadges = async (harnessArg, accountIdsArg, timeoutMsArg = ACCOUNT_BADGE_TIMEOUT_MS) => {
+    const badges = new Map();
+    if (!accountIdsArg.length)
+        return badges;
+    const cancel = new AbortController();
+    const lookups = lookupStatuses(harnessArg, accountIdsArg, { signal: cancel.signal, onStatus: (index, status) => {
+            if (status !== undefined && !cancel.signal.aborted)
+                badges.set(accountIdsArg[index], accountBadge(status));
+        } });
+    // A referenced timer: the command must stay alive until the deadline even when a stalled lookup holds nothing open.
+    let timer;
+    const deadline = new Promise(resolve => { timer = setTimeout(resolve, timeoutMsArg); });
+    try {
+        await Promise.race([lookups, deadline]);
+    }
+    finally {
+        clearTimeout(timer);
+        cancel.abort();
+    }
+    return badges;
+};
 export const accountState = (rowArg) => `${rowArg.account.isActive ? '* active, ' : ''}${rowArg.account.isStashed ? 'saved' : 'not saved'}`;
 export const accountDetails = (rowArg) => [
     plainText(rowArg.account.label), accountState(rowArg),
-    ...(rowArg.account.savedAt ? ['Saved: ' + plainText(rowArg.account.savedAt)] : []),
+    ...(rowArg.account.savedAt ? ['Saved: ' + localDateTime(rowArg.account.savedAt)] : []),
     ...rowArg.account.details.map(plainText),
-    ...(rowArg.status?.facts.map(factArg => `${plainText(factArg.label)}: ${plainText(factArg.value)}`) ?? ['Loading account status…']),
+    ...(rowArg.status?.facts.map(factArg => `${plainText(factArg.label)}: ${localiseTimestamps(plainText(factArg.value))}`) ?? ['Loading account status…']),
     ...(rowArg.status?.problems.map(problemArg => `Unavailable: ${plainText(problemArg)}`) ?? []),
 ].join('\n');
-/** Read-only, bounded parallel status lookup. No account is switched to inspect it. */
+/**
+ * Bounded parallel status lookup. No account is activated, switched or cleared to inspect it -- an adapter may renew
+ * the tokens of the saved copy it reads, and nothing else; the signal cancels lookups in flight, and a session lets
+ * the adapters reuse slow-changing lookups across repeated reads.
+ */
 export const readAccountRows = async (harnessArg, optionsArg = {}) => {
     const state = await harnessArg.readState();
     const rows = state.accounts.map(account => ({ harness: harnessArg, account }));
+    const read = rows.filter(row => optionsArg.lookup?.(row.account) ?? true);
     await optionsArg.onUpdate?.(rows, state);
-    for (let index = 0; index < rows.length && !optionsArg.signal?.aborted; index += 4) {
-        await Promise.all(rows.slice(index, index + 4).map(async (row) => {
-            try {
-                row.status = await harnessArg.readAccountStatus(row.account.id);
-            }
-            catch {
-                row.status = { facts: [], problems: ['Could not read account status.'] };
-            }
+    await lookupStatuses(harnessArg, read.map(row => row.account.id), { signal: optionsArg.signal, session: optionsArg.session, onStatus: async (index, status) => {
+            read[index].status = status ?? { facts: [], problems: ['Could not read account status.'] };
             if (!optionsArg.signal?.aborted)
                 await optionsArg.onUpdate?.(rows, state);
-        }));
-    }
+        } });
     return { rows, state };
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accounts.js","sourceRoot":"","sources":["../ts/accounts.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accounts.js","sourceRoot":"","sources":["../ts/accounts.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.accountlist.d.ts

@@ -1,27 +1,3 @@
-import * as plugins from './plugins.js';
 import type { IAuthHarness } from './interfaces.harness.js';
 import type { IAccountList } from './interfaces.list.js';
 export declare const readAccountList: (harnessesArg: IAuthHarness[]) => Promise<IAccountList>;
-export declare const consoleWidth: () => number;
-export declare const consoleHeading: (textArg: string) => void;
-/**
- * One table implementation for every command, including the label-per-line fallback on narrow terminals.
- *
- * `groupsArg` is smartconsole's optional visual grouping: a divider between runs of consecutive rows with
- * different keys, and a colour line along the left edge per run. Keys are identities, never display labels,
- * and the caller orders the rows so that every group is one run. Below 40 columns the fallback separates
- * divider runs with one dim rule line; it has no left edge, so it draws no colour line.
- */
-export declare const consoleTable: <TRow>(outArg: plugins.smartconsole.SmartConsole, rowsArg: TRow[], columnsArg: plugins.smartconsole.IBackendTableColumn<TRow>[], groupsArg?: NoInfer<plugins.smartconsole.IBackendTableGroups<TRow>>) => Promise<void>;
-/** Shared, provider-independent list presentation. Adapters supply grouping metadata. */
-export declare class AccountListRenderer {
-    private readonly out;
-    constructor(out: plugins.smartconsole.SmartConsole);
-    private get width();
-    private heading;
-    render(listArg: IAccountList): Promise<void>;
-    private overview;
-    private covered;
-    /** Compare like metrics across accounts, keeping duplicate labels as separate rows. */
-    private facts;
-}