@cortexkit/anthropic-auth-core 1.20.0 → 1.21.0

package/dist/claude-code.d.ts

@@ -1,11 +1,13 @@
 export type ClaudeCodeIdentity = {
     deviceId: string;
+    accountIdentity?: string;
     accountUuid?: string;
     sessionId: string;
 };
 export declare function setBounded<K, V>(map: Map<K, V>, key: K, value: V, limit?: number): void;
 export declare function getClaudeCodeIdentity(seed: string): ClaudeCodeIdentity;
-export declare function resolveClaudeCodeIdentity(accessToken: string, model?: string): Promise<ClaudeCodeIdentity>;
+export declare function resetClaudeCodeIdentityCachesForTest(): void;
+export declare function resolveClaudeCodeIdentity(accessToken: string, model: string | undefined, accountIdentity: string | undefined): Promise<ClaudeCodeIdentity>;
 export declare function buildClaudeCodeMetadataUserId(identity: ClaudeCodeIdentity): string | null;
 export declare function applyClaudeCodeMetadata(body: Record<string, unknown>, identity: ClaudeCodeIdentity): boolean;
 export declare const CLAUDE_CODE_FULL_AGENT_BETAS: readonly ['oauth-2025-04-20', 'interleaved-thinking-2025-05-14', 'thinking-token-count-2026-05-13', 'context-management-2025-06-27', 'prompt-caching-scope-2026-01-05', 'claude-code-20250219', 'advisor-tool-2026-03-01', 'advanced-tool-use-2025-11-20', 'extended-cache-ttl-2025-04-11', 'cache-diagnosis-2026-04-07'];

package/dist/claude-code.js

@@ -10,6 +10,16 @@ export function setBounded(map, key, value, limit = IDENTITY_CACHE_LIMIT) {
     }
     map.set(key, value);
 }
+function clearCachedAccountUuid(key, identity) {
+    if (!identity.accountUuid)
+        return identity;
+    if (identityCache.get(key) !== identity) {
+        return { ...identity, accountUuid: undefined };
+    }
+    const cleared = { ...identity, accountUuid: undefined };
+    setBounded(identityCache, key, cleared);
+    return cleared;
+}
 export function getClaudeCodeIdentity(seed) {
     const cacheKey = seed || 'anonymous';
     const cached = identityCache.get(cacheKey);
@@ -26,6 +36,46 @@ const BOOTSTRAP_IDENTITY_CACHE_TTL_MS = 24 * 60 * 60_000;
 const BOOTSTRAP_IDENTITY_NEGATIVE_TTL_MS = 5 * 60_000;
 const bootstrapFetches = new Map();
 const bootstrapResults = new Map();
+export function resetClaudeCodeIdentityCachesForTest() {
+    identityCache.clear();
+    bootstrapFetches.clear();
+    bootstrapResults.clear();
+}
+function compatibilityCacheKey(accessToken) {
+    return `compat:${accessToken || 'anonymous'}`;
+}
+function explicitCacheKey(accountIdentity) {
+    return `identity:${accountIdentity}`;
+}
+function accountCacheKey(accountUuid, accountIdentity) {
+    return `account:${accountUuid}:${accountIdentity}`;
+}
+function adoptCachedIdentity(cached, accountIdentity, accountUuid) {
+    if (!cached)
+        return undefined;
+    if (cached.accountIdentity !== undefined &&
+        cached.accountIdentity !== accountIdentity) {
+        return undefined;
+    }
+    if (accountUuid !== undefined &&
+        cached.accountUuid !== undefined &&
+        cached.accountUuid !== accountUuid) {
+        return undefined;
+    }
+    if (cached.accountIdentity === accountIdentity &&
+        (accountUuid === undefined || cached.accountUuid === accountUuid)) {
+        return cached;
+    }
+    return {
+        ...cached,
+        accountIdentity,
+        ...(accountUuid !== undefined && { accountUuid }),
+    };
+}
+function cacheAccountIdentity(identity, accountIdentity, accountUuid) {
+    setBounded(identityCache, explicitCacheKey(accountIdentity), identity);
+    setBounded(identityCache, accountCacheKey(accountUuid, accountIdentity), identity);
+}
 async function fetchClaudeCodeAccountUuid(accessToken, model) {
     if (!accessToken.startsWith('sk-ant-oat'))
         return null;
@@ -60,47 +110,100 @@ async function fetchClaudeCodeAccountUuid(accessToken, model) {
         clearTimeout(timeout);
     }
 }
-export async function resolveClaudeCodeIdentity(accessToken, model) {
-    const identity = getClaudeCodeIdentity(accessToken);
+export async function resolveClaudeCodeIdentity(accessToken, model, accountIdentity) {
+    const stableAccountIdentity = accountIdentity?.trim() || undefined;
+    const cacheKey = stableAccountIdentity
+        ? explicitCacheKey(stableAccountIdentity)
+        : compatibilityCacheKey(accessToken);
+    let identity;
+    if (stableAccountIdentity) {
+        const cachedIdentity = adoptCachedIdentity(identityCache.get(cacheKey) ?? identityCache.get(accessToken), stableAccountIdentity);
+        identity = cachedIdentity ?? getClaudeCodeIdentity(cacheKey);
+        identity = adoptCachedIdentity(identity, stableAccountIdentity) ?? identity;
+        setBounded(identityCache, cacheKey, identity);
+    }
+    else {
+        identity =
+            identityCache.get(cacheKey) ??
+                identityCache.get(accessToken) ??
+                getClaudeCodeIdentity(cacheKey);
+        setBounded(identityCache, cacheKey, identity);
+        setBounded(identityCache, accessToken, identity);
+    }
     if (!accessToken.startsWith('sk-ant-oat'))
         return identity;
     const now = Date.now();
-    const cachedResult = bootstrapResults.get(accessToken);
+    // A slot-stable identity survives account replacement; bootstrap is the
+    // account lookup that must be repeated for each credential presented to it.
+    const bootstrapKey = `${cacheKey}:${accessToken}`;
+    const cachedResult = bootstrapResults.get(bootstrapKey);
     if (cachedResult && cachedResult.expiresAt > now) {
-        if (!cachedResult.accountUuid)
+        if (!cachedResult.accountUuid) {
+            identity = clearCachedAccountUuid(cacheKey, identity);
+            return identity;
+        }
+        if (!stableAccountIdentity) {
+            if (identity.accountUuid === cachedResult.accountUuid)
+                return identity;
+            identity = { ...identity, accountUuid: cachedResult.accountUuid };
+            setBounded(identityCache, bootstrapKey, identity);
             return identity;
-        const accountCacheKey = `account:${cachedResult.accountUuid}`;
-        const accountIdentity = identityCache.get(accountCacheKey);
-        if (accountIdentity) {
-            setBounded(identityCache, accessToken, accountIdentity);
-            return accountIdentity;
         }
+        const cachedAccountIdentity = adoptCachedIdentity(identityCache.get(accountCacheKey(cachedResult.accountUuid, stableAccountIdentity)) ?? identityCache.get(`account:${cachedResult.accountUuid}`), stableAccountIdentity, cachedResult.accountUuid);
+        if (cachedAccountIdentity) {
+            identity = cachedAccountIdentity;
+            cacheAccountIdentity(identity, stableAccountIdentity, cachedResult.accountUuid);
+            return identity;
+        }
+        if (identity.accountUuid === cachedResult.accountUuid)
+            return identity;
+        identity = {
+            ...identity,
+            accountIdentity: stableAccountIdentity,
+            accountUuid: cachedResult.accountUuid,
+        };
+        cacheAccountIdentity(identity, stableAccountIdentity, cachedResult.accountUuid);
+        return identity;
     }
-    let fetchPromise = bootstrapFetches.get(accessToken);
+    let fetchPromise = bootstrapFetches.get(bootstrapKey);
     if (!fetchPromise) {
         fetchPromise = fetchClaudeCodeAccountUuid(accessToken, model);
-        bootstrapFetches.set(accessToken, fetchPromise);
+        setBounded(bootstrapFetches, bootstrapKey, fetchPromise);
     }
     const accountUuid = await fetchPromise.finally(() => {
-        bootstrapFetches.delete(accessToken);
+        if (bootstrapFetches.get(bootstrapKey) === fetchPromise) {
+            bootstrapFetches.delete(bootstrapKey);
+        }
     });
-    setBounded(bootstrapResults, accessToken, {
+    setBounded(bootstrapResults, bootstrapKey, {
         accountUuid,
         expiresAt: now +
             (accountUuid
                 ? BOOTSTRAP_IDENTITY_CACHE_TTL_MS
                 : BOOTSTRAP_IDENTITY_NEGATIVE_TTL_MS),
     });
-    if (!accountUuid)
+    if (!accountUuid) {
+        identity = clearCachedAccountUuid(cacheKey, identity);
+        return identity;
+    }
+    if (!stableAccountIdentity) {
+        identity = { ...identity, accountUuid };
+        setBounded(identityCache, bootstrapKey, identity);
         return identity;
-    const accountCacheKey = `account:${accountUuid}`;
-    const accountIdentity = identityCache.get(accountCacheKey);
-    if (accountIdentity) {
-        setBounded(identityCache, accessToken, accountIdentity);
-        return accountIdentity;
     }
-    identity.accountUuid = accountUuid;
-    setBounded(identityCache, accountCacheKey, identity);
+    const cachedAccountIdentity = adoptCachedIdentity(identityCache.get(accountCacheKey(accountUuid, stableAccountIdentity)) ??
+        identityCache.get(`account:${accountUuid}`), stableAccountIdentity, accountUuid);
+    if (cachedAccountIdentity) {
+        identity = cachedAccountIdentity;
+        cacheAccountIdentity(identity, stableAccountIdentity, accountUuid);
+        return identity;
+    }
+    identity = {
+        ...identity,
+        accountIdentity: stableAccountIdentity,
+        accountUuid,
+    };
+    cacheAccountIdentity(identity, stableAccountIdentity, accountUuid);
     return identity;
 }
 function isRecord(value) {

package/dist/dump.d.ts

@@ -71,5 +71,6 @@ export declare function dumpRelayRequest(input: {
 export declare function dumpResponseArtifact(handle: DumpHandle | null, input: {
     status: number;
     message: unknown;
+    complete?: boolean;
 }): Promise<void>;
 export {};

package/dist/dump.js

@@ -592,7 +592,10 @@ export async function dumpResponseArtifact(handle, input) {
         !Array.isArray(input.message)
         ? input.message
         : {};
-    const artifact = { status: input.status };
+    const artifact = {
+        status: input.status,
+        stream_complete: input.complete ?? true,
+    };
     if (typeof message.id === 'string' && message.id.length > 0)
         artifact.message_id = message.id;
     if (typeof message.model === 'string' && message.model.length > 0)
@@ -601,6 +604,8 @@ export async function dumpResponseArtifact(handle, input) {
         artifact.usage = message.usage;
     if (Object.hasOwn(message, 'diagnostics'))
         artifact.diagnostics = message.diagnostics;
+    if (typeof message.stop_reason === 'string' && message.stop_reason.length > 0)
+        artifact.stop_reason = message.stop_reason;
     try {
         await writeDumpFile(handle.responsePath, `${JSON.stringify(artifact, null, 2)}\n`);
     }

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from './oauth-profile.ts';
 export * from './pkce.ts';
 export * from './prime.ts';
 export * from './provider.ts';
+export * from './quota-header-feed.ts';
 export * from './quota-headers.ts';
 export * from './quota-manager.ts';
 export * from './quotas.ts';

package/dist/index.js

@@ -17,6 +17,7 @@ export * from './oauth-profile.js';
 export * from './pkce.js';
 export * from './prime.js';
 export * from './provider.js';
+export * from './quota-header-feed.js';
 export * from './quota-headers.js';
 export * from './quota-manager.js';
 export * from './quotas.js';

package/dist/oauth-profile.d.ts

@@ -2,10 +2,11 @@ import type { OAuthAccountProfile } from './accounts.ts';
 export declare const PROFILE_TTL_MS: number;
 export declare function fetchOAuthAccountProfile(input: {
     accessToken: string;
+    accountIdentity?: string;
     fetchImpl?: typeof fetch;
     now?: () => number;
     signal?: AbortSignal;
 }): Promise<OAuthAccountProfile>;
-export declare function oauthProfileMatchesToken(profile: OAuthAccountProfile | undefined, accessToken: string): boolean;
+export declare function oauthProfileMatchesIdentity(profile: OAuthAccountProfile | undefined, accountIdentity: string | undefined): boolean;
 export declare function oauthProfileIsFresh(profile: OAuthAccountProfile | undefined, now?: number): boolean;
 export declare function formatOAuthAccountTier(profile: OAuthAccountProfile | undefined): string | undefined;

package/dist/oauth-profile.js

@@ -1,4 +1,3 @@
-import { tokenFingerprint } from './quota-manager.js';
 const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
 export const PROFILE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 export async function fetchOAuthAccountProfile(input) {
@@ -27,11 +26,18 @@ export async function fetchOAuthAccountProfile(input) {
         tier,
         orgType,
         checkedAt: input.now?.() ?? Date.now(),
-        tokenFingerprint: tokenFingerprint(input.accessToken),
+        ...(input.accountIdentity !== undefined && {
+            accountIdentity: input.accountIdentity,
+        }),
     };
 }
-export function oauthProfileMatchesToken(profile, accessToken) {
-    return profile?.tokenFingerprint === tokenFingerprint(accessToken);
+export function oauthProfileMatchesIdentity(profile, accountIdentity) {
+    if (!profile)
+        return false;
+    if (accountIdentity === undefined)
+        return true;
+    return (profile.accountIdentity === undefined ||
+        profile.accountIdentity === accountIdentity);
 }
 export function oauthProfileIsFresh(profile, now = Date.now()) {
     return Boolean(profile &&

package/dist/quota-header-feed.d.ts

@@ -0,0 +1,40 @@
+import { type AccountStorage, type OAuthQuotaSnapshot } from './accounts.ts';
+export declare const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+export declare const QUOTA_HEADER_FEED_LEASE_MS = 180000;
+export type QuotaHeaderFeedIdentity = {
+    identity_source: 'credential_id';
+    credential_id: string;
+} | {
+    identity_source: 'account_ref';
+    account_ref: string;
+} | {
+    identity_source: 'none';
+};
+export type QuotaHeaderFeedEntry = QuotaHeaderFeedIdentity & {
+    schema_version: typeof QUOTA_HEADER_FEED_SCHEMA_VERSION;
+    provider: 'anthropic';
+    configured_account_count: number;
+    observed_at_ms: number;
+    quota: Pick<OAuthQuotaSnapshot, 'five_hour' | 'seven_day' | 'bindingWindow' | 'fallbackAdvised' | 'scoped' | 'extraUsage'>;
+};
+export declare function getDefaultQuotaHeaderFeedDirectory(): string;
+export declare function configuredAnthropicOAuthAccountCount(input: {
+    storage: AccountStorage | null;
+    mainOAuthConfigured: boolean;
+}): number;
+export declare class QuotaHeaderFeedRegistry {
+    private readonly options;
+    private readonly filePath;
+    private writeChain;
+    constructor(options?: {
+        directory?: string;
+        now?: () => number;
+        leaseMs?: number;
+        instanceId?: string;
+    });
+    publish(entry: QuotaHeaderFeedEntry & {
+        accountKey: string;
+    }): Promise<void>;
+    list(): Promise<QuotaHeaderFeedEntry[]>;
+    dispose(): Promise<void>;
+}

package/dist/quota-header-feed.js

@@ -0,0 +1,248 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readdir, readFile, rename, rm, writeFile, } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { isOAuthAccount, } from './accounts.js';
+export const QUOTA_HEADER_FEED_SCHEMA_VERSION = 2;
+export const QUOTA_HEADER_FEED_LEASE_MS = 180_000;
+export function getDefaultQuotaHeaderFeedDirectory() {
+    return (process.env.OPENCODE_ANTHROPIC_AUTH_QUOTA_FEED_DIR ??
+        join(tmpdir(), 'opencode-anthropic-auth', 'quota-header-feed'));
+}
+export function configuredAnthropicOAuthAccountCount(input) {
+    const fallbackCount = input.storage?.accounts.filter(isOAuthAccount).length ?? 0;
+    return fallbackCount + (input.mainOAuthConfigured ? 1 : 0);
+}
+function validIdentity(entry) {
+    if (entry.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+        entry.provider !== 'anthropic')
+        return false;
+    if (!Number.isFinite(entry.configured_account_count) ||
+        !Number.isFinite(entry.observed_at_ms))
+        return false;
+    if (!entry.quota || typeof entry.quota !== 'object')
+        return false;
+    if (entry.identity_source === 'none') {
+        return !('credential_id' in entry) && !('account_ref' in entry);
+    }
+    if (entry.identity_source === 'credential_id') {
+        return (typeof entry.credential_id === 'string' &&
+            entry.credential_id.length > 0 &&
+            entry.credential_id !== 'main' &&
+            !('account_ref' in entry));
+    }
+    if (entry.identity_source === 'account_ref') {
+        return (typeof entry.account_ref === 'string' &&
+            entry.account_ref.length > 0 &&
+            entry.account_ref !== 'main' &&
+            !('credential_id' in entry));
+    }
+    return false;
+}
+function validatePublishEntry(entry) {
+    if (entry.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+        entry.provider !== 'anthropic' ||
+        !validIdentity(entry)) {
+        throw new Error('Invalid quota header feed entry');
+    }
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function projectQuotaWindow(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (!finiteNumber(candidate.usedPercent) ||
+        !finiteNumber(candidate.remainingPercent) ||
+        !finiteNumber(candidate.checkedAt)) {
+        return undefined;
+    }
+    return {
+        usedPercent: candidate.usedPercent,
+        remainingPercent: candidate.remainingPercent,
+        ...(typeof candidate.resetsAt === 'string' && {
+            resetsAt: candidate.resetsAt,
+        }),
+        checkedAt: candidate.checkedAt,
+    };
+}
+function projectScopedQuotaWindow(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const window = projectQuotaWindow(candidate);
+    if (!window ||
+        typeof candidate.id !== 'string' ||
+        !candidate.id.trim() ||
+        typeof candidate.title !== 'string' ||
+        !candidate.title.trim() ||
+        typeof candidate.modelName !== 'string' ||
+        !candidate.modelName.trim()) {
+        return undefined;
+    }
+    return {
+        ...window,
+        id: candidate.id,
+        title: candidate.title,
+        ...(typeof candidate.modelId === 'string' &&
+            candidate.modelId.trim() && {
+            modelId: candidate.modelId,
+        }),
+        modelName: candidate.modelName,
+    };
+}
+function projectQuotaMoney(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    if (!finiteNumber(candidate.amountMinor) ||
+        typeof candidate.currency !== 'string' ||
+        !candidate.currency.trim() ||
+        !finiteNumber(candidate.exponent)) {
+        return undefined;
+    }
+    return {
+        amountMinor: candidate.amountMinor,
+        currency: candidate.currency,
+        exponent: candidate.exponent,
+    };
+}
+function projectExtraUsage(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const used = projectQuotaMoney(candidate.used);
+    const limit = projectQuotaMoney(candidate.limit);
+    if (!used || !limit || typeof candidate.exhausted !== 'boolean') {
+        return undefined;
+    }
+    return {
+        used,
+        limit,
+        ...(finiteNumber(candidate.utilizationPercent) && {
+            utilizationPercent: candidate.utilizationPercent,
+        }),
+        ...(typeof candidate.severity === 'string' && {
+            severity: candidate.severity,
+        }),
+        exhausted: candidate.exhausted,
+    };
+}
+function projectQuota(quota) {
+    const fiveHour = projectQuotaWindow(quota.five_hour);
+    const sevenDay = projectQuotaWindow(quota.seven_day);
+    const scoped = Array.isArray(quota.scoped)
+        ? quota.scoped
+            .map(projectScopedQuotaWindow)
+            .filter((entry) => entry != null)
+        : undefined;
+    const extraUsage = projectExtraUsage(quota.extraUsage);
+    return {
+        ...(fiveHour && { five_hour: fiveHour }),
+        ...(sevenDay && { seven_day: sevenDay }),
+        ...(typeof quota.bindingWindow === 'string' && {
+            bindingWindow: quota.bindingWindow,
+        }),
+        ...(typeof quota.fallbackAdvised === 'boolean' && {
+            fallbackAdvised: quota.fallbackAdvised,
+        }),
+        ...(scoped && { scoped }),
+        ...(extraUsage && { extraUsage }),
+    };
+}
+export class QuotaHeaderFeedRegistry {
+    options;
+    filePath;
+    writeChain = Promise.resolve();
+    constructor(options = {}) {
+        this.options = options;
+        const instanceId = options.instanceId ?? `${process.pid}-${randomUUID()}`;
+        this.filePath = join(options.directory ?? getDefaultQuotaHeaderFeedDirectory(), `${instanceId}.json`);
+    }
+    publish(entry) {
+        const { accountKey, quota, ...entryWithoutQuota } = entry;
+        const cleanEntry = {
+            ...entryWithoutQuota,
+            quota: projectQuota(quota),
+        };
+        try {
+            validatePublishEntry(cleanEntry);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (!accountKey)
+            return Promise.reject(new Error('Invalid quota header feed account key'));
+        this.writeChain = this.writeChain
+            .catch(() => { })
+            .then(async () => {
+            const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await chmod(directory, 0o700);
+            let entries = {};
+            try {
+                const record = JSON.parse(await readFile(this.filePath, 'utf8'));
+                if (record.version === QUOTA_HEADER_FEED_SCHEMA_VERSION &&
+                    record.entries &&
+                    typeof record.entries === 'object')
+                    entries = record.entries;
+            }
+            catch { }
+            entries[accountKey] = cleanEntry;
+            const tempPath = `${this.filePath}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(tempPath, `${JSON.stringify({ version: QUOTA_HEADER_FEED_SCHEMA_VERSION, entries })}\n`, { mode: 0o600 });
+                await chmod(tempPath, 0o600);
+                await rename(tempPath, this.filePath);
+            }
+            finally {
+                await rm(tempPath, { force: true });
+            }
+        });
+        return this.writeChain;
+    }
+    async list() {
+        await this.writeChain.catch(() => { });
+        const directory = this.options.directory ?? getDefaultQuotaHeaderFeedDirectory();
+        const now = this.options.now?.() ?? Date.now();
+        const leaseMs = this.options.leaseMs ?? QUOTA_HEADER_FEED_LEASE_MS;
+        let names;
+        try {
+            names = (await readdir(directory)).filter((name) => name.endsWith('.json'));
+        }
+        catch {
+            return [];
+        }
+        const newest = new Map();
+        await Promise.all(names.map(async (name) => {
+            try {
+                const record = JSON.parse(await readFile(join(directory, name), 'utf8'));
+                if (record.version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+                    !record.entries ||
+                    typeof record.entries !== 'object')
+                    return;
+                for (const [accountKey, candidate] of Object.entries(record.entries)) {
+                    if (!candidate ||
+                        typeof candidate !== 'object' ||
+                        candidate.schema_version !== QUOTA_HEADER_FEED_SCHEMA_VERSION ||
+                        candidate.provider !== 'anthropic' ||
+                        !validIdentity(candidate))
+                        continue;
+                    const observed = candidate.observed_at_ms;
+                    if (observed > now || now - observed >= leaseMs)
+                        continue;
+                    const existing = newest.get(accountKey);
+                    if (!existing || observed > existing.observed_at_ms)
+                        newest.set(accountKey, candidate);
+                }
+            }
+            catch { }
+        }));
+        return [...newest.values()].sort((a, b) => a.observed_at_ms - b.observed_at_ms);
+    }
+    async dispose() {
+        await this.writeChain.catch(() => { });
+        await rm(this.filePath, { force: true });
+    }
+}

package/dist/quota-headers.js

@@ -49,11 +49,13 @@ export function normalizeQuotaHeaders(headers, now = Date.now()) {
     return snapshot;
 }
 export function mergeHeaderQuotaSnapshot(existing, incoming) {
+    const { scoped: existingScoped, extraUsage: existingExtraUsage, ...existingWithoutPollOwnedFields } = existing ?? {};
+    const { scoped: _incomingScoped, extraUsage: _incomingExtraUsage, ...incomingWithoutPollOwnedFields } = incoming;
     return {
-        ...existing,
-        ...incoming,
-        scoped: existing && 'scoped' in existing ? existing.scoped : undefined,
-        extraUsage: existing?.extraUsage,
+        ...existingWithoutPollOwnedFields,
+        ...incomingWithoutPollOwnedFields,
+        ...(Array.isArray(existingScoped) && { scoped: existingScoped }),
+        ...(existingExtraUsage != null && { extraUsage: existingExtraUsage }),
         bindingWindow: existing?.bindingWindowSource === 'poll'
             ? existing.bindingWindow
             : (incoming.bindingWindow ?? existing?.bindingWindow),