@cortexkit/opencode-openai-auth 1.3.0 → 1.5.0

package/src/tui-compiled/raw/shared/905bffc0220f43d0-map.js

@@ -14,6 +14,9 @@
 // reset clock. It is a tri-state: absent (never reported), a reading, or
 // cleared (the provider reported that no budget exists).
 //
+// Provider-named counters and the prepaid credits record sit beside them too,
+// each judged by its own observation time rather than the limits'.
+//
 // The map is plain JSON so the store can persist it without interpreting it.
 /** The scope of a limit that binds every request regardless of model. */
 export const ALL_SCOPE = 'all';
@@ -93,6 +96,18 @@ function isQuotaCounter(value) {
 export function isQuotaCounters(value) {
     return isRecord(value) && Object.values(value).every(isQuotaCounter);
 }
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** True when `value` is a well-formed prepaid-credits record. */
+export function isQuotaCredits(value) {
+    return (isRecord(value) &&
+        typeof value.hasCredits === 'boolean' &&
+        typeof value.unlimited === 'boolean' &&
+        optional(value, 'balance', isFiniteNumber) &&
+        optional(value, 'overageLimitReached', isBoolean) &&
+        isFiniteNumber(value.checkedAt));
+}
 /** Keep usable counters without letting one malformed count hide a quota map. */
 export function readQuotaCounters(value) {
     if (!isRecord(value))
@@ -102,20 +117,29 @@ export function readQuotaCounters(value) {
         ? undefined
         : Object.fromEntries(entries);
 }
-/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+/**
+ * Decode persisted quota, dropping malformed counters or a malformed credits
+ * record but not limit or budget evidence.
+ */
 export function decodeQuotaMap(value) {
     // A valid map is returned as the same object, so stored quota keeps the
-    // identity it had before counters existed; only a map with a malformed
-    // counter is copied without it.
+    // identity it had before counters and credits existed. A map with a
+    // malformed counter or credits record is copied with those malformed
+    // fields left out.
     if (isQuotaMap(value))
         return value;
     if (!isRecord(value))
         return undefined;
-    const { counters: rawCounters, ...rest } = value;
+    const { counters: rawCounters, credits: rawCredits, ...rest } = value;
     if (!isQuotaMap(rest))
         return undefined;
     const counters = readQuotaCounters(rawCounters);
-    return { ...rest, ...(counters === undefined ? {} : { counters }) };
+    const credits = isQuotaCredits(rawCredits) ? rawCredits : undefined;
+    return {
+        ...rest,
+        ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
+    };
 }
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys
@@ -136,5 +160,6 @@ export function isQuotaMap(value) {
         seen.add(key);
     }
     return (optional(value, 'budget', isCreditBudgetEntry) &&
-        optional(value, 'counters', isQuotaCounters));
+        optional(value, 'counters', isQuotaCounters) &&
+        optional(value, 'credits', isQuotaCredits));
 }

package/src/tui-compiled/raw/shared/abd062d633e29fd2-pool-routing.js

@@ -1,8 +1,13 @@
-import { projectQuota } from "./d5a8f1061ee2f114-index.js";
+import {
+  budgetExhaustedResetAt,
+  isQuotaCredits,
+  projectQuota
+} from "./d5a8f1061ee2f114-index.js";
 import {
   admit,
   decideStickyBreak,
   orderForPlacement,
+  QUOTA_STALENESS_MS,
   routeOrdered,
   routeSticky
 } from "./3e7d45a77c6ad4d5-index.js";
@@ -65,6 +70,70 @@ export function waitForFirstQuotaReading(input, waitMs = FIRST_QUOTA_READING_WAI
 function isConfirmedExhaustion(refusal) {
   return refusal.reason === "exhausted" || refusal.reason === "budget-spent";
 }
+export function creditsUsable(credits, now) {
+  if (!isQuotaCredits(credits))
+    return !1;
+  const record = credits;
+  if (!(now - record.checkedAt <= QUOTA_STALENESS_MS))
+    return !1;
+  if (record.overageLimitReached === !0)
+    return !1;
+  if (record.unlimited)
+    return !0;
+  return record.hasCredits && (record.balance === void 0 || record.balance > 0);
+}
+function creditsTiers(rows, input, admission) {
+  const passes = (id) => input.killswitch.get(id) !== !1, free = new Set(admission.admitted.filter((row) => row.lastPath !== !0 && passes(row.id)).map((row) => row.id)), refusals = new Map(admission.refused.map((refusal) => [refusal.id, refusal])), credits = rows.filter((row) => {
+    if (row.kind !== "oauth" || !passes(row.id))
+      return !1;
+    if (refusals.get(row.id)?.reason !== "exhausted")
+      return !1;
+    const projection = projectQuota(row.quota);
+    if (budgetExhaustedResetAt(projection, input.now))
+      return !1;
+    return creditsUsable(projection.credits, input.now);
+  }).map((row) => row.id);
+  return { free, credits };
+}
+function admitQuietly(input, rows = input.rows) {
+  return admit({
+    rows,
+    now: input.now,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    requestPull: () => {}
+  });
+}
+export function creditsFallbackIds(input) {
+  return [...creditsTiers(input.rows, input, admitQuietly(input)).credits];
+}
+
+export class CreditsServing {
+  #ids = new Set;
+  served(input, id, log) {
+    const admission = admitQuietly(input), tiers = creditsTiers(input.rows, input, admission), credits = new Set(tiers.credits);
+    if (tiers.free.has(id)) {
+      this.#ids.clear();
+      return;
+    }
+    for (const marked of [...this.#ids])
+      if (!credits.has(marked))
+        this.#ids.delete(marked);
+    if (!credits.has(id) || this.#ids.has(id))
+      return;
+    this.#ids.add(id);
+    log?.info("serving requests on prepaid credits", {
+      accountId: id,
+      reason: "free quota used up"
+    });
+  }
+  has(id) {
+    return this.#ids.has(id);
+  }
+  ids() {
+    return new Set(this.#ids);
+  }
+}
 export function blockFor(id, admission, killswitch) {
   if (id === void 0)
     return { reason: "no-credential" };
@@ -97,11 +166,13 @@ export function planOrdered(input) {
     refreshBackoff: input.refreshBackoff,
     now: input.now,
     requestPull: input.requestPull
-  }), ids = orderForPlacement(input.rows.map((row) => row.id), placement, mainId), confirmed = new Set(route.admission.refused.filter((refusal) => isConfirmedExhaustion(refusal) && input.killswitch.get(refusal.id) !== !1).map((refusal) => refusal.id)), lastPath = ids.filter((id) => confirmed.has(id));
+  }), ids = orderForPlacement(input.rows.map((row) => row.id), placement, mainId), confirmed = new Set(route.admission.refused.filter((refusal) => isConfirmedExhaustion(refusal) && input.killswitch.get(refusal.id) !== !1).map((refusal) => refusal.id)), lastPath = ids.filter((id) => confirmed.has(id)), tiers = creditsTiers(input.rows, input, route.admission), free = route.order.filter((id) => tiers.free.has(id)), credits = ids.filter((id) => tiers.credits.includes(id));
   if (!replayable) {
-    const hasMain = ids.includes(mainId), target = hasMain ? mainId : route.order[0] ?? lastPath[0];
+    const hasMain = ids.includes(mainId), target = hasMain ? mainId : free[0] ?? credits[0] ?? route.order[0] ?? lastPath[0];
     if (target !== void 0 && route.order.includes(target))
       return { kind: "send", order: [target], lastPath: !1 };
+    if (target !== void 0 && credits.includes(target))
+      return { kind: "send", order: [target], lastPath: !1 };
     if (target !== void 0 && confirmed.has(target))
       return { kind: "send", order: [target], lastPath: !0 };
     return {
@@ -109,6 +180,16 @@ export function planOrdered(input) {
       block: hasMain ? blockFor(mainId, route.admission, input.killswitch) : routeBlock(ids, route.admission, input.killswitch)
     };
   }
+  if (free.length > 0)
+    return { kind: "send", order: free, lastPath: !1 };
+  if (credits.length > 0) {
+    const rest = route.order.length > 0 ? route.order : lastPath;
+    return {
+      kind: "send",
+      order: [...credits, ...rest.filter((id) => !credits.includes(id))],
+      lastPath: !1
+    };
+  }
   if (route.order.length > 0)
     return { kind: "send", order: route.order, lastPath: !1 };
   if (lastPath.length > 0)
@@ -160,23 +241,46 @@ function routePoolSticky(input, options, extra) {
   });
 }
 export function selectStickyRow(input, options, exclude, pendingBytes) {
-  const route = routePoolSticky(input, options, { exclude, pendingBytes });
-  if (route.outcome !== "dispatch" || route.source === "pin")
-    return;
-  return {
+  const route = routePoolSticky(input, options, { exclude, pendingBytes }), rows = input.rows.filter((row) => !exclude.has(row.id)), tiers = creditsTiers(rows, input, route.admission), selected = route.outcome === "dispatch" && route.source !== "pin" ? {
     accountId: route.accountId,
     source: route.source,
     ...route.quotaCheckedAt === void 0 ? {} : { quotaCheckedAt: route.quotaCheckedAt }
+  } : void 0;
+  if (selected && tiers.free.has(selected.accountId))
+    return selected;
+  const credits = tiers.credits[0];
+  if (credits === void 0)
+    return selected;
+  const checkedAt = projectQuota(rows.find((row) => row.id === credits)?.quota).checkedAt;
+  return {
+    accountId: credits,
+    source: "mode-fallback",
+    ...checkedAt === void 0 ? {} : { quotaCheckedAt: checkedAt }
   };
 }
 export function routePinnedRow(input, options, id) {
-  const killed = input.killswitch.get(id) === !1, route = routePoolSticky(input, options, { pin: id });
+  const killed = input.killswitch.get(id) === !1, move = {
+    kind: "move",
+    reason: killed ? "killswitch" : "exhausted"
+  }, route = routePoolSticky(input, options, { pin: id }), tiers = creditsTiers(input.rows, input, route.admission), onCredits = tiers.credits.includes(id), othersOnCredits = tiers.credits.some((other) => other !== id);
   if (route.outcome === "dispatch") {
-    if (route.pin.action === "assign")
-      return { kind: "move", reason: killed ? "killswitch" : "exhausted" };
-    return route.accountId === id ? { kind: "serve" } : { kind: "detour" };
+    const toLastPath = !tiers.free.has(route.accountId);
+    if (route.pin.action === "assign") {
+      if (toLastPath && onCredits)
+        return { kind: "serve" };
+      return move;
+    }
+    if (route.accountId !== id)
+      return { kind: "detour" };
+    if (toLastPath && othersOnCredits)
+      return move;
+    return { kind: "serve" };
   }
-  const refusal = route.admission.refused.find((entry) => entry.id === id);
+  const refusal = route.admission.refused.find((entry) => entry.id === id), confirmed = killed || refusal !== void 0 && isConfirmedExhaustion(refusal);
+  if (onCredits)
+    return { kind: "serve" };
+  if (othersOnCredits)
+    return confirmed ? move : { kind: "detour" };
   if (!killed && refusal && isConfirmedExhaustion(refusal))
     return { kind: "last-path" };
   return { kind: "none" };

package/src/tui-compiled/raw/shared/b9588ad4725c1d10-enrollment.js

@@ -10,12 +10,22 @@ const ENROLLMENT_SCHEMA = 1;
 const ENROLLMENT_FILE_MAX_BYTES = 16 * 1024;
 const ENROLLMENT_LOCK_TTL_MS = 30_000;
 const TOKEN_RE = /^[0-9a-f]{64}$/;
+/**
+ * The code a vault without the enrollment ceremony answers a proposal with.
+ * Setup reports it as "this vault cannot connect plugins" instead of waiting.
+ */
+export const UNSUPPORTED_ENROLLMENT_CODE = 'unknown_method';
 /**
  * Codes the vault's closed enrollment-refusal vocabulary marks permanent. The
  * client labels some module error frames transient/retry regardless, so the
  * producer's code takes precedence over the client's action for these.
  */
 export const TERMINAL_ENROLLMENT_CODES = new Set([
+    // The daemon's answer to an operation it does not implement: a vault built
+    // before the enrollment ceremony. It arrives as a transport Error frame with
+    // no class, which claustrum-client before 0.13.0 labels transient/retry, but
+    // asking again can never succeed.
+    UNSUPPORTED_ENROLLMENT_CODE,
     'invalid_params',
     'pending_exists',
     'not_found',
@@ -638,6 +648,23 @@ export class ClaustrumEnrollmentManager {
                             retryCode: refusal.code,
                         };
                     }
+                    // A vault without the ceremony cannot hold a request for this
+                    // proposal, now or from an earlier run (the state has no request
+                    // id). So nothing is blocked and nothing is in progress: remove the
+                    // pending state, still under the ceremony lock, so status reads as
+                    // "not enrolled" and a reset or a later run starts afresh.
+                    if (refusal.code === UNSUPPORTED_ENROLLMENT_CODE) {
+                        await lock.assertOwned();
+                        await unlink(this.#paths.statePath).catch((cause) => {
+                            if (cause.code !== 'ENOENT')
+                                throw cause;
+                        });
+                        return {
+                            state: 'unavailable',
+                            proposedName: state.proposedName,
+                            code: refusal.code,
+                        };
+                    }
                     return this.#block(state, refusal.code);
                 }
             }

package/src/tui-compiled/raw/shared/bfbdd0f9aae56b47-pool-quota.js

@@ -42,6 +42,17 @@ function budgetFor(snapshot) {
     return { kind: "cleared" };
   return;
 }
+function prepaidCreditsFor(value, checkedAt) {
+  if (!isRecord(value) || typeof value.hasCredits !== "boolean" || typeof value.unlimited !== "boolean")
+    return;
+  return {
+    hasCredits: value.hasCredits,
+    unlimited: value.unlimited,
+    ...finite(value.balance) && value.balance >= 0 ? { balance: value.balance } : {},
+    ...typeof value.overageLimitReached === "boolean" ? { overageLimitReached: value.overageLimitReached } : {},
+    checkedAt
+  };
+}
 export function observationFromSnapshot(snapshot, checkedAt, complete) {
   if (!isRecord(snapshot) || !finite(checkedAt))
     return;
@@ -53,15 +64,16 @@ export function observationFromSnapshot(snapshot, checkedAt, complete) {
     else if (complete)
       coverage.push({ label });
   }
-  const budget = budgetFor(snapshot), credits = snapshot.resetCreditsAvailable, counters = typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0 ? { resetCredits: { value: credits, checkedAt } } : void 0;
-  if (readings.length === 0 && coverage.length === 0 && !budget && !counters)
+  const budget = budgetFor(snapshot), credits = snapshot.resetCreditsAvailable, counters = typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0 ? { resetCredits: { value: credits, checkedAt } } : void 0, prepaid = prepaidCreditsFor(snapshot.credits, checkedAt);
+  if (readings.length === 0 && coverage.length === 0 && !budget && !counters && !prepaid)
     return;
   return {
     checkedAt,
     ...readings.length > 0 ? { readings } : {},
     ...coverage.length > 0 ? { coverage } : {},
     ...budget ? { budget } : {},
-    ...counters ? { counters } : {}
+    ...counters ? { counters } : {},
+    ...prepaid ? { credits: prepaid } : {}
   };
 }
 export function windowsFromQuotaMap(map) {

package/src/tui-compiled/raw/shared/d0f0b6be200311af-insula.js

@@ -128,6 +128,9 @@ export function insulaUsageTransport(options) {
 }
 const MINUTE = 60_000;
 const MAX_AGE = 4 * MINUTE;
+// consumer-contract.md:331 refetches a slot after 60 s. Two such intervals
+// bound our willingness to wait, not a claim that insula completed its sweep.
+const COLD_WAIT = 2 * MINUTE;
 const sources = new Map();
 // Keep only the minute budget after the last owner closes, so project churn
 // cannot reset the bound. Expired budgets are pruned on the next tick.
@@ -170,6 +173,9 @@ export class InsulaQuotaSource {
     transport;
     key;
     #entries = [];
+    #available = false;
+    #completeProviders = new Set();
+    #coldSince = new Map();
     /** Every usage.get, polled or watch-driven, shares this one slot. */
     #reads = new CoalescedRead(async () => {
         try {
@@ -178,13 +184,25 @@ export class InsulaQuotaSource {
                 !Array.isArray(reply.result) ||
                 reply.error !== undefined)
                 throw new Error('unavailable insula usage');
-            // Each response is a snapshot, not a delta. Missing accounts fall back;
-            // neither pending nor the entry count asserts provider completeness.
+            // Each response is a snapshot, not a delta. Only completeProviders
+            // asserts completeness; neither pending nor the entry count does.
             this.#entries = reply.result.filter((entry) => record(entry) && typeof entry.provider === 'string');
+            this.#available =
+                this.#entries.length === reply.result.length &&
+                    (reply.completeProviders === undefined ||
+                        (Array.isArray(reply.completeProviders) &&
+                            reply.completeProviders.every((value) => typeof value === 'string')));
+            this.#completeProviders = new Set(this.#available && Array.isArray(reply.completeProviders)
+                ? reply.completeProviders
+                : []);
+            for (const provider of this.#completeProviders)
+                this.#coldSince.delete(provider);
         }
         catch {
             // Refusal is absence, even if the previous reading was still young.
             this.#entries = [];
+            this.#available = false;
+            this.#completeProviders.clear();
         }
     }, () => { });
     #reader = new ChangeNoticeReader();
@@ -391,6 +409,50 @@ export class InsulaQuotaSource {
         }
         return undefined;
     }
+    /** Cache-only background lookup; current() retains its original miss behavior. */
+    lookup(provider, accountId, now) {
+        if (!this.#available)
+            return { miss: 'unreachable' };
+        const entry = this.#entries.find((value) => value.provider === provider &&
+            typeof value.account === 'string' &&
+            value.account.trim() === accountId);
+        // An unlabelled error describes the provider's credential path, not an
+        // unrelated labelled account. Never borrow another account's verdict.
+        const errorClass = (entry ??
+            this.#entries.find((value) => value.provider === provider &&
+                value.account === undefined &&
+                value.errorClass !== undefined))?.errorClass;
+        if (errorClass === 'upstream_failed')
+            return { miss: 'upstream-failed' };
+        if (errorClass === 'credential_absent' ||
+            errorClass === 'credential_unusable' ||
+            errorClass === 'credential_rejected')
+            return { miss: 'credential' };
+        if (errorClass !== undefined)
+            return { miss: 'unreachable' };
+        if (entry) {
+            const fetchedAt = typeof entry.fetchedAt === 'string'
+                ? Date.parse(entry.fetchedAt)
+                : Number.NaN;
+            if (!record(entry.usage) || !Number.isFinite(fetchedAt))
+                return { miss: 'unreachable' };
+            const reading = {
+                entry,
+                context: {
+                    fetchedAt,
+                    ...(typeof entry.source === 'string' && { source: entry.source }),
+                },
+            };
+            return now >= fetchedAt + MAX_AGE || entry.stale !== undefined
+                ? { miss: 'stale', reading }
+                : { reading };
+        }
+        if (this.#completeProviders.has(provider))
+            return { miss: 'absent' };
+        const since = this.#coldSince.get(provider) ?? now;
+        this.#coldSince.set(provider, since);
+        return { miss: now - since >= COLD_WAIT ? 'unreachable' : 'cold' };
+    }
 }
 export function acquireInsulaQuotaSource(transport, tokenPath) {
     const key = JSON.stringify([

package/src/tui-compiled/raw/shared/d5a8f1061ee2f114-index.js

@@ -1,5 +1,5 @@
 export { quotaCodec } from "./053cc17b5419261e-codec.js";
-export { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from "./0332701351b3eeec-format.js";
-export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from "./905bffc0220f43d0-map.js";
+export { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaCreditsText, quotaTextParts, quotaWindowName, quotaWindowParts, } from "./0332701351b3eeec-format.js";
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaCredits, isQuotaMap, } from "./905bffc0220f43d0-map.js";
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from "./4f36d333d081d040-merge.js";
 export { budgetExhaustedResetAt, futureResetAt, projectQuota, readsExhausted, } from "./39c3cb05738fcf6d-projection.js";

package/src/tui-compiled/raw/shared/dbc61cd405941828-accounts.js

@@ -154,13 +154,14 @@ function normalizeQuota(value) {
       };
   }
   const credits = value.credits;
-  if (isRecord(credits) && typeof credits.hasCredits === "boolean" && typeof credits.unlimited === "boolean" && typeof credits.overageLimitReached === "boolean") {
-    const balance = Number(credits.balance);
+  if (isRecord(credits) && typeof credits.hasCredits === "boolean" && typeof credits.unlimited === "boolean" && (credits.overageLimitReached === void 0 || typeof credits.overageLimitReached === "boolean")) {
+    const balance = Number(credits.balance), checkedAt = typeof credits.checkedAt === "number" ? credits.checkedAt : Number.NaN;
     quota.credits = {
       hasCredits: credits.hasCredits,
       unlimited: credits.unlimited,
-      overageLimitReached: credits.overageLimitReached,
-      ...Number.isFinite(balance) ? { balance } : {}
+      ...typeof credits.overageLimitReached === "boolean" ? { overageLimitReached: credits.overageLimitReached } : {},
+      ...Number.isFinite(balance) ? { balance } : {},
+      ...Number.isFinite(checkedAt) ? { checkedAt } : {}
     };
   }
   return Object.keys(quota).length ? quota : void 0;

package/src/tui-compiled/raw/shared/dc9290c2a7552ba6-watch.js

@@ -109,8 +109,9 @@ export class ScopedRosterWatch {
         this.#reads = new CoalescedRead(async () => {
             const force = this.#force;
             this.#force = false;
+            // A read is only ever requested by a notice, which set #latestView.
             if (force || this.#latestView !== this.#options.view())
-                await this.#options.discover();
+                await this.#options.discover(this.#latestView ?? '');
         }, (error) => {
             if (!this.#stopped)
                 this.#options.onError?.(error);

package/src/tui-compiled/raw/shared/e8d3c8da776ef9cd-index.js

@@ -14,7 +14,8 @@ export { ClaustrumConsumerError, } from "./ca0fccaba1d87af4-errors.js";
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, isCustodyPlaceholder, isCustodyPlaceholderValue, } from "./d9d2892a4c371301-host-slot.js";
 export { acquireInsulaQuotaSource, } from "./d0f0b6be200311af-insula.js";
 export { acceptAccount, declineAccount, isDeclined, } from "./7c140680fc81be92-interlock.js";
-export { acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, mutateVaultRoster, projectVaultRoster, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
+export { drainVaultQuota } from "./81dddd203f1b92a3-quota-writer.js";
+export { acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, mutateVaultRoster, projectVaultRoster, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, reorderVaultRoster, resolveVaultPrimary, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
 export { ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, WATCH_RETRY_MS, } from "./dc9290c2a7552ba6-watch.js";
 /**
  * Connect the client that lists and fetches this consumer's vault credentials

package/src/tui-compiled/raw/sidebar-state.js

@@ -2,13 +2,35 @@ import {
   formatQuota,
   isQuotaStale,
   projectQuota,
+  quotaCreditsText,
   quotaWindowName
 } from "./shared/d5a8f1061ee2f114-index.js";
 import { orderForPlacement } from "./shared/3e7d45a77c6ad4d5-index.js";
 import {
+  creditsUsable,
   orderedPlacement,
   vaultMainRouteId
 } from "./shared/abd062d633e29fd2-pool-routing.js";
+export function accountCreditsText(quota) {
+  const credits = quota?.credits;
+  if (credits === null || typeof credits !== "object")
+    return;
+  const { hasCredits, unlimited, balance } = credits;
+  if (typeof hasCredits !== "boolean" || typeof unlimited !== "boolean")
+    return;
+  return quotaCreditsText({
+    hasCredits,
+    unlimited,
+    ...typeof balance === "number" ? { balance } : {}
+  });
+}
+export function accountServesOnCredits(quota, now = Date.now()) {
+  if (!exhaustedQuotaResetAt(quota, now))
+    return !1;
+  if (spendControlExhaustedResetAt(quota, now))
+    return !1;
+  return creditsUsable(quota?.credits, now);
+}
 const QUOTA_WINDOW_KEYS = ["primary", "secondary"], LEGACY_WINDOW_MINUTES = {
   primary: 300,
   secondary: 10080
@@ -153,7 +175,7 @@ export function normalizeSidebarState(raw) {
     };
   } else
     main = { quota: null, killed: !1 };
-  const fallbacks = normalizeAccountList(r.fallbacks), vaultAccounts = Array.isArray(r.vaultAccounts) ? normalizeAccountList(r.vaultAccounts) : void 0, activeId = typeof r.activeId === "string" ? r.activeId : void 0, route = typeof r.route === "string" ? r.route : DEFAULT_SIDEBAR_STATE.route, lastUpdated = typeof r.lastUpdated === "number" ? r.lastUpdated : 0, planType = typeof r.planType === "string" ? r.planType : void 0, credits = typeof r.credits === "number" ? r.credits : void 0, activeRouting = normalizeActiveRouting(r.activeRouting), stickyAssignments = normalizeStickyAssignments(r.stickyAssignments);
+  const fallbacks = normalizeAccountList(r.fallbacks), vaultAccounts = Array.isArray(r.vaultAccounts) ? normalizeAccountList(r.vaultAccounts) : void 0, activeId = typeof r.activeId === "string" ? r.activeId : void 0, route = typeof r.route === "string" ? r.route : DEFAULT_SIDEBAR_STATE.route, lastUpdated = typeof r.lastUpdated === "number" ? r.lastUpdated : 0, planType = typeof r.planType === "string" ? r.planType : void 0, activeRouting = normalizeActiveRouting(r.activeRouting), stickyAssignments = normalizeStickyAssignments(r.stickyAssignments);
   return {
     main,
     fallbacks,
@@ -163,7 +185,6 @@ export function normalizeSidebarState(raw) {
     ...activeRouting !== void 0 ? { activeRouting } : {},
     ...stickyAssignments !== void 0 ? { stickyAssignments } : {},
     ...planType !== void 0 ? { planType } : {},
-    ...credits !== void 0 ? { credits } : {},
     ...r.accountPool === !0 ? { accountPool: !0 } : {},
     ...vaultAccounts !== void 0 ? { vaultAccounts } : {}
   };
@@ -491,12 +512,18 @@ function mergeSpendControl(fresher, older) {
     return;
   return older.spendControl;
 }
+function fresherCredits(incoming, existing) {
+  if (!incoming || !existing)
+    return incoming ?? existing;
+  const at = (credits) => typeof credits.checkedAt === "number" && Number.isFinite(credits.checkedAt) ? credits.checkedAt : Number.NEGATIVE_INFINITY;
+  return at(existing) > at(incoming) ? existing : incoming;
+}
 function mergeQuotaByWindow(incoming, existing) {
   if (!incoming)
     return existing;
   if (!existing)
     return incoming;
-  const incomingAt = latestQuotaCheckedAt(incoming), existingAt = latestQuotaCheckedAt(existing), existingSnapshotIsFresher = existingAt !== void 0 && (incomingAt === void 0 || existingAt > incomingAt), primary = freshestWindow(incoming.primary, existing.primary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), secondary = freshestWindow(incoming.secondary, existing.secondary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), spendControl = existingSnapshotIsFresher ? mergeSpendControl(existing, incoming) : mergeSpendControl(incoming, existing), spendControlCleared = spendControl === void 0 && (incoming.spendControlCleared === !0 || existing.spendControlCleared === !0);
+  const incomingAt = latestQuotaCheckedAt(incoming), existingAt = latestQuotaCheckedAt(existing), existingSnapshotIsFresher = existingAt !== void 0 && (incomingAt === void 0 || existingAt > incomingAt), primary = freshestWindow(incoming.primary, existing.primary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), secondary = freshestWindow(incoming.secondary, existing.secondary, existingSnapshotIsFresher, incoming.checkedAt, existing.checkedAt), spendControl = existingSnapshotIsFresher ? mergeSpendControl(existing, incoming) : mergeSpendControl(incoming, existing), spendControlCleared = spendControl === void 0 && (incoming.spendControlCleared === !0 || existing.spendControlCleared === !0), credits = fresherCredits(incoming.credits, existing.credits);
   let checkedAt;
   for (const stamp of [
     finiteWindowCheckedAt(primary),
@@ -507,6 +534,7 @@ function mergeQuotaByWindow(incoming, existing) {
   const {
     spendControl: _incomingSpendControl,
     spendControlCleared: _incomingCleared,
+    credits: _incomingCredits,
     ...incomingRest
   } = incoming;
   return {
@@ -515,6 +543,7 @@ function mergeQuotaByWindow(incoming, existing) {
     secondary,
     ...spendControl !== void 0 ? { spendControl } : {},
     ...spendControlCleared ? { spendControlCleared: !0 } : {},
+    ...credits !== void 0 ? { credits } : {},
     checkedAt: checkedAt ?? incoming.checkedAt
   };
 }

package/src/tui-compiled/raw/tui/v2-dialog.js

@@ -22,7 +22,8 @@ export async function openControlDialog(dialog, initial, apply, active = () => !
       const choices = [
         ...section.items.filter((item) => item.actions.length > 0).map((item) => ({
           title: item.label,
-          description: inlineDescription(item.status, item.detail),
+          description: inlineDescription(item.detail),
+          ...item.status ? { footer: item.status } : {},
           value: { itemId: item.id, actions: item.actions }
         })),
         ...section.actions.map((action) => ({