@modelprofile.com/authswitch 3.3.0 → 4.0.0

package/dist_ts/watchpolicy.d.ts

@@ -0,0 +1,44 @@
+import type { IHarnessUsageWindow } from './interfaces.harness.js';
+/** What a watch knows about one account of a harness when it decides. */
+export interface IWatchReading {
+    id: string;
+    label: string;
+    /** Only a saved account can be switched to. */
+    isSaved: boolean;
+    /** The provider's usage windows from a reading recent enough to act on; null while the usage is unknown. */
+    windows: readonly IHarnessUsageWindow[] | null;
+    /** Why the usage is unknown, for a decision that depends on it. */
+    unknownReason?: string;
+}
+export interface IWatchPolicyInput {
+    activeId: string | null;
+    readings: readonly IWatchReading[];
+    /** The used percentage at which a window counts as used up. */
+    threshold: number;
+    /** A used-up account is traded for another used-up one only when that one is usable again more than this much sooner. */
+    intervalMs: number;
+    now: number;
+}
+/** `ok` says whether the active account is fine; a stay that is not ok still has nothing better to switch to. */
+export type TWatchDecision = {
+    action: 'stay';
+    ok: boolean;
+    reason: string;
+} | {
+    action: 'switch';
+    target: string;
+    reason: string;
+};
+/**
+ * Which account a harness should use, from one set of readings. Pure: the same input always decides the same.
+ *
+ * - The active account is used up when any of its account windows is at or above the threshold. The watch then
+ *   switches to the saved account whose account windows are all at least `WATCH_HYSTERESIS` points below it,
+ *   preferring the one whose longest window resets soonest, then the least used, then by label.
+ * - When no account qualifies and every other saved account with a known reading is used up too, it switches to the
+ *   one that is usable again first, and only when that is more than one interval sooner than the active account.
+ * - An active account limited only on a feature window (one model) switches to an account that is below the margin on
+ *   every window; without one it stays, because the active account still serves everything else.
+ * - A reading that is unknown, whatever the cause, never counts as used up and never makes an account a target.
+ */
+export declare const decideWatchAction: (inputArg: IWatchPolicyInput) => TWatchDecision;

package/dist_ts/watchpolicy.js

@@ -0,0 +1,82 @@
+import { compactUntil, usagePercentText } from './accounts.js';
+import { plainText } from './formatting.js';
+/**
+ * How far below the threshold a switch target must be on every limit, so that a switch never lands on an account that
+ * is about to reach it and the watch never flips back and forth.
+ */
+const WATCH_HYSTERESIS = 10;
+const accountWindows = (readingArg) => (readingArg.windows ?? []).filter(window => window.scope !== 'feature');
+const featureWindows = (readingArg) => (readingArg.windows ?? []).filter(window => window.scope === 'feature');
+/** The fullest of the windows at or above the threshold (the longer one on a tie), which names why an account is limited. */
+const fullest = (windowsArg, thresholdArg) => windowsArg.filter(window => window.usedPercent >= thresholdArg)
+    .sort((left, right) => right.usedPercent - left.usedPercent || right.durationSeconds - left.durationSeconds)[0];
+const limitText = (windowArg, thresholdArg) => `${plainText(windowArg.label)} ${usagePercentText(windowArg.usedPercent)} ≥ ${thresholdArg}%`;
+/** When a window resets; one without a known reset never does. */
+const resetTime = (windowArg) => {
+    const time = windowArg.resetAt === null ? Number.NaN : Date.parse(windowArg.resetAt);
+    return Number.isFinite(time) ? time : Number.POSITIVE_INFINITY;
+};
+/** When every one of the account's used-up windows has reset. */
+const usableAt = (readingArg, thresholdArg) => Math.max(...accountWindows(readingArg).filter(window => window.usedPercent >= thresholdArg).map(resetTime));
+/** The reset of the account's longest window: capacity that expires first is used first. */
+const longestWindowReset = (readingArg) => {
+    const windows = accountWindows(readingArg);
+    const longest = Math.max(...windows.map(window => window.durationSeconds));
+    return Math.min(...windows.filter(window => window.durationSeconds === longest).map(resetTime));
+};
+const peakUsage = (readingArg) => Math.max(...accountWindows(readingArg).map(window => window.usedPercent));
+/** Numbers that are both unbounded compare as equal, so the next key decides. */
+const ascending = (leftArg, rightArg) => leftArg === rightArg ? 0 : leftArg < rightArg ? -1 : 1;
+const byLabel = (leftArg, rightArg) => leftArg.label.localeCompare(rightArg.label) || leftArg.id.localeCompare(rightArg.id);
+const byPreference = (leftArg, rightArg) => ascending(longestWindowReset(leftArg), longestWindowReset(rightArg)) || ascending(peakUsage(leftArg), peakUsage(rightArg)) || byLabel(leftArg, rightArg);
+/**
+ * Which account a harness should use, from one set of readings. Pure: the same input always decides the same.
+ *
+ * - The active account is used up when any of its account windows is at or above the threshold. The watch then
+ *   switches to the saved account whose account windows are all at least `WATCH_HYSTERESIS` points below it,
+ *   preferring the one whose longest window resets soonest, then the least used, then by label.
+ * - When no account qualifies and every other saved account with a known reading is used up too, it switches to the
+ *   one that is usable again first, and only when that is more than one interval sooner than the active account.
+ * - An active account limited only on a feature window (one model) switches to an account that is below the margin on
+ *   every window; without one it stays, because the active account still serves everything else.
+ * - A reading that is unknown, whatever the cause, never counts as used up and never makes an account a target.
+ */
+export const decideWatchAction = (inputArg) => {
+    const { threshold } = inputArg;
+    const stay = (okArg, reasonArg) => ({ action: 'stay', ok: okArg, reason: reasonArg });
+    const active = inputArg.readings.find(reading => reading.id === inputArg.activeId);
+    if (!active)
+        return stay(false, 'no active login');
+    if (active.windows === null)
+        return stay(false, `usage unknown${active.unknownReason ? ` (${active.unknownReason})` : ''}`);
+    const margin = threshold - WATCH_HYSTERESIS;
+    const known = inputArg.readings.filter(reading => reading.id !== active.id && reading.isSaved && reading.windows !== null);
+    const below = (windowsArg) => windowsArg.every(window => window.usedPercent < margin);
+    const best = (candidatesArg) => candidatesArg.sort(byPreference)[0];
+    const usedUp = fullest(accountWindows(active), threshold);
+    if (usedUp) {
+        const limit = limitText(usedUp, threshold);
+        const target = best(known.filter(reading => accountWindows(reading).length > 0 && below(accountWindows(reading))));
+        if (target)
+            return { action: 'switch', target: target.id, reason: limit };
+        const exhausted = known.filter(reading => fullest(accountWindows(reading), threshold) !== undefined);
+        if (!exhausted.length || exhausted.length < known.length)
+            return stay(false, `${limit}; no other saved account is known to be below ${margin}%`);
+        const soonest = exhausted.map(reading => ({ reading, at: usableAt(reading, threshold) }))
+            .sort((left, right) => ascending(left.at, right.at) || byLabel(left.reading, right.reading))[0];
+        if (soonest.at < usableAt(active, threshold) - inputArg.intervalMs) {
+            return { action: 'switch', target: soonest.reading.id, reason: `${limit}; every saved account is used up, and ${plainText(soonest.reading.label)} is usable again first (in ${compactUntil(new Date(soonest.at).toISOString(), inputArg.now)})` };
+        }
+        return stay(false, `${limit}; every saved account is used up, and none is usable again sooner`);
+    }
+    const featureLimit = fullest(featureWindows(active), threshold);
+    if (featureLimit) {
+        const limit = limitText(featureLimit, threshold);
+        const target = best(known.filter(reading => accountWindows(reading).length > 0 && below(reading.windows)));
+        if (target)
+            return { action: 'switch', target: target.id, reason: limit };
+        return stay(false, `${limit}; no other saved account is known to be below ${margin}% on every limit`);
+    }
+    return stay(true, `every limit below ${threshold}%`);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0Y2hwb2xpY3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy93YXRjaHBvbGljeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9ELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQThCNUM7OztHQUdHO0FBQ0gsTUFBTSxnQkFBZ0IsR0FBRyxFQUFFLENBQUM7QUFFNUIsTUFBTSxjQUFjLEdBQUcsQ0FBQyxVQUF5QixFQUF5QixFQUFFLENBQUMsQ0FBQyxVQUFVLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUM7QUFDckosTUFBTSxjQUFjLEdBQUcsQ0FBQyxVQUF5QixFQUF5QixFQUFFLENBQUMsQ0FBQyxVQUFVLENBQUMsT0FBTyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLENBQUM7QUFFckosNkhBQTZIO0FBQzdILE1BQU0sT0FBTyxHQUFHLENBQUMsVUFBMEMsRUFBRSxZQUFvQixFQUFtQyxFQUFFLENBQ3BILFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsV0FBVyxJQUFJLFlBQVksQ0FBQztLQUM1RCxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQyxXQUFXLElBQUksS0FBSyxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFFcEgsTUFBTSxTQUFTLEdBQUcsQ0FBQyxTQUE4QixFQUFFLFlBQW9CLEVBQVUsRUFBRSxDQUNqRixHQUFHLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLElBQUksZ0JBQWdCLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxNQUFNLFlBQVksR0FBRyxDQUFDO0FBRWhHLGtFQUFrRTtBQUNsRSxNQUFNLFNBQVMsR0FBRyxDQUFDLFNBQThCLEVBQVUsRUFBRTtJQUMzRCxNQUFNLElBQUksR0FBRyxTQUFTLENBQUMsT0FBTyxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckYsT0FBTyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQztBQUNqRSxDQUFDLENBQUM7QUFFRixpRUFBaUU7QUFDakUsTUFBTSxRQUFRLEdBQUcsQ0FBQyxVQUF5QixFQUFFLFlBQW9CLEVBQVUsRUFBRSxDQUMzRSxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxXQUFXLElBQUksWUFBWSxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFFOUcsNEZBQTRGO0FBQzVGLE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxVQUF5QixFQUFVLEVBQUU7SUFDL0QsTUFBTSxPQUFPLEdBQUcsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQzNDLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUM7SUFDM0UsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxlQUFlLEtBQUssT0FBTyxDQUFDLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFDbEcsQ0FBQyxDQUFDO0FBRUYsTUFBTSxTQUFTLEdBQUcsQ0FBQyxVQUF5QixFQUFVLEVBQUUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO0FBRW5JLGlGQUFpRjtBQUNqRixNQUFNLFNBQVMsR0FBRyxDQUFDLE9BQWUsRUFBRSxRQUFnQixFQUFVLEVBQUUsQ0FBQyxPQUFPLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sR0FBRyxRQUFRLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDeEgsTUFBTSxPQUFPLEdBQUcsQ0FBQyxPQUFzQixFQUFFLFFBQXVCLEVBQVUsRUFBRSxDQUMxRSxPQUFPLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0FBQ3ZGLE1BQU0sWUFBWSxHQUFHLENBQUMsT0FBc0IsRUFBRSxRQUF1QixFQUFVLEVBQUUsQ0FDL0UsU0FBUyxDQUFDLGtCQUFrQixDQUFDLE9BQU8sQ0FBQyxFQUFFLGtCQUFrQixDQUFDLFFBQVEsQ0FBQyxDQUFDLElBQUksU0FBUyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsRUFBRSxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0FBRTNKOzs7Ozs7Ozs7OztHQVdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxRQUEyQixFQUFrQixFQUFFO0lBQy9FLE1BQU0sRUFBRSxTQUFTLEVBQUUsR0FBRyxRQUFRLENBQUM7SUFDL0IsTUFBTSxJQUFJLEdBQUcsQ0FBQyxLQUFjLEVBQUUsU0FBaUIsRUFBa0IsRUFBRSxDQUFDLENBQUMsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDdkgsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNuRixJQUFJLENBQUMsTUFBTTtRQUFFLE9BQU8sSUFBSSxDQUFDLEtBQUssRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO0lBQ25ELElBQUksTUFBTSxDQUFDLE9BQU8sS0FBSyxJQUFJO1FBQUUsT0FBTyxJQUFJLENBQUMsS0FBSyxFQUFFLGdCQUFnQixNQUFNLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxLQUFLLE1BQU0sQ0FBQyxhQUFhLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUM1SCxNQUFNLE1BQU0sR0FBRyxTQUFTLEdBQUcsZ0JBQWdCLENBQUM7SUFDNUMsTUFBTSxLQUFLLEdBQUcsUUFBUSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxFQUFFLElBQUksT0FBTyxDQUFDLE9BQU8sSUFBSSxPQUFPLENBQUMsT0FBTyxLQUFLLElBQUksQ0FBQyxDQUFDO0lBQzNILE1BQU0sS0FBSyxHQUFHLENBQUMsVUFBMEMsRUFBVyxFQUFFLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxXQUFXLEdBQUcsTUFBTSxDQUFDLENBQUM7SUFDL0gsTUFBTSxJQUFJLEdBQUcsQ0FBQyxhQUE4QixFQUE2QixFQUFFLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUVoSCxNQUFNLE1BQU0sR0FBRyxPQUFPLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQzFELElBQUksTUFBTSxFQUFFLENBQUM7UUFDWCxNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQzNDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuSCxJQUFJLE1BQU07WUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQUUsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFDMUUsTUFBTSxTQUFTLEdBQUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLEVBQUUsU0FBUyxDQUFDLEtBQUssU0FBUyxDQUFDLENBQUM7UUFDckcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLElBQUksU0FBUyxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUMsTUFBTTtZQUFFLE9BQU8sSUFBSSxDQUFDLEtBQUssRUFBRSxHQUFHLEtBQUssaURBQWlELE1BQU0sR0FBRyxDQUFDLENBQUM7UUFDakosTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFLFFBQVEsQ0FBQyxPQUFPLEVBQUUsU0FBUyxDQUFDLEVBQUUsQ0FBQyxDQUFDO2FBQ3RGLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNsRyxJQUFJLE9BQU8sQ0FBQyxFQUFFLEdBQUcsUUFBUSxDQUFDLE1BQU0sRUFBRSxTQUFTLENBQUMsR0FBRyxRQUFRLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDbkUsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxHQUFHLEtBQUsseUNBQXlDLFNBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyw4QkFBOEIsWUFBWSxDQUFDLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRSxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ3BQLENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxLQUFLLEVBQUUsR0FBRyxLQUFLLG1FQUFtRSxDQUFDLENBQUM7SUFDbEcsQ0FBQztJQUVELE1BQU0sWUFBWSxHQUFHLE9BQU8sQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDaEUsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNqQixNQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsWUFBWSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQ2pELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLE1BQU0sR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFRLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDNUcsSUFBSSxNQUFNO1lBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDO1FBQzFFLE9BQU8sSUFBSSxDQUFDLEtBQUssRUFBRSxHQUFHLEtBQUssaURBQWlELE1BQU0sa0JBQWtCLENBQUMsQ0FBQztJQUN4RyxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUMsSUFBSSxFQUFFLHFCQUFxQixTQUFTLEdBQUcsQ0FBQyxDQUFDO0FBQ3ZELENBQUMsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -23,7 +23,7 @@
     "authswitch": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.3",
+    "@git.zone/tsbuild": "^4.5.0",
     "@git.zone/tsrun": "^2.0.6",
     "@git.zone/tstest": "^6.1.1",
     "@types/node": "26.5.1"
@@ -31,7 +31,9 @@
   "dependencies": {
     "@modelprofile.com/flexharness-models": "^7.0.1",
     "@modelprofile.com/flexharness-providers": "^7.0.1",
-    "@push.rocks/smartconsole": "^1.3.0"
+    "@push.rocks/smartconsole": "^1.3.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "proper-lockfile": "^4.1.2"
   },
   "files": [
     "ts/**/*",