@cortexkit/opencode-openai-auth 1.0.5 → 1.2.0

package/src/tui-compiled/raw/shared/134b008900698fe0-backoff.js

@@ -0,0 +1,92 @@
+import { createHash } from "node:crypto";
+export const NON_TRANSIENT_REFRESH_RETRY_DELAY_MS = 86400000;
+const MIN_REFRESH_RETRY_DELAY_MS = 300000, MAX_REFRESH_RETRY_DELAY_MS = 3600000, MIN_QUOTA_RETRY_DELAY_MS = 60000, MAX_QUOTA_RETRY_DELAY_MS = 900000, NON_TRANSIENT_QUOTA_RETRY_DELAY_MS = 300000;
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export function isTransientRefreshError(error) {
+  const status = error?.status;
+  if (typeof status === "number")
+    return status === 429 || status >= 500;
+  if (!(error instanceof Error))
+    return !1;
+  return error.name === "AbortError" || error.name === "TimeoutError" || error.message.includes("fetch failed") || "code" in error && (error.code === "ECONNRESET" || error.code === "ECONNREFUSED" || error.code === "ETIMEDOUT" || error.code === "UND_ERR_CONNECT_TIMEOUT");
+}
+export function isTransientQuotaError(error) {
+  const message = formatErrorMessage(error), status = error?.status;
+  if (typeof status === "number")
+    return status === 429 || status >= 500;
+  if (!(error instanceof Error))
+    return !1;
+  const code = error.code;
+  return error.name === "AbortError" || error.name === "TimeoutError" || message.includes("fetch failed") || code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT";
+}
+export function hashRefreshToken(refreshToken) {
+  return createHash("sha256").update(refreshToken).digest("hex");
+}
+export function buildRefreshOperationError(input) {
+  const tokenHash = hashRefreshToken(input.refreshToken), retryCount = (input.previous?.tokenHash === tokenHash ? input.previous.retryCount ?? 0 : 0) + 1;
+  let delay;
+  const retryAfter = input.error?.retryAfter;
+  if (typeof retryAfter === "number" && retryAfter > 0)
+    delay = retryAfter * 1000;
+  else if (isTransientRefreshError(input.error))
+    delay = Math.min(MAX_REFRESH_RETRY_DELAY_MS, MIN_REFRESH_RETRY_DELAY_MS * 2 ** Math.min(retryCount - 1, 6));
+  else
+    delay = NON_TRANSIENT_REFRESH_RETRY_DELAY_MS;
+  return {
+    message: formatErrorMessage(input.error),
+    checkedAt: input.now,
+    nextRetryAt: input.now + delay,
+    retryCount,
+    tokenHash
+  };
+}
+export function refreshBackoffActive(error, refreshToken, now) {
+  if (!error?.nextRetryAt || error.nextRetryAt <= now)
+    return !1;
+  if (!refreshToken)
+    return !0;
+  return error.tokenHash === hashRefreshToken(refreshToken);
+}
+export function formatRefreshBackoffMessage(error, now) {
+  return `Codex OAuth refresh is backed off for ${Math.max(1, Math.ceil(((error.nextRetryAt ?? now) - now) / 1000))}s after: ${error.message}`;
+}
+export function buildQuotaOperationError(input) {
+  const retryCount = (input.previous?.retryCount ?? 0) + 1;
+  let delay;
+  const retryAfter = input.error?.retryAfter;
+  if (typeof retryAfter === "number" && retryAfter > 0)
+    delay = retryAfter * 1000;
+  else if (isTransientQuotaError(input.error))
+    delay = Math.min(MAX_QUOTA_RETRY_DELAY_MS, MIN_QUOTA_RETRY_DELAY_MS * 2 ** Math.min(retryCount - 1, 6));
+  else
+    delay = NON_TRANSIENT_QUOTA_RETRY_DELAY_MS;
+  return {
+    message: formatErrorMessage(input.error),
+    checkedAt: input.now,
+    nextRetryAt: input.now + delay,
+    retryCount
+  };
+}
+export function quotaBackoffActive(error, now) {
+  if (!error?.nextRetryAt || error.nextRetryAt <= now)
+    return !1;
+  return !0;
+}
+export function formatQuotaBackoffMessage(error, now) {
+  return `Quota API backed off for ${Math.max(1, Math.ceil(((error.nextRetryAt ?? now) - now) / 1000))}s after: ${error.message}`;
+}
+export function parseRetryAfter(value) {
+  if (!value)
+    return;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds > 0)
+    return Math.ceil(seconds);
+  const date = Date.parse(value);
+  if (Number.isFinite(date)) {
+    const delta = Math.ceil((date - Date.now()) / 1000);
+    return delta > 0 ? delta : void 0;
+  }
+  return;
+}

package/src/tui-compiled/raw/shared/169b2b4bf30909bc-consumer.js

@@ -0,0 +1,430 @@
+import { createLogger } from "./cc9e0702a752cea7-index.js";
+import { combineAbortSignals } from "./6371b24a0573d79e-any-signal.js";
+import { ClaustrumScopedCustody, decideScopedRetryAfter401, } from "./0f77ebc3c914c9c6-custody.js";
+import { readClaustrumEnrollmentToken } from "./b9588ad4725c1d10-enrollment.js";
+import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
+import { acquireInsulaQuotaSource } from "./d0f0b6be200311af-insula.js";
+import { acceptVaultRoute, declineVaultRoute, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
+/**
+ * One plugin host's view of its vault accounts. It turns vault credentials
+ * into rows for `/routing`, authorizes each physical send with the vault, and
+ * reports a 401 against the exact record version that send used. Metadata
+ * (the connection and discovery) is shared and coalesced; credential reads
+ * never are. It never enrolls: a missing token is an error here, and setup
+ * is where enrollment happens.
+ */
+export class ClaustrumConsumer {
+    #options;
+    #shutdown = new AbortController();
+    #logger;
+    #custody;
+    #connecting;
+    #refreshing;
+    #roster;
+    /**
+     * The grants named by this instance's latest discovery, with the view that
+     * discovery committed. Memory only: the roster file never carries it.
+     */
+    #grantReach;
+    #timer;
+    #started = false;
+    #insula;
+    constructor(options) {
+        this.#options = options;
+        this.#logger = options.logger ?? createLogger('claustrum');
+    }
+    #assertOpen(signal) {
+        this.#shutdown.signal.throwIfAborted();
+        signal?.throwIfAborted();
+    }
+    async #active() {
+        return (await this.#options.isCustodyActive?.()) ?? true;
+    }
+    #wait(pending, signal) {
+        const combined = combineAbortSignals([
+            this.#shutdown.signal,
+            ...(signal ? [signal] : []),
+        ]);
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                combined.signal.removeEventListener('abort', abort);
+                combined.dispose();
+            };
+            const abort = () => {
+                cleanup();
+                reject(combined.signal.reason);
+            };
+            combined.signal.addEventListener('abort', abort, { once: true });
+            // Observe the operation even after cancellation: shared metadata work may
+            // finish for other callers, and a late connection must still be closed.
+            pending.then((value) => {
+                cleanup();
+                if (combined.signal.aborted)
+                    reject(combined.signal.reason);
+                else
+                    resolve(value);
+            }, (error) => {
+                cleanup();
+                reject(error);
+            });
+            if (combined.signal.aborted)
+                abort();
+        });
+    }
+    async #getCustody() {
+        this.#assertOpen();
+        if (this.#custody)
+            return this.#custody;
+        if (!this.#connecting) {
+            this.#connecting = this.#options
+                .connect()
+                .then((client) => {
+                if (this.#shutdown.signal.aborted) {
+                    client.close();
+                    this.#assertOpen();
+                }
+                this.#custody = new ClaustrumScopedCustody({
+                    client,
+                    family: this.#options.family,
+                    tokenPath: this.#options.tokenPath,
+                    parseIdentity: this.#options.parseIdentity,
+                    requireAssertion: this.#options.requireAssertion,
+                    now: this.#options.now,
+                    logger: this.#logger,
+                });
+                if (this.#options.insula && client.insula) {
+                    this.#insula = acquireInsulaQuotaSource(client.insula, this.#options.tokenPath);
+                }
+                return this.#custody;
+            })
+                .finally(() => {
+                this.#connecting = undefined;
+            });
+        }
+        return this.#wait(this.#connecting);
+    }
+    /** The last committed roster this instance saw, without any I/O. */
+    snapshot() {
+        return this.#roster;
+    }
+    /**
+     * What this consumer is granted, from its latest discovery, without any I/O.
+     * It explains an empty roster: `grants === 0` means no grant at all, while
+     * `grants > 0` means a grant that reaches no credential (`tuples` names its
+     * selector). Undefined means unknown, never zero: the vault or client is too
+     * old to send it, nothing was discovered yet, or the roster now in memory is
+     * a different view than the one this instance discovered (a peer process
+     * held the discovery lease and its newer roster was served instead).
+     */
+    grantReach() {
+        const latest = this.#grantReach;
+        return latest && this.#roster?.view === latest.view
+            ? latest.reach
+            : undefined;
+    }
+    /** Rows for `/routing`, from the last committed roster. */
+    routingRows() {
+        return vaultRoutingRows(this.#roster);
+    }
+    refresh() {
+        this.#assertOpen();
+        if (this.#refreshing)
+            return this.#refreshing;
+        this.#refreshing = (async () => {
+            if (!(await this.#active())) {
+                this.#roster = undefined;
+                this.#grantReach = undefined;
+                this.#custody?.close();
+                this.#custody = undefined;
+                this.#insula?.release();
+                this.#insula = undefined;
+                return undefined;
+            }
+            const custody = await this.#getCustody();
+            // Capture the inventory so its grant fields can be kept beside the roster;
+            // the roster file itself never stores them.
+            let discovered;
+            const roster = await refreshVaultRoster({
+                path: this.#options.rosterPath,
+                custody: {
+                    discover: async (signal) => {
+                        discovered = await custody.discover(signal);
+                        return discovered;
+                    },
+                },
+                isActive: () => this.#active(),
+                signal: this.#shutdown.signal,
+                projection: () => ({
+                    reservedRouteIds: new Set(this.#options.reservedRouteIds?.() ?? []),
+                    routePrefix: this.#options.routePrefix,
+                    mapAccount: this.#options.mapAccount,
+                    now: (this.#options.now ?? Date.now)(),
+                }),
+            });
+            this.#assertOpen();
+            const changed = roster?.view !== this.#roster?.view;
+            this.#roster = roster;
+            // Each discovery replaces the previous value, including with unknown. A
+            // refresh that served a peer's roster discovered nothing and leaves it;
+            // grantReach() hides it once the roster's view no longer matches.
+            if (discovered && roster?.view !== undefined)
+                this.#grantReach = discovered.grantReach
+                    ? { view: roster.view, reach: discovered.grantReach }
+                    : undefined;
+            // Notify on view changes only: subscribers rewrite shared state on each
+            // notification, and the poll runs every few seconds.
+            if (roster && changed)
+                this.#options.onRoster?.(roster);
+            return roster;
+        })().finally(() => {
+            this.#refreshing = undefined;
+        });
+        return this.#refreshing;
+    }
+    start() {
+        if (this.#started)
+            return;
+        this.#assertOpen();
+        this.#started = true;
+        const tick = async () => {
+            try {
+                await this.refresh();
+                await this.refreshInsulaQuota();
+            }
+            catch (error) {
+                if (!this.#shutdown.signal.aborted)
+                    this.#options.onError?.(error);
+            }
+            if (this.#shutdown.signal.aborted)
+                return;
+            const delay = this.#options.pollIntervalMs ?? 5_000;
+            if (delay <= 0)
+                return;
+            this.#timer = (this.#options.setTimeoutImpl ?? setTimeout)(() => {
+                this.#timer = undefined;
+                void tick();
+            }, delay);
+            this.#timer.unref?.();
+        };
+        void tick();
+    }
+    /**
+     * Fetch on a background tick, at most once per minute across projects with
+     * the same daemon and enrollment token path. Admission must use the cache
+     * instead, so an optional quota daemon never delays a provider request.
+     */
+    async refreshInsulaQuota() {
+        if (!this.#options.insula ||
+            this.#shutdown.signal.aborted ||
+            !(await this.#active()))
+            return;
+        try {
+            await readClaustrumEnrollmentToken(this.#options.tokenPath);
+            await this.#getCustody();
+            await this.#insula?.source.refresh((this.#options.now ?? Date.now)());
+        }
+        catch {
+            // An optional source must never prevent the plugin's own quota poll.
+        }
+    }
+    /**
+     * Cache-only, for unknown-quota admission with a served receipt. Undefined
+     * means poll the provider normally. Only get_scoped's asserted account_id
+     * joins insula; parsed identities and display metadata cannot substitute.
+     * Background polling should use cachedInsulaQuotaForRoute instead.
+     */
+    async cachedInsulaQuota(receipt) {
+        if (!this.#options.insula ||
+            this.#shutdown.signal.aborted ||
+            !(await this.#active()))
+            return undefined;
+        try {
+            await readClaustrumEnrollmentToken(this.#options.tokenPath);
+            return this.#normalizeInsulaQuota(receipt.assertedAccountIdentity);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Background cache lookup without fetching a credential. Re-read the roster
+     * so a peer's account replacement invalidates the old route immediately.
+     * A route without a known provider account cannot join an insula entry.
+     */
+    async cachedInsulaQuotaForRoute(routeId) {
+        if (!this.#options.insula ||
+            this.#shutdown.signal.aborted ||
+            !(await this.#active()))
+            return undefined;
+        try {
+            await readClaustrumEnrollmentToken(this.#options.tokenPath);
+            const roster = await readVaultRoster(this.#options.rosterPath);
+            const row = roster?.rows.find((entry) => entry.routeId === routeId);
+            return this.#normalizeInsulaQuota(row?.accountIdentity);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    #normalizeInsulaQuota(accountIdentity) {
+        if (!this.#options.insula || !accountIdentity)
+            return undefined;
+        const current = this.#insula?.source.current(this.#options.insula.provider, accountIdentity, (this.#options.now ?? Date.now)());
+        return current
+            ? this.#options.insula.normalize(current.entry, current.context)
+            : undefined;
+    }
+    /**
+     * Authorize one physical send on a vault route. The roster file is re-read
+     * first, so a decline committed by another process applies before the next
+     * poll, and a route whose credential or account changed is refused.
+     */
+    async authorize(routeId, signal) {
+        this.#assertOpen(signal);
+        const roster = this.#roster ?? (await this.#wait(this.refresh(), signal));
+        if (!roster || !(await this.#active()))
+            throw new ClaustrumConsumerError('not-active', 'Claustrum scoped custody is not active');
+        const current = await readVaultRoster(this.#options.rosterPath);
+        this.#assertOpen(signal);
+        const observed = roster.rows.find((row) => row.routeId === routeId);
+        const configured = current?.rows.find((row) => row.routeId === routeId);
+        if (configured && !configured.enabled)
+            throw new ClaustrumConsumerError('route-declined', 'Claustrum route is disabled');
+        if (!observed ||
+            !configured ||
+            configured.state !== 'active' ||
+            configured.credentialId !== observed.credentialId ||
+            configured.accountIdentity !== observed.accountIdentity)
+            throw new ClaustrumConsumerError('route-unavailable', 'Claustrum route is disabled, removed or changed');
+        const custody = await this.#wait(this.#getCustody(), signal);
+        const combined = combineAbortSignals([
+            this.#shutdown.signal,
+            ...(signal ? [signal] : []),
+        ]);
+        try {
+            return await custody.authorize({
+                credentialId: configured.credentialId,
+                credentialType: configured.credentialType,
+                ...(configured.accountIdentity !== undefined && {
+                    accountIdentity: configured.accountIdentity,
+                }),
+            }, combined.signal);
+        }
+        finally {
+            combined.dispose();
+        }
+    }
+    async reportFailure(attempt, status, source) {
+        this.#assertOpen();
+        if (!this.#custody)
+            throw new ClaustrumConsumerError('no-receipt', 'Claustrum dispatch receipt has no active owner');
+        await this.#custody.reportFailure(attempt, status, source);
+    }
+    /**
+     * Send on a vault route. `dispatch` builds and sends the request with the
+     * receipt's token and may be called twice, so it must be able to rebuild
+     * its body. A 401 is retried once, and only when the vault now serves a new
+     * record version of the same credential and account; the final 401 is
+     * reported against the version that send actually used. Each call to
+     * `dispatch` gets its own receipt.
+     */
+    async send(routeId, dispatch, options) {
+        const signal = options.signal;
+        let served = await this.authorize(routeId, signal);
+        let response = await dispatch(served, signal);
+        if (response.status === 401 && !signal?.aborted) {
+            let current;
+            try {
+                current = await this.authorize(routeId, signal);
+            }
+            catch {
+                // Re-authorization failed: keep this 401 and report it against the
+                // receipt (served record version) this request was sent with.
+            }
+            if (decideScopedRetryAfter401(options.site, served, current, this.#logger)) {
+                await response.body?.cancel().catch(() => { });
+                served = current;
+                response = await dispatch(current, signal);
+            }
+        }
+        if (response.status === 401) {
+            await this.reportFailure(served, 401, options.reporterSource ?? 'direct').catch((error) => this.#options.onError?.(error));
+            // After the report the vault may mark the account as needing a new
+            // login; refresh now so routing drops it without waiting for the next poll. Deferred so a consumer closed in
+            // the meantime reports to onError instead of throwing from this send.
+            Promise.resolve()
+                .then(() => this.refresh())
+                .catch((error) => {
+                if (!this.#shutdown.signal.aborted)
+                    this.#options.onError?.(error);
+            });
+        }
+        return response;
+    }
+    /** Decline a vault account: it stays listed and never routes until accepted. */
+    async decline(routeId) {
+        this.#assertOpen();
+        await declineVaultRoute(this.#options.rosterPath, routeId);
+        this.#roster = await readVaultRoster(this.#options.rosterPath);
+    }
+    async accept(routeId) {
+        this.#assertOpen();
+        await acceptVaultRoute(this.#options.rosterPath, routeId);
+        this.#roster = await readVaultRoster(this.#options.rosterPath);
+    }
+    /**
+     * Store a quota or profile observation for a vault route. The receipt the
+     * reading was taken with is required: the observation lands only while the
+     * route still holds the credential and account that receipt was served for
+     * (see `recordVaultQuota`), so a reading for a replaced account is dropped.
+     */
+    async recordQuota(routeId, observation, attempt) {
+        this.#assertOpen();
+        const kept = await recordVaultQuota(this.#options.rosterPath, {
+            routeId,
+            observation,
+            credentialId: attempt.credentialId,
+            accountIdentitySource: attempt.accountIdentitySource,
+            ...(attempt.accountIdentity !== undefined && {
+                accountIdentity: attempt.accountIdentity,
+            }),
+            ...(attempt.expectedAccountIdentity !== undefined && {
+                expectedAccountIdentity: attempt.expectedAccountIdentity,
+            }),
+        });
+        if (kept)
+            this.#roster = await readVaultRoster(this.#options.rosterPath);
+        return kept;
+    }
+    /**
+     * Store a background observation that belongs to an account rather than to
+     * a served credential (an insula reading from `cachedInsulaQuotaForRoute`).
+     * It lands only while the route is still bound to that known account, so no
+     * credential fetch is needed and a replaced account's reading is dropped.
+     * The in-memory roster is reloaded from the file, without a vault call.
+     */
+    async recordAccountQuota(routeId, accountIdentity, observation) {
+        this.#assertOpen();
+        const kept = await recordVaultAccountQuota(this.#options.rosterPath, {
+            routeId,
+            accountIdentity,
+            observation,
+        });
+        if (kept)
+            this.#roster = await readVaultRoster(this.#options.rosterPath);
+        return kept;
+    }
+    close() {
+        if (this.#shutdown.signal.aborted)
+            return;
+        this.#shutdown.abort(new ClaustrumConsumerError('closed', 'Claustrum consumer is closed'));
+        if (this.#timer)
+            (this.#options.clearTimeoutImpl ?? clearTimeout)(this.#timer);
+        this.#timer = undefined;
+        this.#custody?.close();
+        this.#insula?.release();
+        this.#insula = undefined;
+        this.#roster = undefined;
+        this.#grantReach = undefined;
+    }
+}

package/src/tui-compiled/raw/shared/2577ec69f9973ae9-quota-normalize.js

@@ -0,0 +1,154 @@
+export function toResetIso(raw) {
+  if (raw == null || raw === "")
+    return;
+  const n = typeof raw === "number" ? raw : Number(raw);
+  if (Number.isFinite(n)) {
+    const ms = n < 100000000000 ? n * 1000 : n, d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+  }
+  const d = new Date(raw);
+  return Number.isNaN(d.getTime()) ? void 0 : d.toISOString();
+}
+function positiveFinite(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function nonNegativeFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function windowFromHeader(h, prefix) {
+  const used = h.get(prefix);
+  if (used === null || used.trim() === "")
+    return;
+  const usedPercent = Number(used);
+  if (!Number.isFinite(usedPercent) || usedPercent < 0 || usedPercent > 100)
+    return;
+  const base = prefix.slice(0, -13), windowMinutes = positiveFinite(h.get(`${base}-window-minutes`)), resetsAt = toResetIso(h.get(`${base}-reset-at`) ?? void 0);
+  if (usedPercent === 0 && h.get(`${base}-window-minutes`) === "0" && !resetsAt)
+    return;
+  return {
+    usedPercent,
+    remainingPercent: 100 - usedPercent,
+    resetsAt,
+    checkedAt: Date.now(),
+    ...windowMinutes !== void 0 ? { windowMinutes } : {}
+  };
+}
+const QUOTA_USED_PERCENT_HEADERS = [
+  "x-codex-primary-used-percent",
+  "x-codex-secondary-used-percent"
+];
+function usedPercentHeaderState(h, name) {
+  const raw = h.get(name);
+  if (raw === null)
+    return "absent";
+  if (raw.trim() === "")
+    return "invalid";
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 && value <= 100 ? "valid" : "invalid";
+}
+export function normalizeQuotaHeaders(h) {
+  if (QUOTA_USED_PERCENT_HEADERS.some((name) => usedPercentHeaderState(h, name) === "invalid"))
+    return {};
+  const snapshot = {}, primary = windowFromHeader(h, "x-codex-primary-used-percent");
+  if (primary)
+    snapshot.primary = primary;
+  const secondary = windowFromHeader(h, "x-codex-secondary-used-percent");
+  if (secondary)
+    snapshot.secondary = secondary;
+  return snapshot;
+}
+export function isCompleteQuotaHeaderFrame(h) {
+  const states = QUOTA_USED_PERCENT_HEADERS.map((name) => usedPercentHeaderState(h, name));
+  return states.includes("valid") && !states.includes("invalid");
+}
+function windowFromWs(w) {
+  if (!w)
+    return;
+  if (!Number.isFinite(w.used_percent) || w.used_percent < 0 || w.used_percent > 100)
+    return;
+  const windowMinutes = positiveFinite(w.window_minutes), resetsAt = toResetIso(w.reset_at);
+  if (w.used_percent === 0 && windowMinutes === void 0 && !resetsAt)
+    return;
+  return {
+    usedPercent: w.used_percent,
+    remainingPercent: 100 - w.used_percent,
+    resetsAt,
+    checkedAt: Date.now(),
+    ...windowMinutes !== void 0 ? { windowMinutes } : {}
+  };
+}
+export function normalizeWsFrame(event) {
+  const snapshot = {}, primary = windowFromWs(event.rate_limits?.primary);
+  if (primary)
+    snapshot.primary = primary;
+  const secondary = windowFromWs(event.rate_limits?.secondary);
+  if (secondary)
+    snapshot.secondary = secondary;
+  return snapshot;
+}
+function nonNegativeNumberish(value) {
+  if (value == null || value === "")
+    return;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function windowFromWham(w) {
+  if (!w)
+    return;
+  if (!Number.isFinite(w.used_percent) || w.used_percent < 0 || w.used_percent > 100)
+    return;
+  const windowSeconds = positiveFinite(w.limit_window_seconds), resetsAt = toResetIso(w.reset_at);
+  if (w.used_percent === 0 && windowSeconds === void 0 && !resetsAt)
+    return;
+  return {
+    usedPercent: w.used_percent,
+    remainingPercent: 100 - w.used_percent,
+    resetsAt,
+    checkedAt: Date.now(),
+    ...windowSeconds !== void 0 ? { windowMinutes: windowSeconds / 60 } : {}
+  };
+}
+export function normalizeWham(json) {
+  const snapshot = {}, primary = windowFromWham(json.rate_limit?.primary_window);
+  if (primary)
+    snapshot.primary = primary;
+  const secondary = windowFromWham(json.rate_limit?.secondary_window);
+  if (secondary)
+    snapshot.secondary = secondary;
+  const resetCreditsAvailable = nonNegativeFinite(json.rate_limit_reset_credits?.available_count);
+  if (resetCreditsAvailable !== void 0)
+    snapshot.resetCreditsAvailable = resetCreditsAvailable;
+  const resetCreditsApplicable = nonNegativeFinite(json.rate_limit_reset_credits?.applicable_available_count);
+  if (resetCreditsApplicable !== void 0)
+    snapshot.resetCreditsApplicable = resetCreditsApplicable;
+  const individualLimit = json.spend_control?.individual_limit;
+  if (json.spend_control === null || individualLimit === null)
+    snapshot.spendControlCleared = !0;
+  if (individualLimit && typeof json.spend_control?.reached === "boolean") {
+    const limit = nonNegativeNumberish(individualLimit.limit), used = nonNegativeNumberish(individualLimit.used), remaining = nonNegativeNumberish(individualLimit.remaining), usedPercent = nonNegativeNumberish(individualLimit.used_percent), remainingPercent = nonNegativeNumberish(individualLimit.remaining_percent);
+    if (limit !== void 0 && used !== void 0 && remaining !== void 0 && usedPercent !== void 0 && remainingPercent !== void 0)
+      snapshot.spendControl = {
+        limit,
+        used,
+        remaining,
+        usedPercent,
+        remainingPercent,
+        resetsAt: toResetIso(individualLimit.reset_at),
+        unit: individualLimit.unit,
+        source: individualLimit.source,
+        reached: json.spend_control.reached
+      };
+  }
+  const credits = json.credits;
+  if (credits && typeof credits.has_credits === "boolean" && typeof credits.unlimited === "boolean" && typeof credits.overage_limit_reached === "boolean") {
+    const balance = nonNegativeNumberish(credits.balance);
+    snapshot.credits = {
+      hasCredits: credits.has_credits,
+      unlimited: credits.unlimited,
+      overageLimitReached: credits.overage_limit_reached,
+      ...balance !== void 0 ? { balance } : {}
+    };
+  }
+  return snapshot;
+}