@cortexkit/opencode-antigravity-auth 3.0.5 → 3.0.6

package/dist/src/common-auth-embedded/claustrum/insula.d.ts

@@ -0,0 +1,69 @@
+import type { ClaustrumClientOptions } from '@cortexkit/claustrum-client';
+/** Insula's window fields are open: plugins choose which limits they understand. */
+export interface InsulaUsageWindow {
+    usedPercent: number;
+    rawUsedPercent?: number;
+    resetsAt?: string;
+    windowMinutes?: number;
+    windowKind?: string;
+    [field: string]: unknown;
+}
+export interface InsulaUsageEntry {
+    provider: string;
+    account?: string;
+    fetchedAt?: string;
+    source?: string;
+    stale?: unknown;
+    errorClass?: unknown;
+    usage?: {
+        primary?: InsulaUsageWindow;
+        secondary?: InsulaUsageWindow;
+        tertiary?: InsulaUsageWindow;
+        extraRateWindows?: Array<{
+            id?: string;
+            title?: string;
+            window?: InsulaUsageWindow;
+        }>;
+        [field: string]: unknown;
+    };
+    [field: string]: unknown;
+}
+export interface InsulaQuotaContext {
+    /** Milliseconds since the epoch, parsed from the producer's fetchedAt. */
+    fetchedAt: number;
+    source?: string;
+}
+export interface InsulaQuotaOptions<Q> {
+    provider: 'codex' | 'claude' | 'antigravity';
+    /**
+     * Set every converted window's reading time to context.fetchedAt, not poll
+     * time. Return undefined for entries the plugin cannot use. Antigravity can
+     * receive its own sidebar reading back from insula: accept it only from the
+     * vault or when fetchedAt is newer than the plugin's last reading.
+     */
+    normalize: (entry: InsulaUsageEntry, context: InsulaQuotaContext) => Q | undefined;
+}
+/** Optional transport for custom scoped clients; getUsage must not retry refusals. */
+export interface InsulaUsageTransport {
+    connectionFile: string;
+    getUsage(): Promise<unknown>;
+}
+/** Constructing this transport opens no connection; getUsage opens one per call. */
+export declare function insulaUsageTransport(options: ClaustrumClientOptions & {
+    connectionFile: string;
+}): InsulaUsageTransport;
+export declare class InsulaQuotaSource {
+    #private;
+    private readonly transport;
+    private readonly key;
+    constructor(transport: InsulaUsageTransport, key: string);
+    refresh(now: number): Promise<void>;
+    current(provider: string, accountId: string, now: number): {
+        entry: InsulaUsageEntry;
+        context: InsulaQuotaContext;
+    } | undefined;
+}
+export declare function acquireInsulaQuotaSource(transport: InsulaUsageTransport, tokenPath: string): {
+    source: InsulaQuotaSource;
+    release(): void;
+};

package/dist/src/common-auth-embedded/claustrum/insula.js

@@ -0,0 +1,152 @@
+import { resolve } from 'node:path';
+import { storeIdentity } from '@cortexkit/claustrum-client';
+// A static import: claustrum-client already loads subc-client whenever
+// /claustrum is imported, so loading it lazily saves nothing, and a dynamic
+// 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';
+/** Constructing this transport opens no connection; getUsage opens one per call. */
+export function insulaUsageTransport(options) {
+    const identity = options.identity ??
+        storeIdentity(options.projectRoot ?? process.cwd(), options.storagePath ?? process.cwd());
+    return {
+        connectionFile: options.connectionFile,
+        async getUsage() {
+            let client;
+            let expired = false;
+            let timer;
+            const timeout = new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('insula usage timeout')), 3_000);
+                timer.unref?.();
+            });
+            const request = (async () => {
+                client = options.connector
+                    ? await options.connector({
+                        connectionFile: options.connectionFile,
+                        handshakeTimeoutMs: Math.min(options.handshakeTimeoutMs ?? 3_000, 3_000),
+                    })
+                    : await SubcClient.connect({
+                        connectionFile: options.connectionFile,
+                        handshakeTimeoutMs: Math.min(options.handshakeTimeoutMs ?? 3_000, 3_000),
+                    });
+                // A slow connector may resolve after the whole-call deadline. It still
+                // owns a socket, which must not survive or open a route after fallback.
+                if (expired) {
+                    client.close();
+                    throw new Error('insula usage timeout');
+                }
+                // Managed call() retries warming routes. A single routeOpen/request
+                // instead lets the plugin fall back as soon as the daemon refuses.
+                const route = await client.routeOpen({ kind: 'management_surface', module_id: 'insula' }, identity);
+                return await client.request(route, { method: 'usage.get', params: {} });
+            })();
+            try {
+                return await Promise.race([request, timeout]);
+            }
+            finally {
+                expired = true;
+                clearTimeout(timer);
+                client?.close();
+            }
+        },
+    };
+}
+const MINUTE = 60_000;
+const MAX_AGE = 4 * 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.
+const attempts = new Map();
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export class InsulaQuotaSource {
+    transport;
+    key;
+    #entries = [];
+    #pending;
+    constructor(transport, key) {
+        this.transport = transport;
+        this.key = key;
+    }
+    refresh(now) {
+        if (this.#pending)
+            return this.#pending;
+        for (const [key, time] of attempts) {
+            if (now - time >= MINUTE)
+                attempts.delete(key);
+        }
+        const lastAttempt = attempts.get(this.key);
+        if (lastAttempt !== undefined && now - lastAttempt < MINUTE)
+            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 = [];
+            }
+        })().finally(() => {
+            this.#pending = undefined;
+        });
+        return this.#pending;
+    }
+    current(provider, accountId, now) {
+        for (const entry of this.#entries) {
+            if (entry.provider !== provider ||
+                typeof entry.account !== 'string' ||
+                entry.account.trim() !== accountId)
+                continue;
+            if (entry.stale !== undefined ||
+                entry.errorClass !== undefined ||
+                !record(entry.usage))
+                continue;
+            const fetchedAt = typeof entry.fetchedAt === 'string'
+                ? Date.parse(entry.fetchedAt)
+                : Number.NaN;
+            if (!Number.isFinite(fetchedAt) || now - fetchedAt >= MAX_AGE)
+                continue;
+            return {
+                entry,
+                context: {
+                    fetchedAt,
+                    ...(typeof entry.source === 'string' && { source: entry.source }),
+                },
+            };
+        }
+        return undefined;
+    }
+}
+export function acquireInsulaQuotaSource(transport, tokenPath) {
+    const key = JSON.stringify([
+        resolve(transport.connectionFile),
+        resolve(tokenPath),
+    ]);
+    let shared = sources.get(key);
+    if (!shared) {
+        shared = { source: new InsulaQuotaSource(transport, key), refs: 0 };
+        sources.set(key, shared);
+    }
+    shared.refs++;
+    let released = false;
+    return {
+        source: shared.source,
+        release() {
+            if (released)
+                return;
+            released = true;
+            if (--shared.refs === 0)
+                sources.delete(key);
+        },
+    };
+}

package/dist/src/common-auth-embedded/claustrum/roster.d.ts

@@ -133,6 +133,19 @@ export declare function recordVaultQuota(path: string, input: QuotaReceipt & {
     routeId: string;
     observation: QuotaObservation;
 }): Promise<boolean>;
+/**
+ * Merge a quota observation that belongs to an account rather than to a
+ * served credential, such as a background reading from insula. The write
+ * lands only while the row is still bound to that exact known account, so a
+ * reading taken before a replacement never reaches the successor. Unlike
+ * `recordVaultQuota` it never binds an account: a row without a known account
+ * is refused. Returns whether the observation was kept.
+ */
+export declare function recordVaultAccountQuota(path: string, input: {
+    routeId: string;
+    accountIdentity: string;
+    observation: QuotaObservation;
+}): Promise<boolean>;
 /**
  * Discover and commit the roster. The lease covers the list call and the
  * commit, not just the write: an opaque view cannot tell a delayed old reply

package/dist/src/common-auth-embedded/claustrum/roster.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { acquireRefreshFileLock, withLock, writeJsonAtomic, } from '../fs/index.js';
 import { readPrivateText, windowsPrivateFiles } from '../fs/private-files.js';
-import { isQuotaMap, mergeQuotaObservation, } from '../quota/index.js';
+import { decodeQuotaMap, mergeQuotaObservation, } from '../quota/index.js';
 import { ClaustrumConsumerError } from './errors.js';
 import { acceptAccount, declineAccount, isDeclined, } from './interlock.js';
 export const DEFAULT_ROUTE_PREFIX = 'vault:';
@@ -210,6 +210,7 @@ function optionalString(value) {
     return value === undefined || typeof value === 'string';
 }
 function decodeRow(value) {
+    const quota = isRecord(value) ? decodeQuotaMap(value.quota) : undefined;
     if (!isRecord(value) ||
         typeof value.routeId !== 'string' ||
         typeof value.credentialId !== 'string' ||
@@ -224,11 +225,14 @@ function decodeRow(value) {
         (value.aliases !== undefined &&
             (!Array.isArray(value.aliases) ||
                 !value.aliases.every((alias) => typeof alias === 'string'))) ||
-        (value.quota !== undefined && !isQuotaMap(value.quota)) ||
+        (value.quota !== undefined && quota === undefined) ||
         (value.stale !== undefined && value.stale !== true) ||
         (value.unclaimed !== undefined && value.unclaimed !== true))
         return undefined;
-    return value;
+    return {
+        ...value,
+        ...(quota === undefined ? {} : { quota }),
+    };
 }
 const SKIPPED_REASONS = new Set([
     'empty credential id',
@@ -435,6 +439,32 @@ export function recordVaultQuota(path, input) {
         };
     });
 }
+/**
+ * Merge a quota observation that belongs to an account rather than to a
+ * served credential, such as a background reading from insula. The write
+ * lands only while the row is still bound to that exact known account, so a
+ * reading taken before a replacement never reaches the successor. Unlike
+ * `recordVaultQuota` it never binds an account: a row without a known account
+ * is refused. Returns whether the observation was kept.
+ */
+export function recordVaultAccountQuota(path, input) {
+    return mutateVaultRoster(path, (current) => {
+        const row = current?.rows.find((entry) => entry.routeId === input.routeId);
+        if (!current ||
+            !row ||
+            row.accountIdentity === undefined ||
+            row.accountIdentity !== input.accountIdentity)
+            return { result: false };
+        const quota = mergeQuotaObservation(row.quota, input.observation);
+        return {
+            next: {
+                ...current,
+                rows: current.rows.map((entry) => entry === row ? { ...entry, quota } : entry),
+            },
+            result: true,
+        };
+    });
+}
 /**
  * Discover and commit the roster. The lease covers the list call and the
  * commit, not just the write: an opaque view cannot tell a delayed old reply

package/dist/src/common-auth-embedded/fs/refresh-file-lock.js

@@ -1,8 +1,25 @@
 import { randomUUID } from 'node:crypto';
-import { mkdir, open, readFile, rename, rm, stat, writeFile, } from 'node:fs/promises';
+import { mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { createPrivateBytes, createPrivateDirectoryExclusive, ensurePrivateDirectory, PrivateFileError, privateOperation, readPrivateText, verifyPrivate, windowsPrivateFiles, writePrivateAtomic, } from './private-files.js';
 import { LockOwnershipError, lockPathFor } from './with-lock.js';
+/**
+ * Create a new owner-only file and write `text` into it, failing with EEXIST if
+ * the file already exists. Writing through the handle rather than path-based
+ * `writeFile(path, …, { flag: 'wx' })` matters: Bun's path form also truncates
+ * the file it has just created, and on some Linux filesystems (XFS under load)
+ * that redundant ftruncate stalls for hundreds of milliseconds, inside every
+ * lock acquisition.
+ */
+async function createExclusiveText(path, text) {
+    const handle = await open(path, 'wx', 0o600);
+    try {
+        await handle.writeFile(text, 'utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
 const setRefreshLockRenewalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearRefreshLockRenewalTimeout = globalThis.clearTimeout.bind(globalThis);
 // A concurrent contender renaming the freshly-created eviction-marker directory
@@ -152,11 +169,7 @@ export async function acquireRefreshFileLock(options) {
         if (windowsPrivateFiles)
             await createPrivateBytes(lockPath, bytes);
         else
-            await writeFile(lockPath, bytes, {
-                encoding: 'utf8',
-                mode: 0o600,
-                flag: 'wx',
-            });
+            await createExclusiveText(lockPath, bytes);
     }
     async function leaseContention(error) {
         const code = error.code;
@@ -304,11 +317,7 @@ export async function acquireRefreshFileLock(options) {
             if (windowsPrivateFiles)
                 await createPrivateBytes(evictOwnerPath, bytes);
             else
-                await writeFile(evictOwnerPath, bytes, {
-                    encoding: 'utf8',
-                    mode: 0o600,
-                    flag: 'wx',
-                });
+                await createExclusiveText(evictOwnerPath, bytes);
         }
         catch (error) {
             // A competing contender can rename our just-created marker directory

package/dist/src/common-auth-embedded/quota/codec.d.ts

@@ -1,5 +1,7 @@
 export interface QuotaCodec {
     readonly validate: (value: unknown) => boolean;
+    /** Normalize persisted data before validation; older codecs may omit this. */
+    readonly decode?: (value: unknown) => unknown;
     readonly merge: (stored: unknown, observation: unknown) => unknown;
 }
 /**

package/dist/src/common-auth-embedded/quota/codec.js

@@ -1,4 +1,4 @@
-import { isQuotaMap } from './map.js';
+import { decodeQuotaMap, isQuotaMap } from './map.js';
 import { mergeQuotaObservation } from './merge.js';
 /**
  * The quota codec the account-pool store (the `/store` subpath) takes when it
@@ -8,5 +8,6 @@ import { mergeQuotaObservation } from './merge.js';
  */
 export const quotaCodec = Object.freeze({
     validate: isQuotaMap,
+    decode: decodeQuotaMap,
     merge: mergeQuotaObservation,
 });

package/dist/src/common-auth-embedded/quota/format.d.ts

@@ -21,6 +21,26 @@ export interface QuotaTextOptions {
     /** Defaults to `QUOTA_STALE_AFTER_MS`. */
     staleAfterMs?: number;
 }
+export interface QuotaWindowPart {
+    kind: 'window' | 'budget';
+    /** The display name of a quota window, or `credits` for the budget. */
+    name: string;
+    /** The shared figure wording, including `credits` for budget figures. */
+    figure: string;
+    /** The unrounded remaining percentage, clamped to 0–100, when known. */
+    remainingPercent?: number;
+    /** A bare relative reset span such as `4d`, only when the reset is future. */
+    resetIn?: string;
+    checkedAt: number;
+    /** Whether the reset followed this reading and has arrived by `now`. */
+    resetSinceReading: boolean;
+}
+export interface QuotaParts {
+    /** Reported windows in display order, followed by the budget when present. */
+    windows: QuotaWindowPart[];
+    /** The shared checked-age wording, present only when the reading is stale. */
+    age?: string;
+}
 /**
  * The name a window is shown under. A general window (scope `all`) is named
  * by its stored length; a model-scoped window keeps the label the plugin
@@ -29,6 +49,12 @@ export interface QuotaTextOptions {
  * were recorded) falls back to its label.
  */
 export declare function quotaWindowName(limit: Pick<ProjectedLimit, 'scope' | 'label' | 'windowMinutes'>): string;
+/**
+ * Structured quota wording for layouts that need one row per window. The
+ * windows use the same filtering and order as `quotaTextParts`; future resets
+ * and the optional age keep the shared formatter's wording.
+ */
+export declare function quotaWindowParts(quota: ProjectedQuota | undefined, options: QuotaTextOptions): QuotaParts;
 /**
  * The pieces of a quota text, in order: one per reported window
  * (`5h 58% left, resets 2h`), then the credit budget when there is one, then

package/dist/src/common-auth-embedded/quota/format.js

@@ -1,7 +1,7 @@
 // The one quota wording every surface shows: the command menu's dialogs on
 // OpenCode and Pi, the terminal auth menu, and the plugins' sidebars. Each of
-// them calls `formatQuota` (or `quotaTextParts` for one line per window), so
-// the wording cannot drift between plugins or between a dialog and a sidebar.
+// them calls `formatQuota`, `quotaTextParts`, or `quotaWindowParts`, so the
+// wording cannot drift between plugins or between a dialog and a sidebar.
 //
 // The rules: a window is named by its length (`5h`, `7d`), or, for a window
 // that binds only one model family, by the label the plugin stored it under.
@@ -22,18 +22,23 @@ export const NO_QUOTA_READING = 'no quota reading yet';
  */
 export const NO_LIMITS_REPORTED = 'no limits reported';
 /**
- * A length or a time span in its largest whole-ish unit: `45m`, `5h`, `3d`.
- * Spans under an hour are minutes, under a day hours, otherwise days, each
- * rounded to the nearest unit and never shown as zero.
+ * A time span in at most its two largest units: `45m`, `2h29m`, `5h`, `3d23h`,
+ * `7d`. Every unit is rounded down, so a reset is never shown later than it is;
+ * the one exception is a span under a minute, which reads `1m` rather than
+ * zero. A zero second unit is left out.
  */
 function shortSpan(ms) {
-    const minutes = Math.max(1, Math.round(ms / 60_000));
+    const minutes = Math.max(1, Math.floor(ms / 60_000));
     if (minutes < 60)
         return `${minutes}m`;
-    const hours = Math.round(minutes / 60);
-    if (hours < 24)
-        return `${hours}h`;
-    return `${Math.max(1, Math.round(minutes / 1440))}d`;
+    if (minutes < 1440) {
+        const hours = Math.floor(minutes / 60);
+        const rest = minutes % 60;
+        return rest === 0 ? `${hours}h` : `${hours}h${rest}m`;
+    }
+    const days = Math.floor(minutes / 1440);
+    const hours = Math.floor((minutes % 1440) / 60);
+    return hours === 0 ? `${days}d` : `${days}d${hours}h`;
 }
 /** A stored window length in minutes as its exact name: `5h`, `7d`, `90m`. */
 function lengthName(minutes) {
@@ -55,17 +60,20 @@ export function quotaWindowName(limit) {
         return limit.label;
     return lengthName(limit.windowMinutes);
 }
+function clampPercent(remaining) {
+    return Math.min(100, Math.max(0, remaining));
+}
 function percentLeft(remaining) {
-    return `${Math.round(Math.min(100, Math.max(0, remaining)))}% left`;
+    return `${Math.round(clampPercent(remaining))}% left`;
 }
-function resetText(resetsAt, now) {
-    if (resetsAt === undefined)
-        return '';
-    const at = Date.parse(resetsAt);
-    // A reset already passed says nothing about the future; leave it out.
-    if (!Number.isFinite(at) || at <= now)
-        return '';
-    return `, resets ${shortSpan(at - now)}`;
+function resetDetails(resetsAt, checkedAt, now) {
+    const at = resetsAt === undefined ? Number.NaN : Date.parse(resetsAt);
+    return {
+        ...(Number.isFinite(at) && at > now
+            ? { resetIn: shortSpan(at - now) }
+            : {}),
+        resetSinceReading: Number.isFinite(at) && at > checkedAt && at <= now,
+    };
 }
 /** Shortest window first, so `5h` reads before `7d`; unknown lengths last. */
 function displayOrder(left, right) {
@@ -85,42 +93,70 @@ function displayOrder(left, right) {
     return left.label < right.label ? -1 : left.label > right.label ? 1 : 0;
 }
 /**
- * The pieces of a quota text, in order: one per reported window
- * (`5h 58% left, resets 2h`), then the credit budget when there is one, then
- * `checked 3h ago` when the oldest piece shown is stale. Empty when nothing
- * was reported; `formatQuota` turns that into a sentence. A caller printing
- * one line per window (the terminal auth menu) uses these directly.
+ * Structured quota wording for layouts that need one row per window. The
+ * windows use the same filtering and order as `quotaTextParts`; future resets
+ * and the optional age keep the shared formatter's wording.
  */
-export function quotaTextParts(quota, options) {
+export function quotaWindowParts(quota, options) {
     if (!quota)
-        return [];
+        return { windows: [] };
     const { now } = options;
-    const full = (options.form ?? 'full') === 'full';
-    const parts = [];
-    const times = [];
     const readings = quota.limits
         .filter((limit) => limit.kind === 'reading' && limit.remainingPercent !== undefined)
         .sort(displayOrder);
-    for (const limit of readings) {
-        times.push(limit.checkedAt);
-        parts.push(`${quotaWindowName(limit)} ${percentLeft(limit.remainingPercent ?? 0)}${full ? resetText(limit.resetsAt, now) : ''}`);
-    }
+    const windows = readings.map((limit) => {
+        const remainingPercent = clampPercent(limit.remainingPercent ?? 0);
+        return {
+            kind: 'window',
+            name: quotaWindowName(limit),
+            figure: percentLeft(limit.remainingPercent ?? 0),
+            remainingPercent,
+            checkedAt: limit.checkedAt,
+            ...resetDetails(limit.resetsAt, limit.checkedAt, now),
+        };
+    });
     const budget = quota.budget;
     if (budget) {
-        times.push(budget.checkedAt);
+        const remainingPercent = budget.remainingPercent;
         const figure = budget.reached
             ? 'credits spent'
-            : budget.remainingPercent !== undefined
-                ? `credits ${percentLeft(budget.remainingPercent)}`
+            : remainingPercent !== undefined
+                ? `credits ${percentLeft(remainingPercent)}`
                 : 'credits available';
-        parts.push(`${figure}${full ? resetText(budget.resetsAt, now) : ''}`);
+        windows.push({
+            kind: 'budget',
+            name: 'credits',
+            figure,
+            ...(remainingPercent === undefined
+                ? {}
+                : { remainingPercent: clampPercent(remainingPercent) }),
+            checkedAt: budget.checkedAt,
+            ...resetDetails(budget.resetsAt, budget.checkedAt, now),
+        });
     }
-    if (times.length > 0) {
-        const age = now - Math.min(...times);
-        if (age > (options.staleAfterMs ?? QUOTA_STALE_AFTER_MS))
-            parts.push(`checked ${shortSpan(age)} ago`);
+    if (windows.length > 0) {
+        const age = now - Math.min(...windows.map((part) => part.checkedAt));
+        if (age > (options.staleAfterMs ?? QUOTA_STALE_AFTER_MS)) {
+            return { windows, age: `checked ${shortSpan(age)} ago` };
+        }
     }
-    return parts;
+    return { windows };
+}
+/**
+ * The pieces of a quota text, in order: one per reported window
+ * (`5h 58% left, resets 2h`), then the credit budget when there is one, then
+ * `checked 3h ago` when the oldest piece shown is stale. Empty when nothing
+ * was reported; `formatQuota` turns that into a sentence. A caller printing
+ * one line per window (the terminal auth menu) uses these directly.
+ */
+export function quotaTextParts(quota, options) {
+    const parts = quotaWindowParts(quota, options);
+    const full = (options.form ?? 'full') === 'full';
+    const text = parts.windows.map((part) => {
+        const reset = full && part.resetIn ? `, resets ${part.resetIn}` : '';
+        return `${part.kind === 'budget' ? '' : `${part.name} `}${part.figure}${reset}`;
+    });
+    return parts.age === undefined ? text : [...text, parts.age];
 }
 /**
  * A row's quota as one line: `5h 58% left · 7d 90% left` in the compact

package/dist/src/common-auth-embedded/quota/index.d.ts

@@ -1,9 +1,9 @@
 export type { QuotaCodec } from './codec.js';
 export { quotaCodec } from './codec.js';
-export type { QuotaTextForm, QuotaTextOptions } from './format.js';
-export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, } from './format.js';
-export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, QuotaAbsentEntry, QuotaEntry, QuotaMap, QuotaReadingEntry, QuotaRetiredEntry, } from './map.js';
-export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, emptyQuotaMap, isQuotaMap, } from './map.js';
+export type { QuotaParts, QuotaTextForm, QuotaTextOptions, QuotaWindowPart, } from './format.js';
+export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from './format.js';
+export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, QuotaAbsentEntry, QuotaCounter, QuotaEntry, QuotaMap, QuotaReadingEntry, QuotaRetiredEntry, } from './map.js';
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from './map.js';
 export type { ObservedBudget, ObservedPair, ObservedReading, QuotaObservation, } from './merge.js';
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from './merge.js';
 export type { ExhaustionReset, ProjectedBudget, ProjectedLimit, ProjectedQuota, } from './projection.js';

package/dist/src/common-auth-embedded/quota/index.js

@@ -1,5 +1,5 @@
 export { quotaCodec } from './codec.js';
-export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, } from './format.js';
-export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, emptyQuotaMap, isQuotaMap, } from './map.js';
+export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from './format.js';
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from './map.js';
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from './merge.js';
 export { budgetExhaustedResetAt, futureResetAt, projectQuota, readsExhausted, } from './projection.js';

package/dist/src/common-auth-embedded/quota/map.d.ts

@@ -44,16 +44,27 @@ export interface CreditBudgetCleared {
     checkedAt: number;
 }
 export type CreditBudgetEntry = CreditBudgetReading | CreditBudgetCleared;
+export interface QuotaCounter {
+    value: number;
+    checkedAt: number;
+}
 export interface QuotaMap {
     limits: QuotaEntry[];
     /** Absent means no observation has reported on the budget yet. */
     budget?: CreditBudgetEntry;
+    /** Provider-named counts, each with its own observation time. */
+    counters?: Record<string, QuotaCounter>;
 }
 export declare function emptyQuotaMap(): QuotaMap;
 /** The time an entry speaks for: its reading, retirement or absence time. */
 export declare function entryTime(entry: QuotaEntry): number;
 export declare function limitKey(scope: string, label: string): string;
 export declare function isCreditBudgetEntry(value: unknown): value is CreditBudgetEntry;
+export declare function isQuotaCounters(value: unknown): value is Record<string, QuotaCounter>;
+/** Keep usable counters without letting one malformed count hide a quota map. */
+export declare function readQuotaCounters(value: unknown): Record<string, QuotaCounter> | undefined;
+/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+export declare function decodeQuotaMap(value: unknown): QuotaMap | undefined;
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys
  * are tolerated (and preserved by merge) so a newer writer's additions