@cortexkit/antigravity-auth-core 3.0.8 → 3.0.10

package/dist/common-auth-embedded/auth-menu/login.d.ts

@@ -26,28 +26,24 @@ export interface MenuLogin {
         signal?: AbortSignal;
     }): Promise<LoginFlow>;
     /**
-     * Opens the URL in a browser; false or a throw means no browser could be
-     * opened. Defaults to `openBrowserForMenu`.
+     * Opens the URL in a browser; false or a throw means its opener could not be
+     * started. Defaults to `openBrowserForMenu`.
      */
     openBrowser?(url: string): boolean | undefined | Promise<boolean | undefined>;
 }
-type BrowserExec = (file: string, args: string[], options: {
-    stdio: 'ignore';
-    timeout: number;
-}) => unknown;
 type BrowserSpawn = (file: string, args: string[], options: {
     stdio: 'ignore';
-    windowsHide: true;
+    windowsHide?: true;
 }) => {
     pid?: number;
     unref(): void;
     on(event: 'error', listener: () => void): unknown;
 };
-/** Opens a URL with the platform's opener; false when that fails. */
-export declare function openBrowserForMenu(url: string, platform?: NodeJS.Platform, execFileSync?: BrowserExec, spawn?: BrowserSpawn): boolean;
+/** Opens a URL with the platform's opener; false when it could not start. */
+export declare function openBrowserForMenu(url: string, platform?: NodeJS.Platform, spawn?: BrowserSpawn): boolean;
 /**
  * Runs a login for the menu: a browser login first and, when no browser can
- * be opened, a device-code login instead, so a headless machine can still
+ * be started, a device-code login instead, so a headless machine can still
  * add an account. The URL is always printed, so an operator can open it by
  * hand when the opener reports success but nothing appears.
  */

package/dist/common-auth-embedded/auth-menu/login.js

@@ -1,6 +1,6 @@
-import { execFileSync as defaultExecFileSync, spawn as defaultSpawn, } from 'node:child_process';
-/** Opens a URL with the platform's opener; false when that fails. */
-export function openBrowserForMenu(url, platform = process.platform, execFileSync = defaultExecFileSync, spawn = defaultSpawn) {
+import { spawn as defaultSpawn } from 'node:child_process';
+/** Opens a URL with the platform's opener; false when it could not start. */
+export function openBrowserForMenu(url, platform = process.platform, spawn = defaultSpawn) {
     try {
         if (platform === 'win32') {
             // Start-Process opens the URL with its associated app. Base64 UTF-16LE
@@ -28,15 +28,18 @@ export function openBrowserForMenu(url, platform = process.platform, execFileSyn
             // Node leaves pid undefined when the process could not be started.
             return child.pid !== undefined;
         }
-        else {
-            execFileSync(platform === 'darwin' ? 'open' : 'xdg-open', [url], {
-                stdio: 'ignore',
-                timeout: 3000,
-            });
-        }
-        return true;
+        const child = spawn(platform === 'darwin' ? 'open' : 'xdg-open', [url], {
+            stdio: 'ignore',
+        });
+        // A failed launch reports asynchronously; without a listener it would
+        // become an uncaught exception after this function has returned.
+        child.on('error', () => { });
+        child.unref();
+        // The URL handler's process may outlive the caller; a pid means launch began.
+        return child.pid !== undefined;
     }
     catch {
+        // Browser launch is best effort; the printed URL remains the fallback.
         return false;
     }
 }
@@ -53,7 +56,7 @@ function printFlow(context, flow) {
 }
 /**
  * Runs a login for the menu: a browser login first and, when no browser can
- * be opened, a device-code login instead, so a headless machine can still
+ * be started, a device-code login instead, so a headless machine can still
  * add an account. The URL is always printed, so an operator can open it by
  * hand when the opener reports success but nothing appears.
  */

package/dist/common-auth-embedded/claustrum/consumer.d.ts

@@ -3,7 +3,7 @@ import type { QuotaObservation } from '../quota/index.js';
 import type { RoutingRow } from '../routing/index.js';
 import { type ClaustrumFamily, type ClaustrumScopedAttempt, type ClaustrumScopedClient, type IdentityParser, type KeptReceiptState, type VaultGrantReach } from './custody.js';
 import { type ClaustrumLogger } from './errors.js';
-import { type InsulaQuotaOptions } from './insula.js';
+import { type InsulaQuotaOptions, type InsulaQuotaResult } from './insula.js';
 import { type AccountMapper, type QuotaReceipt, type VaultRosterFile } from './roster.js';
 import { type WatchMode } from './watch.js';
 export interface ClaustrumConsumerOptions<Q = QuotaObservation> {
@@ -134,6 +134,10 @@ export declare class ClaustrumConsumer<Q = QuotaObservation> {
      * A route without a known provider account cannot join an insula entry.
      */
     cachedInsulaQuotaForRoute(routeId: string): Promise<Q | undefined>;
+    /** Cache-only background lookup, preserving the reason a route has no reading. */
+    lookupInsulaQuotaForRoute(routeId: string): Promise<InsulaQuotaResult<Q>>;
+    /** Skip the fallback poll while insula is cold or its upstream fetch failed. */
+    pollInsulaQuotaForRoute(routeId: string, fallback: () => Promise<Q | undefined>): Promise<Q | 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
@@ -165,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/common-auth-embedded/claustrum/consumer.js

@@ -3,8 +3,9 @@ import { combineAbortSignals } from '../util/any-signal.js';
 import { ClaustrumScopedCustody, decideScopedRetryAfter401, } from './custody.js';
 import { readClaustrumEnrollmentToken } from './enrollment.js';
 import { ClaustrumConsumerError } from './errors.js';
-import { acquireInsulaQuotaSource } from './insula.js';
-import { acceptVaultRoute, declineVaultRoute, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, vaultRoutingRows, } from './roster.js';
+import { acquireInsulaQuotaSource, } from './insula.js';
+import { pendingVaultQuota, retainVaultQuotaWriter } from './quota-writer.js';
+import { acceptVaultRoute, applyVaultQuota, declineVaultRoute, forgetPendingVaultDiscovery, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, vaultRoutingRows, } from './roster.js';
 import { SAFETY_POLL_MS } from './watch.js';
 /**
  * One plugin host's view of its vault accounts. It turns vault credentials
@@ -32,11 +33,16 @@ export class ClaustrumConsumer {
     #insula;
     #vaultWatch;
     #releaseInsulaWatch;
+    #insulaSkips = new Map();
     /** When this instance last completed a discovery, by `now`. */
     #discoveredAt;
+    #releaseQuotaWriter;
     constructor(options) {
         this.#options = options;
         this.#logger = options.logger ?? createLogger('claustrum');
+        this.#releaseQuotaWriter = retainVaultQuotaWriter(options.rosterPath, (publication) => {
+            this.#roster = applyVaultQuota(this.#roster, publication).roster;
+        });
     }
     #assertOpen(signal) {
         this.#shutdown.signal.throwIfAborted();
@@ -175,11 +181,9 @@ export class ClaustrumConsumer {
             let discovered;
             const roster = await refreshVaultRoster({
                 path: this.#options.rosterPath,
-                custody: {
-                    discover: async (signal) => {
-                        discovered = await custody.discover(signal);
-                        return discovered;
-                    },
+                custody,
+                onInventory: (inventory) => {
+                    discovered = inventory;
                 },
                 isActive: () => this.#active(),
                 signal: this.#shutdown.signal,
@@ -192,7 +196,7 @@ export class ClaustrumConsumer {
             });
             this.#assertOpen();
             const changed = roster?.view !== this.#roster?.view;
-            this.#roster = roster;
+            this.#roster = pendingVaultQuota(this.#options.rosterPath, roster);
             custody.retain(roster?.rows ?? []);
             // Each discovery replaces the previous value, including with unknown. A
             // refresh that served a peer's roster discovered nothing and leaves it;
@@ -348,7 +352,7 @@ export class ClaustrumConsumer {
             return undefined;
         try {
             await readClaustrumEnrollmentToken(this.#options.tokenPath);
-            const roster = await readVaultRoster(this.#options.rosterPath);
+            const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
             const row = roster?.rows.find((entry) => entry.routeId === routeId);
             return this.#normalizeInsulaQuota(row?.accountIdentity);
         }
@@ -356,6 +360,44 @@ export class ClaustrumConsumer {
             return undefined;
         }
     }
+    /** Cache-only background lookup, preserving the reason a route has no reading. */
+    async lookupInsulaQuotaForRoute(routeId) {
+        const options = this.#options.insula;
+        if (!options || this.#shutdown.signal.aborted || !(await this.#active()))
+            return { miss: 'unreachable' };
+        try {
+            await readClaustrumEnrollmentToken(this.#options.tokenPath);
+            const roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+            const account = roster?.rows.find((row) => row.routeId === routeId)?.accountIdentity;
+            if (!account || !this.#insula)
+                return { miss: 'unreachable' };
+            const result = this.#insula.source.lookup(options.provider, account, (this.#options.now ?? Date.now)());
+            const reading = result.reading &&
+                options.normalize(result.reading.entry, result.reading.context);
+            if (result.miss)
+                return { miss: result.miss, ...(reading !== undefined && { reading }) };
+            // Refusing an echo or unsupported window leaves the plugin's poll in charge.
+            return reading === undefined ? { miss: 'unreachable' } : { reading };
+        }
+        catch {
+            return { miss: 'unreachable' };
+        }
+    }
+    /** Skip the fallback poll while insula is cold or its upstream fetch failed. */
+    async pollInsulaQuotaForRoute(routeId, fallback) {
+        const result = await this.lookupInsulaQuotaForRoute(routeId);
+        if (result.miss === 'cold' || result.miss === 'upstream-failed') {
+            if (this.#insulaSkips.get(routeId) !== result.miss) {
+                this.#insulaSkips.set(routeId, result.miss);
+                this.#logger.warn('skipped insula provider poll', {
+                    reason: result.miss,
+                });
+            }
+            return undefined;
+        }
+        this.#insulaSkips.delete(routeId);
+        return result.miss ? fallback() : result.reading;
+    }
     #normalizeInsulaQuota(accountIdentity) {
         if (!this.#options.insula || !accountIdentity)
             return undefined;
@@ -380,7 +422,7 @@ export class ClaustrumConsumer {
             this.#insula = undefined;
             throw new ClaustrumConsumerError('not-active', 'Claustrum scoped custody is not active');
         }
-        const current = await readVaultRoster(this.#options.rosterPath);
+        const current = pendingVaultQuota(this.#options.rosterPath, 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);
@@ -472,13 +514,13 @@ export class ClaustrumConsumer {
     async decline(routeId) {
         this.#assertOpen();
         await declineVaultRoute(this.#options.rosterPath, routeId);
-        this.#roster = await readVaultRoster(this.#options.rosterPath);
+        this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
         this.#custody?.retain(this.#roster?.rows ?? []);
     }
     async accept(routeId) {
         this.#assertOpen();
         await acceptVaultRoute(this.#options.rosterPath, routeId);
-        this.#roster = await readVaultRoster(this.#options.rosterPath);
+        this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
     }
     /**
      * Store a quota or profile observation for a vault route. The receipt the
@@ -488,7 +530,7 @@ export class ClaustrumConsumer {
      */
     async recordQuota(routeId, observation, attempt) {
         this.#assertOpen();
-        const kept = await recordVaultQuota(this.#options.rosterPath, {
+        return recordVaultQuota(this.#options.rosterPath, {
             routeId,
             observation,
             credentialId: attempt.credentialId,
@@ -500,27 +542,21 @@ export class ClaustrumConsumer {
                 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.
+     * Memory updates immediately; durable publication is detached and coalesced.
      */
     async recordAccountQuota(routeId, accountIdentity, observation) {
         this.#assertOpen();
-        const kept = await recordVaultAccountQuota(this.#options.rosterPath, {
+        return recordVaultAccountQuota(this.#options.rosterPath, {
             routeId,
             accountIdentity,
             observation,
         });
-        if (kept)
-            this.#roster = await readVaultRoster(this.#options.rosterPath);
-        return kept;
     }
     close() {
         if (this.#shutdown.signal.aborted)
@@ -535,5 +571,12 @@ export class ClaustrumConsumer {
         this.#insula = undefined;
         this.#roster = undefined;
         this.#grantReach = undefined;
+        void this.#releaseQuotaWriter();
+        forgetPendingVaultDiscovery(this.#options.rosterPath);
+    }
+    /** Close immediately; the last consumer also waits for the writer's bounded drain. */
+    async dispose() {
+        this.close();
+        await this.#releaseQuotaWriter();
     }
 }

package/dist/common-auth-embedded/claustrum/index.d.ts

@@ -7,8 +7,9 @@ export { type AccountIdentitySource, type ClaustrumFamily, type ClaustrumRosterW
 export { type ClaustrumEnrollmentClient, type ClaustrumEnrollmentConnection, type ClaustrumEnrollmentDisconnectResult, ClaustrumEnrollmentManager, type ClaustrumEnrollmentPaths, type ClaustrumEnrollmentResetResult, type ClaustrumEnrollmentStatus, classifyEnrollmentError, connectClaustrumEnrollmentClient, disconnectClaustrumEnrollment, type EnrollmentDisposition, enrollmentAuthority, enrollmentName, getClaustrumEnrollmentPaths, hostEnrollmentPaths, RETRYABLE_ENROLLMENT_CODES, readClaustrumEnrollmentStatus, readClaustrumEnrollmentToken, resetClaustrumEnrollmentState, TERMINAL_ENROLLMENT_CODES, } from './enrollment.js';
 export { ClaustrumConsumerError, type ClaustrumConsumerFailureKind, type ClaustrumLogger, } from './errors.js';
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, type HostSlotContent, isCustodyPlaceholder, isCustodyPlaceholderValue, } from './host-slot.js';
-export { acquireInsulaQuotaSource, type InsulaQuotaContext, type InsulaQuotaOptions, type InsulaQuotaSource, type InsulaUsageEntry, type InsulaUsageTransport, type InsulaUsageWatch, type InsulaUsageWindow, type InsulaWatchOptions, } from './insula.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/common-auth-embedded/claustrum/index.js

@@ -14,6 +14,7 @@ export { ClaustrumConsumerError, } from './errors.js';
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, isCustodyPlaceholder, isCustodyPlaceholderValue, } from './host-slot.js';
 export { acquireInsulaQuotaSource, } from './insula.js';
 export { acceptAccount, declineAccount, isDeclined, } from './interlock.js';
+export { drainVaultQuota } from './quota-writer.js';
 export { acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, mutateVaultRoster, projectVaultRoster, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, vaultRoutingRows, } from './roster.js';
 export { ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, WATCH_RETRY_MS, } from './watch.js';
 /**

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

@@ -34,6 +34,27 @@ export interface InsulaQuotaContext {
     fetchedAt: number;
     source?: string;
 }
+export type InsulaQuotaMiss = 'cold' | 'stale' | 'absent' | 'upstream-failed' | 'credential' | 'unreachable';
+export interface InsulaQuotaReading {
+    entry: InsulaUsageEntry;
+    context: InsulaQuotaContext;
+}
+/** A miss may retain a dated reading; it is not a current quota observation. */
+export type InsulaQuotaLookup = {
+    reading: InsulaQuotaReading;
+    miss?: never;
+} | {
+    miss: InsulaQuotaMiss;
+    reading?: InsulaQuotaReading;
+};
+/** The normalized equivalent of a source lookup, for a plugin's quota type. */
+export type InsulaQuotaResult<Q> = {
+    reading: Q;
+    miss?: never;
+} | {
+    miss: InsulaQuotaMiss;
+    reading?: Q;
+};
 export interface InsulaQuotaOptions<Q> {
     provider: 'codex' | 'claude' | 'antigravity';
     /**
@@ -110,6 +131,8 @@ export declare class InsulaQuotaSource {
         entry: InsulaUsageEntry;
         context: InsulaQuotaContext;
     } | undefined;
+    /** Cache-only background lookup; current() retains its original miss behavior. */
+    lookup(provider: string, accountId: string, now: number): InsulaQuotaLookup;
 }
 export declare function acquireInsulaQuotaSource(transport: InsulaUsageTransport, tokenPath: string): {
     source: InsulaQuotaSource;

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

@@ -128,6 +128,9 @@ export function insulaUsageTransport(options) {
 }
 const MINUTE = 60_000;
 const MAX_AGE = 4 * MINUTE;
+// consumer-contract.md:331 refetches a slot after 60 s. Two such intervals
+// bound our willingness to wait, not a claim that insula completed its sweep.
+const COLD_WAIT = 2 * MINUTE;
 const sources = new Map();
 // Keep only the minute budget after the last owner closes, so project churn
 // cannot reset the bound. Expired budgets are pruned on the next tick.
@@ -170,6 +173,9 @@ export class InsulaQuotaSource {
     transport;
     key;
     #entries = [];
+    #available = false;
+    #completeProviders = new Set();
+    #coldSince = new Map();
     /** Every usage.get, polled or watch-driven, shares this one slot. */
     #reads = new CoalescedRead(async () => {
         try {
@@ -178,13 +184,25 @@ export class InsulaQuotaSource {
                 !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.
+            // Each response is a snapshot, not a delta. Only completeProviders
+            // asserts completeness; neither pending nor the entry count does.
             this.#entries = reply.result.filter((entry) => record(entry) && typeof entry.provider === 'string');
+            this.#available =
+                this.#entries.length === reply.result.length &&
+                    (reply.completeProviders === undefined ||
+                        (Array.isArray(reply.completeProviders) &&
+                            reply.completeProviders.every((value) => typeof value === 'string')));
+            this.#completeProviders = new Set(this.#available && Array.isArray(reply.completeProviders)
+                ? reply.completeProviders
+                : []);
+            for (const provider of this.#completeProviders)
+                this.#coldSince.delete(provider);
         }
         catch {
             // Refusal is absence, even if the previous reading was still young.
             this.#entries = [];
+            this.#available = false;
+            this.#completeProviders.clear();
         }
     }, () => { });
     #reader = new ChangeNoticeReader();
@@ -391,6 +409,50 @@ export class InsulaQuotaSource {
         }
         return undefined;
     }
+    /** Cache-only background lookup; current() retains its original miss behavior. */
+    lookup(provider, accountId, now) {
+        if (!this.#available)
+            return { miss: 'unreachable' };
+        const entry = this.#entries.find((value) => value.provider === provider &&
+            typeof value.account === 'string' &&
+            value.account.trim() === accountId);
+        // An unlabelled error describes the provider's credential path, not an
+        // unrelated labelled account. Never borrow another account's verdict.
+        const errorClass = (entry ??
+            this.#entries.find((value) => value.provider === provider &&
+                value.account === undefined &&
+                value.errorClass !== undefined))?.errorClass;
+        if (errorClass === 'upstream_failed')
+            return { miss: 'upstream-failed' };
+        if (errorClass === 'credential_absent' ||
+            errorClass === 'credential_unusable' ||
+            errorClass === 'credential_rejected')
+            return { miss: 'credential' };
+        if (errorClass !== undefined)
+            return { miss: 'unreachable' };
+        if (entry) {
+            const fetchedAt = typeof entry.fetchedAt === 'string'
+                ? Date.parse(entry.fetchedAt)
+                : Number.NaN;
+            if (!record(entry.usage) || !Number.isFinite(fetchedAt))
+                return { miss: 'unreachable' };
+            const reading = {
+                entry,
+                context: {
+                    fetchedAt,
+                    ...(typeof entry.source === 'string' && { source: entry.source }),
+                },
+            };
+            return now >= fetchedAt + MAX_AGE || entry.stale !== undefined
+                ? { miss: 'stale', reading }
+                : { reading };
+        }
+        if (this.#completeProviders.has(provider))
+            return { miss: 'absent' };
+        const since = this.#coldSince.get(provider) ?? now;
+        this.#coldSince.set(provider, since);
+        return { miss: now - since >= COLD_WAIT ? 'unreachable' : 'cold' };
+    }
 }
 export function acquireInsulaQuotaSource(transport, tokenPath) {
     const key = JSON.stringify([

package/dist/common-auth-embedded/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 {};