@cortexkit/antigravity-auth-core 3.0.19 → 3.0.21

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

@@ -50,6 +50,12 @@ export interface ClaustrumConsumerOptions<Q = QuotaObservation> {
      * routine token refresh, which never moves the view.
      */
     onRoster?: (roster: VaultRosterFile) => void;
+    /**
+     * Called once when a coalesced discovery starts, with its completion promise.
+     * Covers explicit refresh, poll, watch and send-triggered discovery, even when
+     * the view does not change. Observe rejection when attaching async work.
+     */
+    onDiscovery?: (promise: Promise<VaultRosterFile | undefined>) => void;
     onError?: (error: unknown) => void;
     /**
      * How often `start()` ticks. A tick lists the vault when no vault watch is
@@ -104,6 +110,8 @@ export interface HubMemberPort {
     keptReceiptState(): KeptReceiptState;
     /** Apply the union of every member's roster in memory to kept receipts. */
     retainUnion(): void;
+    /** Share a committed preference change with live members using this roster file. */
+    publishRoster(roster: VaultRosterFile): void;
     forget(credentialId: string): void;
     /** The member closed: the hub stops committing and pushing to it. */
     detach(): void;
@@ -113,6 +121,8 @@ export interface HubRefreshOutcome {
 }
 /** What the hub may do to one member's memory. Package-internal. */
 export interface HubMemberHooks {
+    /** Observe a hub discovery without relying on member refresh overrides. */
+    discovery(promise: Promise<HubRefreshOutcome | undefined>): void;
     /**
      * Set the roster in memory as a consumer's own refresh does (pending quota
      * readings included) and notify `onRoster` when its view changed.

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

@@ -314,8 +314,17 @@ export class ClaustrumConsumer {
             this.#refreshing = undefined;
         });
         this.#track(this.#refreshing);
+        this.#notifyDiscovery(this.#refreshing);
         return this.#refreshing;
     }
+    #notifyDiscovery(promise) {
+        try {
+            this.#options.onDiscovery?.(promise);
+        }
+        catch (error) {
+            this.#options.onError?.(error);
+        }
+    }
     /**
      * Poll in the background and open the vault and insula watches. Until the
      * vault watch is accepted, and whenever it is unavailable, every tick lists
@@ -571,6 +580,13 @@ export class ClaustrumConsumer {
     /** The hub's handle on this member's memory. */
     #hubHooks() {
         return {
+            discovery: (promise) => {
+                const hub = this.#hub;
+                if (!hub || !this.#options.onDiscovery || this.#shutdown.signal.aborted)
+                    return;
+                const discovery = this.#track(promise.then((outcome) => this.#hubOutcome(hub, outcome)));
+                this.#notifyDiscovery(discovery);
+            },
             install: (roster) => {
                 if (this.#shutdown.signal.aborted)
                     return;
@@ -607,6 +623,9 @@ export class ClaustrumConsumer {
      */
     async #hubRefresh(hub) {
         const outcome = await hub.refresh();
+        return this.#hubOutcome(hub, outcome);
+    }
+    #hubOutcome(hub, outcome) {
         this.#assertOpen();
         if (!outcome)
             return undefined;
@@ -788,6 +807,8 @@ export class ClaustrumConsumer {
         this.#assertOpen();
         await declineVaultRoute(this.#options.rosterPath, routeId);
         this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+        if (this.#roster)
+            this.#hub?.publishRoster(this.#roster);
         // A hub member shares kept receipts with every other member, so they are
         // retained against all members' rosters, never against this one alone.
         if (this.#hub)
@@ -799,6 +820,8 @@ export class ClaustrumConsumer {
         this.#assertOpen();
         await acceptVaultRoute(this.#options.rosterPath, routeId);
         this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+        if (this.#roster)
+            this.#hub?.publishRoster(this.#roster);
     }
     /**
      * Set the order vault accounts are tried in (`reorderVaultRoster`), then
@@ -809,6 +832,8 @@ export class ClaustrumConsumer {
         this.#assertOpen();
         const result = await reorderVaultRoster(this.#options.rosterPath, routeIds);
         this.#roster = pendingVaultQuota(this.#options.rosterPath, await readVaultRoster(this.#options.rosterPath));
+        if (this.#roster)
+            this.#hub?.publishRoster(this.#roster);
         return result;
     }
     /**

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

@@ -25,7 +25,8 @@ export interface ClaustrumFamily {
 /** Non-secret classification facts, including rows decoded by older clients. */
 export interface VaultRowFacts {
     readonly credentialId: string;
-    readonly credentialType: string;
+    /** Internal serving type derived from `authMethod`, not the id's type hint. */
+    readonly credentialType: VaultCredentialType;
     readonly authMethod?: string;
     readonly refreshAdapter?: string;
     readonly providerIds?: readonly string[];
@@ -108,7 +109,10 @@ export interface VaultInventory {
     readonly view: string;
     readonly credentials: readonly VaultCredential[];
     readonly skipped: readonly SkippedVaultRecord[];
-    /** Classifying families only: fixed refusal codes, never classifier errors. */
+    /**
+     * Classifying families only: declared policy codes or the fixed library codes
+     * `unknown-auth-method`, `unmapped` and `unclassified`, never classifier errors.
+     */
     readonly refused?: readonly {
         credentialId?: string;
         code: string;

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

@@ -1,3 +1,4 @@
+import { channel } from 'node:diagnostics_channel';
 import { ClaustrumCredentialError, } from '@cortexkit/claustrum-client';
 import { createLogger } from '../logger/index.js';
 import { ClaustrumUnreachableError, classifyVaultFailure, } from './availability.js';
@@ -27,6 +28,8 @@ function scopedRetryReason(served, current) {
     return 'rotated';
 }
 const defaultLogger = createLogger('claustrum');
+// Opt-in diagnostics let tests retain wait phases without logging each vault read.
+const phaseDiagnostics = channel('common-auth.claustrum.phases');
 /**
  * Decide whether a request that got a 401 should retry with the freshly
  * re-authorized receipt, and log the decision. The vault can refresh a
@@ -85,16 +88,28 @@ function credentialTypeOf(row, family) {
         return notMine;
     if (!row.categories.includes(family.category))
         return notMine;
-    if (row.credentialType !== 'oauth' && row.credentialType !== 'api_key')
-        return notMine;
     if ('classify' in family) {
-        // Older clients omit these facts entirely; do not call a policy that needs them.
+        const metadata = rowFactsOf(row);
+        let type;
+        // The id's type is only a hint; the vault's auth method determines serving.
+        switch (metadata.authMethod) {
+            case 'apikey':
+                type = 'api_key';
+                break;
+            case 'chatgpt':
+            case 'antigravity':
+            case 'oauth':
+                type = 'oauth';
+                break;
+            default:
+                return { kind: 'refused', code: 'unknown-auth-method' };
+        }
         const facts = {
             credentialId: row.id,
-            credentialType: row.credentialType,
+            credentialType: type,
             categories: row.categories,
             refreshAdapter: row.refreshAdapter,
-            ...rowFactsOf(row),
+            ...metadata,
         };
         if (facts.providerIds === undefined)
             return { kind: 'refused', code: 'unmapped' };
@@ -103,7 +118,7 @@ function credentialTypeOf(row, family) {
             if (result.kind === 'not-mine')
                 return notMine;
             if (result.kind === 'mine' && typeof result.member === 'string')
-                return { kind: 'mine', type: row.credentialType, member: result.member };
+                return { kind: 'mine', type, member: result.member };
             if (result.kind === 'refused' &&
                 typeof result.code === 'string' &&
                 /^[a-z][a-z0-9-]{0,31}$/.test(result.code) &&
@@ -116,6 +131,8 @@ function credentialTypeOf(row, family) {
         }
         return { kind: 'refused', code: 'unclassified' };
     }
+    if (row.credentialType !== 'oauth' && row.credentialType !== 'api_key')
+        return notMine;
     if (row.credentialType === 'oauth')
         return row.refreshAdapter === family.refreshAdapter
             ? { kind: 'mine', type: 'oauth' }
@@ -266,6 +283,11 @@ export class ClaustrumScopedCustody {
     }
     async #token(signal) {
         this.#check(signal);
+        if (phaseDiagnostics.hasSubscribers)
+            phaseDiagnostics.publish({
+                logger: this.#logger,
+                phase: 'token read begin',
+            });
         const pending = this.#readToken();
         this.#tokenReads.add(pending);
         let value;
@@ -274,6 +296,11 @@ export class ClaustrumScopedCustody {
         }
         finally {
             this.#tokenReads.delete(pending);
+            if (phaseDiagnostics.hasSubscribers)
+                phaseDiagnostics.publish({
+                    logger: this.#logger,
+                    phase: 'token read end',
+                });
         }
         this.#check(signal);
         if (!/^[0-9a-f]{64}$/.test(value.token) ||
@@ -345,6 +372,11 @@ export class ClaustrumScopedCustody {
             this.#kept.clear();
             throw error;
         }
+        if (phaseDiagnostics.hasSubscribers)
+            phaseDiagnostics.publish({
+                logger: this.#logger,
+                phase: 'list scoped begin',
+            });
         try {
             inventory = await this.#call(() => this.#client.listScoped(token), signal);
         }
@@ -352,6 +384,13 @@ export class ClaustrumScopedCustody {
             this.listFailed(error);
             throw error;
         }
+        finally {
+            if (phaseDiagnostics.hasSubscribers)
+                phaseDiagnostics.publish({
+                    logger: this.#logger,
+                    phase: 'list scoped end',
+                });
+        }
         const skipped = [];
         const refused = [];
         let notMine = 0;

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

@@ -1,5 +1,5 @@
 import type { QuotaObservation } from '../quota/index.js';
-import { type ClaustrumConsumer } from './consumer.js';
+import { type ClaustrumConsumer, type ClaustrumConsumerOptions } from './consumer.js';
 import { type ClassifyingClaustrumFamily, type ClaustrumScopedClient, ClaustrumScopedCustody, type IdentityParser, type KeptReceiptState, type VaultGrantReach } from './custody.js';
 import { type ClaustrumLogger } from './errors.js';
 import { type AccountMapper, type VaultRosterFile } from './roster.js';
@@ -100,6 +100,8 @@ export interface ClaustrumHubMemberOptions<_Q = QuotaObservation> {
     reservedRouteIds?: () => Iterable<string>;
     /** As `ClaustrumConsumerOptions.onRoster`: once per change of view. */
     onRoster?: (roster: VaultRosterFile) => void;
+    /** Observe every hub discovery's member result, including background work. */
+    onDiscovery?: ClaustrumConsumerOptions<_Q>['onDiscovery'];
     /** This member's own failures, such as a roster commit that failed. */
     onError?: (error: unknown) => void;
     logger?: ClaustrumLogger;

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

@@ -11,8 +11,9 @@
 // different processes already share, plus the base-view rule, so a commit
 // never replaces a view another process committed after this hub listed.
 import { createHash } from 'node:crypto';
+import { channel } from 'node:diagnostics_channel';
 import { readdir, stat } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { createLogger } from '../logger/index.js';
 import { combineAbortSignals } from '../util/any-signal.js';
 import { ClaustrumUnreachableError } from './availability.js';
@@ -23,6 +24,8 @@ import { ClaustrumConsumerError } from './errors.js';
 import { DEFAULT_ROUTE_PREFIX, decodedVaultRoster, forgetPendingVaultDiscovery, isVaultRosterLockRefusal, readVaultRoster, refreshVaultRoster, vaultRosterSeed, } from './roster.js';
 import { drainShutdown, shutdownWarning } from './shutdown.js';
 import { SAFETY_POLL_MS } from './watch.js';
+/** Published rosters are shared only in memory; file locks still order commits. */
+const sharedRosters = new Map();
 /** Lowercase ASCII, safe as a file name on every OS. */
 const FILE_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 /** Device names Windows reserves in every directory, with any extension. */
@@ -250,9 +253,11 @@ export class ClaustrumDiscoveryHub {
             watchMode: () => this.watchState(),
             keptReceiptState: () => this.keptReceiptState(),
             retainUnion: () => this.#retainUnion(),
+            publishRoster: (roster) => this.#publishRoster(entry, roster),
             forget: (credentialId) => this.#current?.custody?.forget(credentialId),
             detach: () => {
                 entry.closed = true;
+                entry.releaseRoster?.();
             },
         };
         const consumerOptions = {
@@ -265,14 +270,58 @@ export class ClaustrumDiscoveryHub {
             }),
             ...(this.#options.mapAccount && { mapAccount: this.#options.mapAccount }),
             ...(options.onRoster && { onRoster: options.onRoster }),
+            ...(options.onDiscovery && { onDiscovery: options.onDiscovery }),
             ...(options.onError && { onError: options.onError }),
             logger: options.logger ?? this.#logger,
             ...(this.#options.now && { now: this.#options.now }),
         };
         const { consumer, hooks } = createHubMember(port, consumerOptions);
         entry.hooks = hooks;
+        const path = resolve(entry.path);
+        const subscribers = sharedRosters.get(path) ?? new Set();
+        const install = (roster) => {
+            // A peer cannot reactivate an off or closed member, or install routes
+            // that collide with this plugin instance's local pool.
+            if (entry.closed ||
+                this.#active !== true ||
+                !this.#current ||
+                !this.#live(this.#current) ||
+                !hooks.roster() ||
+                this.#collides(hooks, roster))
+                return;
+            entry.seen = JSON.stringify(decodedVaultRoster(roster));
+            hooks.install(roster);
+            if (roster.view !== this.#committed?.view)
+                entry.pending ??= { failures: 0, wait: 0 };
+            this.#retainUnion();
+        };
+        subscribers.add(install);
+        entry.receiveRoster = install;
+        sharedRosters.set(path, subscribers);
+        let subscribed = true;
+        entry.releaseRoster = () => {
+            if (!subscribed)
+                return;
+            subscribed = false;
+            subscribers.delete(install);
+            if (!subscribers.size)
+                sharedRosters.delete(path);
+        };
         return consumer;
     }
+    #publishRoster(entry, roster) {
+        const generation = this.#current;
+        if (entry.closed || !generation || !this.#live(generation))
+            return;
+        entry.seen = JSON.stringify(decodedVaultRoster(roster));
+        entry.hooks?.install(roster);
+        for (const install of sharedRosters.get(resolve(entry.path)) ?? []) {
+            if (!this.#live(generation))
+                return;
+            if (install !== entry.receiveRoster)
+                install(roster);
+        }
+    }
     // --- leases ---
     #startGeneration() {
         const generation = {
@@ -582,6 +631,8 @@ export class ClaustrumDiscoveryHub {
         }));
         run.promise = promise;
         this.#run = run;
+        for (const entry of this.#open())
+            entry.hooks?.discovery(promise);
         return promise;
     }
     /**
@@ -681,9 +732,7 @@ export class ClaustrumDiscoveryHub {
                 continue;
             }
             // The push: memory holds the committed roster before refresh resolves.
-            entry.seen = JSON.stringify(decodedVaultRoster(roster));
-            if (!entry.closed)
-                hooks.install(roster);
+            this.#publishRoster(entry, roster);
         }
         if (!this.#live(generation))
             return undefined;
@@ -718,7 +767,25 @@ export class ClaustrumDiscoveryHub {
                 throw base;
             // A member's first roster under this key carries the declines and
             // order of its newest roster under an older key.
-            const seed = base.file ? undefined : await this.#seed(entry);
+            let seed;
+            if (!base.file) {
+                const phaseDiagnostics = channel('common-auth.claustrum.phases');
+                if (phaseDiagnostics.hasSubscribers)
+                    phaseDiagnostics.publish({
+                        logger: this.#logger,
+                        phase: `seed read ${entry.provider} begin`,
+                    });
+                try {
+                    seed = await this.#seed(entry);
+                }
+                finally {
+                    if (phaseDiagnostics.hasSubscribers)
+                        phaseDiagnostics.publish({
+                            logger: this.#logger,
+                            phase: `seed read ${entry.provider} end`,
+                        });
+                }
+            }
             const roster = await refreshVaultRoster({
                 path: entry.path,
                 custody: { discover: async () => share },
@@ -850,7 +917,7 @@ export class ClaustrumDiscoveryHub {
             }
             const before = enabledRows(memory);
             entry.seen = content;
-            hooks.install(file);
+            this.#publishRoster(entry, file);
             if (enabledRows(hooks.roster()) !== before)
                 this.#retainUnion();
         }
@@ -1013,6 +1080,8 @@ export class ClaustrumDiscoveryHub {
         if (this.#shutdown.signal.aborted)
             return;
         this.#shutdown.abort(closed('Claustrum discovery hub is closed'));
+        for (const entry of this.#members.values())
+            entry.releaseRoster?.();
         if (this.#timer)
             (this.#options.clearTimeoutImpl ?? clearTimeout)(this.#timer);
         this.#timer = undefined;

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

@@ -443,6 +443,12 @@ export class InsulaQuotaSource {
                     ...(typeof entry.source === 'string' && { source: entry.source }),
                 },
             };
+            // Kept usage must not trigger a provider poll after a non-local failure.
+            // Only an explicitly local failure permits fallback; unknown causes do not.
+            if (entry.stale !== undefined &&
+                (!record(entry.stale) ||
+                    entry.stale.class !== 'local_source_unavailable'))
+                return { miss: 'upstream-failed', reading };
             return now >= fetchedAt + MAX_AGE || entry.stale !== undefined
                 ? { miss: 'stale', reading }
                 : { reading };

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

@@ -810,7 +810,7 @@ export async function refreshVaultRoster(options) {
         throw error;
     }
     finally {
-        await lease.release();
+        await lease.release(options.signal);
     }
 }
 /**

package/dist/common-auth-embedded/fs/refresh-file-lock.d.ts

@@ -21,7 +21,8 @@ export interface LockLoss {
 export interface RefreshFileLock {
     readonly ownerId: string;
     assertOwned(): Promise<void>;
-    release(): Promise<void>;
+    /** Abort stops release retries; the unrenewed lease is left to expire by TTL. */
+    release(signal?: AbortSignal): Promise<void>;
     /** Resolves once on detected loss; remains pending after an owner's release. */
     whenLost(): Promise<LockLoss>;
     hasLost(): boolean;

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

@@ -836,7 +836,7 @@ export async function acquireRefreshFileLockWithClock(options) {
                     : {}),
             });
         },
-        release: async () => {
+        release: async (signal) => {
             if (windowsPrivateFiles && releaseConfirmed)
                 return;
             released = true;
@@ -882,6 +882,8 @@ export async function acquireRefreshFileLockWithClock(options) {
                         releaseConfirmed = removalConfirmed;
                         return;
                     }
+                    if (signal?.aborted)
+                        return;
                     await recoverStaleEvictionMarker();
                 }
                 catch (error) {

package/dist/common-auth-embedded/fs/with-lock.js

@@ -38,7 +38,7 @@ export async function withLock(target, options, fn) {
                 return await fn(lock);
             }
             finally {
-                await lock.release();
+                await lock.release(options.signal);
             }
         }
         const remaining = options.timeoutMs - (performance.now() - started);

package/dist/common-auth-embedded/source-output.json

@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "package": "@cortexkit/common-auth",
-  "version": "0.29.0",
+  "version": "0.32.1",
   "artifactStatus": "published",
   "publicRoots": {
     "./store": {
@@ -37,15 +37,15 @@
       "import": "./dist/pi-slot/index.js"
     }
   },
-  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.29.0.tgz",
-  "tarballSha256": "6d8795d0672353ab897f938cad86c63556ceab7704bd60498a8c8e1a62dbc207",
-  "sri": "sha512-XnNFY5ppNQRDP09lUTDDONGHwiJ8Z93w8/NP16pmWpC6lzBPkC7XJcHhld+B6iLATaNvbcenfhecitB8fS9nbQ==",
+  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.32.1.tgz",
+  "tarballSha256": "d25d2eb670bc5ac48e75bf31cd633bb8b56fd807bf4467d69dbf62a00e1e6717",
+  "sri": "sha512-Y3SmHTnkDjdvo8d6MsQTVr+GlR3q6Ro8HYDqEFuotSUbrv8GwJvjRkYraN8ahEAT8uRHFmfyWGuogfYLzz65DA==",
   "canonicalFiles": 147,
-  "canonicalBytes": 994153,
+  "canonicalBytes": 1000963,
   "generator": {
     "path": "packages/opencode/scripts/embed-common-auth.ts",
-    "version": 3,
-    "sha256": "ece06fd4117208e4b276fee17386d3a0f93e641cee49c0d30d985c169c551ad2"
+    "version": 4,
+    "sha256": "d0920ba672e4d2a4ab37cd827d0a8098e9253d23678b88d051750373787af65d"
   },
   "files": [
     {
@@ -227,33 +227,33 @@
     {
       "source": "package/dist/claustrum/consumer.d.ts",
       "output": "claustrum/consumer.d.ts",
-      "bytes": 13309,
-      "sourceSha256": "a33f8fb2750424f1dd1e80ee6e0f260d4d5b6bdf6be3b00b2ae503bfbadb4d17",
-      "outputSha256": "a33f8fb2750424f1dd1e80ee6e0f260d4d5b6bdf6be3b00b2ae503bfbadb4d17",
+      "bytes": 13934,
+      "sourceSha256": "97e5fb096153912483b45f75831e4652db19457d94ad76ba8363b1fd232e6fd7",
+      "outputSha256": "97e5fb096153912483b45f75831e4652db19457d94ad76ba8363b1fd232e6fd7",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/consumer.js",
       "output": "claustrum/consumer.js",
-      "bytes": 38516,
-      "sourceSha256": "46a8be88c8e5270d06bda0042235d7081dea06eaf1ae15f9a5fdf2ed93e478fd",
-      "outputSha256": "46a8be88c8e5270d06bda0042235d7081dea06eaf1ae15f9a5fdf2ed93e478fd",
+      "bytes": 39439,
+      "sourceSha256": "3b4cf06be8732f3183ac97721dfffb8fc489d4be1044260742a72a9995324391",
+      "outputSha256": "3b4cf06be8732f3183ac97721dfffb8fc489d4be1044260742a72a9995324391",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.d.ts",
       "output": "claustrum/custody.d.ts",
-      "bytes": 16192,
-      "sourceSha256": "ac8a3f2a47ec04ba0b6b5f69425db6672aa7660cd9249853f05fb2b4669698c2",
-      "outputSha256": "ac8a3f2a47ec04ba0b6b5f69425db6672aa7660cd9249853f05fb2b4669698c2",
+      "bytes": 16390,
+      "sourceSha256": "3bbbfc2d700cf6c25356339c64d3bef5cee5e00336d141de18bb7522c8a5ceaa",
+      "outputSha256": "3bbbfc2d700cf6c25356339c64d3bef5cee5e00336d141de18bb7522c8a5ceaa",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.js",
       "output": "claustrum/custody.js",
-      "bytes": 30242,
-      "sourceSha256": "cfa9c256d59ac4740f5b88fc1662a3bbb29078973cbeaf6225448c305fa580a2",
-      "outputSha256": "cfa9c256d59ac4740f5b88fc1662a3bbb29078973cbeaf6225448c305fa580a2",
+      "bytes": 31616,
+      "sourceSha256": "5ed70e65b78a04ceec3b3430908f46c860ea768b779b6af0f925681fd786593d",
+      "outputSha256": "5ed70e65b78a04ceec3b3430908f46c860ea768b779b6af0f925681fd786593d",
       "transform": "verbatim"
     },
     {
@@ -307,17 +307,17 @@
     {
       "source": "package/dist/claustrum/hub.d.ts",
       "output": "claustrum/hub.d.ts",
-      "bytes": 9169,
-      "sourceSha256": "07a5c385738649ec5c03b6afb7a916011e565c9f9d5463b280b9896024d8f0c0",
-      "outputSha256": "07a5c385738649ec5c03b6afb7a916011e565c9f9d5463b280b9896024d8f0c0",
+      "bytes": 9346,
+      "sourceSha256": "4c2cbd91b3cc9691ee765f766b7c80d27cf28b38494a0a53ce9410c184e7ca1d",
+      "outputSha256": "4c2cbd91b3cc9691ee765f766b7c80d27cf28b38494a0a53ce9410c184e7ca1d",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/hub.js",
       "output": "claustrum/hub.js",
-      "bytes": 43086,
-      "sourceSha256": "f156151cba0a628828a9c28cdeea757a4c959e4398a79c423001b2b2857c2ec7",
-      "outputSha256": "f156151cba0a628828a9c28cdeea757a4c959e4398a79c423001b2b2857c2ec7",
+      "bytes": 45993,
+      "sourceSha256": "e50ebf6bcf840f8a4229d219ecb20fc1422c74b5b3aa2034dff0b73852380b79",
+      "outputSha256": "e50ebf6bcf840f8a4229d219ecb20fc1422c74b5b3aa2034dff0b73852380b79",
       "transform": "verbatim"
     },
     {
@@ -347,9 +347,9 @@
     {
       "source": "package/dist/claustrum/insula.js",
       "output": "claustrum/insula.js",
-      "bytes": 19744,
-      "sourceSha256": "506b549f26a741599bfee04bf334cf7b29fde4077a79f65bc2dad78e03bafee0",
-      "outputSha256": "506b549f26a741599bfee04bf334cf7b29fde4077a79f65bc2dad78e03bafee0",
+      "bytes": 20137,
+      "sourceSha256": "e2a2625cdad490cf24aa0badf66c842becd806738f8b137ebcf2b01e296eb0d2",
+      "outputSha256": "e2a2625cdad490cf24aa0badf66c842becd806738f8b137ebcf2b01e296eb0d2",
       "transform": "verbatim"
     },
     {
@@ -395,9 +395,9 @@
     {
       "source": "package/dist/claustrum/roster.js",
       "output": "claustrum/roster.js",
-      "bytes": 39326,
-      "sourceSha256": "f46fc75edcf4e418f02a5699c7395f1f44abd2e28b77067b89f7622af5890214",
-      "outputSha256": "f46fc75edcf4e418f02a5699c7395f1f44abd2e28b77067b89f7622af5890214",
+      "bytes": 39340,
+      "sourceSha256": "6919aa948f9022f76ce2b7aac83733bd7a11a8c21b8511191cf7fbf6bc1a2b30",
+      "outputSha256": "6919aa948f9022f76ce2b7aac83733bd7a11a8c21b8511191cf7fbf6bc1a2b30",
       "transform": "verbatim"
     },
     {
@@ -595,17 +595,17 @@
     {
       "source": "package/dist/fs/refresh-file-lock.d.ts",
       "output": "fs/refresh-file-lock.d.ts",
-      "bytes": 2946,
-      "sourceSha256": "b649e67813eb4086ca5642c99d318f90ccccae9702b23ad8fb0616f8d62f5a06",
-      "outputSha256": "b649e67813eb4086ca5642c99d318f90ccccae9702b23ad8fb0616f8d62f5a06",
+      "bytes": 3052,
+      "sourceSha256": "31c23ba9135ddc57ea0196ad56280bd12eab2c9524d33bd43d78112da27214d2",
+      "outputSha256": "31c23ba9135ddc57ea0196ad56280bd12eab2c9524d33bd43d78112da27214d2",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/refresh-file-lock.js",
       "output": "fs/refresh-file-lock.js",
-      "bytes": 37753,
-      "sourceSha256": "38bc20ae71a195818f9cf7e42954e8305f92a55ff15dd855da33ccdec6b34fa1",
-      "outputSha256": "38bc20ae71a195818f9cf7e42954e8305f92a55ff15dd855da33ccdec6b34fa1",
+      "bytes": 37832,
+      "sourceSha256": "07b261b409c5c6cc9b35cb732df44486d372413ce6ae078be4b211b9b5a5c1c7",
+      "outputSha256": "07b261b409c5c6cc9b35cb732df44486d372413ce6ae078be4b211b9b5a5c1c7",
       "transform": "verbatim"
     },
     {
@@ -619,9 +619,9 @@
     {
       "source": "package/dist/fs/with-lock.js",
       "output": "fs/with-lock.js",
-      "bytes": 1789,
-      "sourceSha256": "94fa839ec83d730280048f7e586453daadc590c4fbcf5601fd96f4a2d4193d6b",
-      "outputSha256": "94fa839ec83d730280048f7e586453daadc590c4fbcf5601fd96f4a2d4193d6b",
+      "bytes": 1803,
+      "sourceSha256": "f31ff1935e18563e465ab235202de3932255d3b1fc72b5d0baf6d3502931fc8e",
+      "outputSha256": "f31ff1935e18563e465ab235202de3932255d3b1fc72b5d0baf6d3502931fc8e",
       "transform": "verbatim"
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/antigravity-auth-core",
-  "version": "3.0.19",
+  "version": "3.0.21",
   "description": "Harness-agnostic core for Google Antigravity OAuth: transport, fingerprint, request transforms, accounts, quota",
   "type": "module",
   "license": "MIT",