@cortexkit/anthropic-auth-core 2.2.0 → 2.2.2

package/dist/internal-types/claustrum/consumer.d.ts

@@ -169,8 +169,10 @@ export declare class ClaustrumConsumer<Q = QuotaObservation> {
      * 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.
+     * Memory updates immediately; durable publication is detached and coalesced.
      */
     recordAccountQuota(routeId: string, accountIdentity: string, observation: QuotaObservation): Promise<boolean>;
     close(): void;
+    /** Close immediately; the last consumer also waits for the writer's bounded drain. */
+    dispose(): Promise<void>;
 }

package/dist/internal-types/claustrum/index.d.ts

@@ -9,6 +9,7 @@ export { ClaustrumConsumerError, type ClaustrumConsumerFailureKind, type Claustr
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, type HostSlotContent, isCustodyPlaceholder, isCustodyPlaceholderValue, } from './host-slot.js';
 export { acquireInsulaQuotaSource, type InsulaQuotaContext, type InsulaQuotaLookup, type InsulaQuotaMiss, type InsulaQuotaOptions, type InsulaQuotaReading, type InsulaQuotaResult, type InsulaQuotaSource, type InsulaUsageEntry, type InsulaUsageTransport, type InsulaUsageWatch, type InsulaUsageWindow, type InsulaWatchOptions, } from './insula.js';
 export { acceptAccount, type DeclinedAccount, declineAccount, isDeclined, } from './interlock.js';
+export { drainVaultQuota } from './quota-writer.js';
 export { type AccountMapper, acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, type MutateVaultRosterOptions, mutateVaultRoster, type ProjectionOptions, projectVaultRoster, type QuotaReceipt, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, type VaultPrimary, type VaultPrimaryBinding, type VaultPrimaryUnavailableReason, type VaultRosterFile, type VaultRosterLockContext, type VaultRosterRow, vaultRoutingRows, } from './roster.js';
 export { type ChangeNotice, ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, type ScopedRosterWatchOptions, type ScopedWatchEnd, type ScopedWatchHandle, type ScopedWatchNoticeShape, type ScopedWatchSource, WATCH_RETRY_MS, type WatchMode, } from './watch.js';
 /**

package/dist/internal-types/claustrum/quota-writer.d.ts

@@ -0,0 +1,18 @@
+import { type QuotaObservation } from '../quota/index.js';
+import { type QuotaReceipt, type VaultRosterFile } from './roster.js';
+export type VaultQuotaPublication = {
+    routeId: string;
+    accountIdentity?: string;
+    receipt?: QuotaReceipt;
+    observation: QuotaObservation;
+};
+type Listener = (publication: VaultQuotaPublication) => void;
+/** Retain the shared writer; the last consumer's close drains it. */
+export declare function retainVaultQuotaWriter(path: string, listener: Listener): () => Promise<void>;
+/** Enqueue without filesystem work; each quota field retains its own receipt fence. */
+export declare function enqueueVaultQuota(path: string, publication: VaultQuotaPublication): Promise<boolean>;
+/** Overlay uncommitted observations when a consumer reloads the durable roster. */
+export declare function pendingVaultQuota(path: string, roster: VaultRosterFile | undefined): VaultRosterFile | undefined;
+/** Wait at most timeoutMs for detached publication; shutdown loss is acceptable. */
+export declare function drainVaultQuota(path: string, timeoutMs?: number): Promise<void>;
+export {};

package/dist/internal-types/claustrum/roster.d.ts

@@ -2,6 +2,8 @@ import { type QuotaMap, type QuotaObservation } from '../quota/index.js';
 import type { RoutingRow } from '../routing/index.js';
 import type { ClaustrumScopedAttempt, ClaustrumScopedCustody, SkippedVaultRecord, VaultCredential, VaultCredentialType, VaultInventory } from './custody.js';
 import { type DeclinedAccount } from './interlock.js';
+import { type VaultQuotaPublication } from './quota-writer.js';
+export { drainVaultQuota } from './quota-writer.js';
 /**
  * One vault account as the pool sees it. It carries no bearer material: the
  * access token is fetched from the vault for every send. Several vault
@@ -91,6 +93,7 @@ export interface VaultRosterLockContext {
     assertOwned: () => Promise<void>;
 }
 export interface MutateVaultRosterOptions {
+    signal?: AbortSignal;
     /**
      * Runs when the new roster is fully staged on disk, immediately before the
      * rename that publishes it, so a caller can confirm a lease of its own at
@@ -127,7 +130,10 @@ export type QuotaReceipt = Pick<ClaustrumScopedAttempt, 'credentialId' | 'accoun
  * write is fenced on the receipt the reading was taken with: it lands only
  * while the row still holds that receipt's credential (as representative or
  * alias) and account, so a slow read for a replaced account can never land on
- * its successor. Returns whether the observation was kept.
+ * its successor. Resolves false when the fence refuses the reading against the
+ * roster as it stands now (on disk, plus readings this process has not
+ * written yet), and true once the reading is queued for the next write. The
+ * write applies the fence again, so a rebind between the two still refuses.
  */
 export declare function recordVaultQuota(path: string, input: QuotaReceipt & {
     routeId: string;
@@ -139,19 +145,28 @@ export declare function recordVaultQuota(path: string, input: QuotaReceipt & {
  * 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.
+ * is refused. Resolves false when the row is not bound to that account now,
+ * and true once the reading is queued, as `recordVaultQuota` does.
  */
 export declare function recordVaultAccountQuota(path: string, input: {
     routeId: string;
     accountIdentity: string;
     observation: QuotaObservation;
 }): Promise<boolean>;
+/** Apply the same identity fence to memory overlays and durable quota batches. */
+export declare function applyVaultQuota(current: VaultRosterFile | undefined, input: VaultQuotaPublication): {
+    roster: VaultRosterFile | undefined;
+    kept: boolean;
+};
+export declare function forgetPendingVaultDiscovery(path: string): void;
 /**
  * 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
  * from a newer one, so a run that lost its lease is refused at commit. A
  * failed list, or custody switching off mid-run, never writes anything; a
  * peer holding the lease means its last committed roster is served instead.
+ * A write-lock timeout keeps the discovered inventory for the next poll,
+ * unless a peer has superseded its base view in the meantime.
  */
 export declare function refreshVaultRoster(options: {
     path: string;
@@ -159,6 +174,7 @@ export declare function refreshVaultRoster(options: {
     isActive?: () => boolean | Promise<boolean>;
     signal?: AbortSignal;
     projection?: ProjectionOptions | (() => ProjectionOptions);
+    onInventory?: (inventory: VaultInventory) => void;
 }): Promise<VaultRosterFile | undefined>;
 /**
  * A host-owned main account as last verified from the vault: the plugin's

package/dist/internal-types/fs/with-lock.d.ts

@@ -28,6 +28,7 @@ export interface LockOptions {
     ttlMs: number;
     timeoutMs: number;
     renew?: boolean;
+    signal?: AbortSignal;
     onStep?: Parameters<typeof acquireRefreshFileLock>[0]['onStep'];
     onRenewalTimer?: Parameters<typeof acquireRefreshFileLock>[0]['onRenewalTimer'];
 }

package/dist/internal-types/quota/format.d.ts

@@ -1,3 +1,4 @@
+import { type QuotaCredits } from './map.js';
 import type { ProjectedLimit, ProjectedQuota } from './projection.js';
 /** A reading older than this is marked with its age. */
 export declare const QUOTA_STALE_AFTER_MS: number;
@@ -31,6 +32,13 @@ export interface QuotaWindowPart {
     kind: 'window' | 'budget';
     /** The display name of a quota window, or `credits` for the budget. */
     name: string;
+    /**
+     * The label the narrow line gives this item: an account-wide window keeps
+     * its name (`5h`), a model-scoped window reads as its model's short name
+     * (`Fa` for Fable, extended until names in the same reading differ), and
+     * the budget reads `cr`. For layouts too narrow for the full name.
+     */
+    short: string;
     /** The shared figure wording, including `credits` for budget figures. */
     figure: string;
     /** The unrounded remaining percentage, clamped to 0–100, when known. */
@@ -84,3 +92,14 @@ export declare function quotaTextParts(quota: ProjectedQuota | undefined, option
  * provider answered without a limit for any window.
  */
 export declare function formatQuota(quota: ProjectedQuota | undefined, options: QuotaTextOptions): string;
+/**
+ * Prepaid credits as one short value, worded as the official Codex client's
+ * status view words them: `Unlimited` for unlimited credits, `<n> credits`
+ * for a finite positive balance (rounded to a whole number), `Available` when
+ * the account has credits but no usable balance was reported, and undefined
+ * when the account has no credits (or `credits` is undefined), so a caller
+ * shows no credits row at all. Unlimited wins even when `hasCredits` is false.
+ * No other formatter adds this text; a caller that wants a credits row asks
+ * for it.
+ */
+export declare function quotaCreditsText(credits: Pick<QuotaCredits, 'hasCredits' | 'unlimited' | 'balance'> | undefined): string | undefined;

package/dist/internal-types/quota/index.d.ts

@@ -1,9 +1,9 @@
 export type { QuotaCodec } from './codec.js';
 export { quotaCodec } from './codec.js';
 export type { QuotaParts, QuotaTextForm, QuotaTextOptions, QuotaWindowPart, } from './format.js';
-export { formatQuota, isQuotaStale, 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 { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaCreditsText, quotaTextParts, quotaWindowName, quotaWindowParts, } from './format.js';
+export type { CreditBudgetCleared, CreditBudgetEntry, CreditBudgetReading, QuotaAbsentEntry, QuotaCounter, QuotaCredits, QuotaEntry, QuotaMap, QuotaReadingEntry, QuotaRetiredEntry, } from './map.js';
+export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaCredits, 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, QuotaGroup, } from './projection.js';

package/dist/internal-types/quota/map.d.ts

@@ -48,12 +48,30 @@ export interface QuotaCounter {
     value: number;
     checkedAt: number;
 }
+/**
+ * Prepaid credits a provider account holds beside its rate-limit windows (for
+ * example a ChatGPT workspace's credits, which keep requests working after a
+ * window is used up). This is a state, not a count or the spend budget: the
+ * account has credits or not, they may be unlimited, and the provider may
+ * report a balance. It carries its own observation time.
+ */
+export interface QuotaCredits {
+    hasCredits: boolean;
+    unlimited: boolean;
+    /** The balance the provider reported, when it reported one. */
+    balance?: number;
+    /** The provider's verdict that the overage allowance is used up. */
+    overageLimitReached?: boolean;
+    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>;
+    /** Absent means no observation has reported on prepaid credits yet. */
+    credits?: QuotaCredits;
 }
 export declare function emptyQuotaMap(): QuotaMap;
 /** The time an entry speaks for: its reading, retirement or absence time. */
@@ -61,9 +79,14 @@ 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>;
+/** True when `value` is a well-formed prepaid-credits record. */
+export declare function isQuotaCredits(value: unknown): value is QuotaCredits;
 /** 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. */
+/**
+ * Decode persisted quota, dropping malformed counters or a malformed credits
+ * record but not limit or budget evidence.
+ */
 export declare function decodeQuotaMap(value: unknown): QuotaMap | undefined;
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys

package/dist/internal-types/quota/merge.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaCounter, type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaCredits, type QuotaMap } from './map.js';
 export interface ObservedReading {
     /** Defaults to `all`. */
     scope?: string;
@@ -34,6 +34,11 @@ export interface QuotaObservation {
     budget?: ObservedBudget;
     /** Each named count uses its own time, independently of limits and budget. */
     counters?: Record<string, QuotaCounter>;
+    /**
+     * Prepaid credits, judged by their own time independently of limits, budget
+     * and counters. Absent means the observation says nothing about credits.
+     */
+    credits?: QuotaCredits;
 }
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export declare class QuotaCodecError extends TypeError {

package/dist/internal-types/quota/projection.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaCounter, type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaCredits, type QuotaMap } from './map.js';
 export interface ProjectedLimit {
     scope: string;
     label: string;
@@ -40,6 +40,8 @@ export interface ProjectedQuota {
     /** Present only when the stored budget is a reading, not cleared. */
     budget?: ProjectedBudget;
     counters?: Record<string, QuotaCounter>;
+    /** The stored prepaid credits, unchanged in every scope. */
+    credits?: QuotaCredits;
     /**
      * The named groups the windows belong to, in the order the plugin lists
      * them. Set only by a plugin whose windows all belong to such groups; the

package/dist/internal-types/setup/process-fence.d.ts

@@ -33,11 +33,18 @@ export declare function listSetupProcesses(runner?: CommandRunner, options?: {
     onStep?: (details: ProcessInspectionStep) => void;
     /** False skips the Windows PowerShell query for Node and Bun command lines. */
     inspectRuntimes?: boolean;
+    /**
+     * The process to leave out, the running setup itself. Defaults to
+     * `process.pid`; tests pass a value no listed process can have, because in
+     * a container this process can hold any small PID a fixture uses.
+     */
+    selfPid?: number;
 }): Promise<Array<{
     pid: number;
     command: string;
 }>>;
 export declare function createProcessFence(runner?: CommandRunner, options?: {
     platform?: string;
+    selfPid?: number;
 }): ProcessFence;
 export declare function assertHostsStopped(fence: ProcessFence, env?: SetupEnvironment): Promise<void>;

package/dist/native-vault-runtime.d.ts

@@ -122,7 +122,7 @@ export interface NativeVaultRuntime {
 export declare function publishNativeVaultRosterSeed(paths: Pick<NativeVaultPaths, 'roster'>, input: NativeRosterSeedInput, options?: {
     assertOwned?: () => Promise<void>;
 }): Promise<NativeVaultRosterSeed>;
-/** Match imported metadata to the held vault roster before publishing it. The caller's assertOwned fences its captured input; the roster lease separately prevents account replacement during the metadata write. */
+/** Match imported custody metadata to the current roster without blocking roster writers. The optional assertOwned callback separately rechecks the caller's captured input before rename. */
 export declare function publishNativeVaultRuntimeSeed(paths: Pick<NativeVaultPaths, 'roster' | 'runtime' | 'storageId'>, state: NativeRuntimeState, options?: {
     assertOwned?: () => Promise<void>;
 }): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/anthropic-auth-core",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@cortexkit/common-auth": "0.22.0"
+    "@cortexkit/common-auth": "0.23.0"
   },
   "dependencies": {
     "@cortexkit/claustrum-client": "0.12.0",