@cortexkit/opencode-openai-auth 1.2.0 → 1.4.0

package/src/tui-compiled/runtime/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/runtime/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/runtime/shared/d0f0b6be200311af-insula.js

@@ -5,6 +5,8 @@ import { storeIdentity } from "@cortexkit/claustrum-client";
 // import makes bundlers emit a separate chunk that a running host loses when
 // its dist folder is rebuilt underneath it.
 import { SubcClient } from "@cortexkit/subc-client";
+import { classifyVaultFailure } from "./94f53cfd572ba4bb-availability.js";
+import { ChangeNoticeReader, CoalescedRead, RESUBSCRIBE_BACKOFF_MS, WATCH_RETRY_MS, } from "./dc9290c2a7552ba6-watch.js";
 /** Constructing this transport opens no connection; getUsage opens one per call. */
 export function insulaUsageTransport(options) {
     const identity = options.identity ??
@@ -49,10 +51,86 @@ export function insulaUsageTransport(options) {
                 client?.close();
             }
         },
+        watchUsage(onNotice) {
+            // The watch holds its own connection for as long as it is open: each
+            // usage.get above opens and closes a short-lived one, and the scoped
+            // credential connection is never shared with insula. The method name
+            // alone makes the request a watch; subc-client does not yet set the
+            // SUBSCRIPTION flag, and insula does not require it.
+            let client;
+            let subscription;
+            let stopped = false;
+            const closed = (async () => {
+                let deadline;
+                const timeout = new Promise((_resolve, reject) => {
+                    deadline = setTimeout(
+                    // Coded as a timeout, so InsulaQuotaSource treats a watch that could
+                    // not open in time as an unreachable insula and tries again later,
+                    // not as a refusal.
+                    () => reject(Object.assign(new Error('insula watch timeout'), {
+                        code: 'timeout',
+                    })), 3_000);
+                    deadline.unref?.();
+                });
+                const open = (async () => {
+                    const handshakeTimeoutMs = Math.min(options.handshakeTimeoutMs ?? 3_000, 3_000);
+                    const connected = options.connector
+                        ? await options.connector({
+                            connectionFile: options.connectionFile,
+                            handshakeTimeoutMs,
+                        })
+                        : await SubcClient.connect({
+                            connectionFile: options.connectionFile,
+                            handshakeTimeoutMs,
+                        });
+                    client = connected;
+                    // A connection that arrives after stop() or after the open deadline
+                    // must not keep a route or socket alive.
+                    if (stopped) {
+                        connected.close();
+                        return;
+                    }
+                    const route = await connected.routeOpen({ kind: 'management_surface', module_id: 'insula' }, identity);
+                    if (stopped) {
+                        connected.close();
+                        return;
+                    }
+                    subscription = connected.subscribe(route, { method: 'usage.watch' }, onNotice);
+                })();
+                try {
+                    await Promise.race([open, timeout]);
+                }
+                catch (error) {
+                    stopped = true;
+                    throw error;
+                }
+                finally {
+                    clearTimeout(deadline);
+                }
+                if (subscription)
+                    await subscription.closed;
+            })().finally(() => {
+                stopped = true;
+                client?.close();
+            });
+            return {
+                stop() {
+                    if (stopped)
+                        return;
+                    stopped = true;
+                    subscription?.unsubscribe();
+                    client?.close();
+                },
+                closed,
+            };
+        },
     };
 }
 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.
@@ -60,18 +138,107 @@ const attempts = new Map();
 function record(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function decodeUsageNotice(body) {
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(body));
+    }
+    catch {
+        return undefined;
+    }
+    if (!record(value) ||
+        typeof value.kind !== 'string' ||
+        typeof value.epoch !== 'string' ||
+        value.epoch.length === 0 ||
+        typeof value.seq !== 'number' ||
+        !Number.isSafeInteger(value.seq) ||
+        value.seq < 1 ||
+        (value.provider !== undefined && typeof value.provider !== 'string'))
+        return undefined;
+    return {
+        kind: value.kind,
+        epoch: value.epoch,
+        seq: value.seq,
+        ...(typeof value.provider === 'string' && { provider: value.provider }),
+    };
+}
+function refusalCode(error) {
+    return error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string'
+        ? error.code
+        : undefined;
+}
 export class InsulaQuotaSource {
     transport;
     key;
     #entries = [];
-    #pending;
+    #available = false;
+    #completeProviders = new Set();
+    #coldSince = new Map();
+    /** Every usage.get, polled or watch-driven, shares this one slot. */
+    #reads = new CoalescedRead(async () => {
+        try {
+            const reply = await this.transport.getUsage();
+            if (!record(reply) ||
+                !Array.isArray(reply.result) ||
+                reply.error !== undefined)
+                throw new Error('unavailable insula usage');
+            // 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();
+    #mode = 'polling';
+    #watchers = 0;
+    /**
+     * How many registered watchers read every provider. Watchers limited to one
+     * provider are counted per provider in `#providers` instead.
+     */
+    #everyProvider = 0;
+    #providers = new Map();
+    #watch;
+    #timer;
+    #timers = {};
+    /**
+     * How many accepted watches in a row have closed; each one doubles the wait
+     * before the next re-subscribe. Reset once a watch brings a second notice.
+     */
+    #closes = 0;
     constructor(transport, key) {
         this.transport = transport;
         this.key = key;
     }
+    /**
+     * The background poll: at most one usage.get per minute per daemon and
+     * enrollment token. While a watch is open it reads nothing, because insula's
+     * notices announce every new reading. If insula stops announcing an account,
+     * that account's last entry grows older than the freshness limit `current()`
+     * applies, `current()` returns nothing for it, and the plugin falls back to
+     * its own provider poll for that account.
+     */
     refresh(now) {
-        if (this.#pending)
-            return this.#pending;
+        if (this.#reads.running)
+            return this.#reads.running;
+        if (this.#mode === 'watching')
+            return Promise.resolve();
         for (const [key, time] of attempts) {
             if (now - time >= MINUTE)
                 attempts.delete(key);
@@ -81,25 +248,141 @@ export class InsulaQuotaSource {
             return Promise.resolve();
         // Reserve the minute before I/O, so concurrent projects cannot each poll.
         attempts.set(this.key, now);
-        this.#pending = (async () => {
-            try {
-                const reply = await this.transport.getUsage();
-                if (!record(reply) ||
-                    !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.
-                this.#entries = reply.result.filter((entry) => record(entry) && typeof entry.provider === 'string');
-            }
-            catch {
-                // Refusal is absence, even if the previous reading was still young.
-                this.#entries = [];
+        return this.#reads.request();
+    }
+    /** How this source currently learns about usage changes, for logs. */
+    watchMode() {
+        return this.#mode;
+    }
+    /**
+     * Hold a `usage.watch` open while any watcher wants it, and re-read
+     * usage.get when a notice says something changed. Watchers of one source
+     * share one watch, since insula admits only 64 per process. Returns the
+     * release; the last release closes the watch.
+     */
+    watch(options = {}) {
+        this.#watchers++;
+        const provider = options.provider;
+        if (provider === undefined)
+            this.#everyProvider++;
+        else
+            this.#providers.set(provider, (this.#providers.get(provider) ?? 0) + 1);
+        if (this.#watchers === 1) {
+            this.#timers = options;
+            this.#open();
+        }
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (provider === undefined)
+                this.#everyProvider--;
+            else {
+                const left = (this.#providers.get(provider) ?? 1) - 1;
+                if (left > 0)
+                    this.#providers.set(provider, left);
+                else
+                    this.#providers.delete(provider);
             }
-        })().finally(() => {
-            this.#pending = undefined;
-        });
-        return this.#pending;
+            if (--this.#watchers === 0)
+                this.#stopWatch();
+        };
+    }
+    #stopWatch() {
+        if (this.#timer)
+            (this.#timers.clearTimeoutImpl ?? clearTimeout)(this.#timer);
+        this.#timer = undefined;
+        const watch = this.#watch;
+        this.#watch = undefined;
+        watch?.handle?.stop();
+        this.#mode = 'polling';
+    }
+    #later(delay) {
+        this.#timer = (this.#timers.setTimeoutImpl ?? setTimeout)(() => {
+            this.#timer = undefined;
+            if (this.#watchers > 0 && !this.#watch)
+                this.#open();
+        }, delay);
+        this.#timer.unref?.();
+    }
+    #open() {
+        const watchUsage = this.transport.watchUsage;
+        if (!watchUsage) {
+            // A custom transport that cannot watch: poll exactly as before.
+            this.#mode = 'fallback';
+            return;
+        }
+        this.#mode = 'polling';
+        this.#reader.restart();
+        const watch = { notices: 0 };
+        this.#watch = watch;
+        let handle;
+        try {
+            handle = watchUsage.call(this.transport, (body) => this.#notice(watch, body));
+        }
+        catch (error) {
+            this.#closed(watch, error);
+            return;
+        }
+        watch.handle = handle;
+        handle.closed.then(() => this.#closed(watch, undefined), (error) => this.#closed(watch, error));
+    }
+    #notice(watch, body) {
+        // Frames already in transport can arrive after a local stop.
+        if (this.#watch !== watch)
+            return;
+        watch.notices++;
+        if (watch.notices === 1)
+            this.#mode = 'watching';
+        // A second notice means the watch stayed up past its acceptance.
+        if (watch.notices === 2)
+            this.#closes = 0;
+        const notice = decodeUsageNotice(body);
+        // An unreadable notice may hide any change: treat it as a break, and
+        // make the next notice read as one too.
+        if (!notice)
+            this.#reader.restart();
+        const continuous = notice ? this.#reader.continuous(notice) : false;
+        // The first notice of every watch names no provider, so it always reads:
+        // nothing was watched before it. After a gap or a new epoch notices were
+        // lost, so read even when this notice names another provider.
+        if (!continuous ||
+            notice?.provider === undefined ||
+            this.#everyProvider > 0 ||
+            this.#providers.has(notice.provider))
+            void this.#reads.request();
+    }
+    #closed(watch, error) {
+        if (this.#watch !== watch)
+            return;
+        this.#watch = undefined;
+        const code = refusalCode(error);
+        if (code === 'unknown_method' || code === 'usage_watch_limit') {
+            // An insula that predates usage.watch, or one already holding 64
+            // watches: poll exactly as before until every watcher has released.
+            this.#mode = 'fallback';
+            return;
+        }
+        if (watch.notices > 0) {
+            // An accepted watch that closed (insula shut down, or the connection
+            // dropped) gets one new watch, whose first notice reads usage.get.
+            const delay = Math.min(RESUBSCRIBE_BACKOFF_MS * 2 ** Math.min(this.#closes, 16), WATCH_RETRY_MS);
+            this.#closes++;
+            this.#mode = 'polling';
+            this.#later(delay);
+            return;
+        }
+        // Closed before any notice, so never accepted: read once to learn
+        // whether insula answers at all, then poll as before. A refusal insula
+        // answered stands until every watcher has released. A close it did not
+        // explain (a
+        // dropped connection, a timeout, a stream ended at once while insula
+        // shuts down) earns one new watch much later.
+        this.#mode = 'fallback';
+        void this.#reads.request();
+        if (error === undefined || classifyVaultFailure(error) === 'unreachable')
+            this.#later(WATCH_RETRY_MS);
     }
     current(provider, accountId, now) {
         for (const entry of this.#entries) {
@@ -126,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/runtime/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/runtime/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;