@cortexkit/antigravity-auth-core 3.0.12 → 3.0.13

package/dist/common-auth-embedded/fs/file-read-cache.js

@@ -0,0 +1,57 @@
+import { lstat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+async function identity(path) {
+    try {
+        const metadata = await lstat(path);
+        // Do not follow a symlink: its target can change without changing the link.
+        return metadata.isFile() ? metadata : undefined;
+    }
+    catch (error) {
+        return error.code === 'ENOENT'
+            ? 'absent'
+            : undefined;
+    }
+}
+function sameIdentity(left, right) {
+    if (left === 'absent' || right === 'absent')
+        return left === right;
+    return (left.dev === right.dev &&
+        left.ino === right.ino &&
+        left.size === right.size &&
+        left.mtimeMs === right.mtimeMs &&
+        left.ctimeMs === right.ctimeMs);
+}
+/** Process-local reads, capped at 64 path sets with one value per resolved set. */
+export class FileReadCache {
+    #entries = new Map();
+    async read(paths, read, validateHit) {
+        const resolvedPaths = paths.map((path) => resolve(path));
+        const key = JSON.stringify(resolvedPaths);
+        const probed = await Promise.all(resolvedPaths.map(identity));
+        const identities = probed.every((entry) => entry !== undefined)
+            ? probed
+            : undefined;
+        const cached = this.#entries.get(key);
+        if (identities &&
+            cached &&
+            identities.every((entry, index) => {
+                const previous = cached.identities[index];
+                return previous !== undefined && sameIdentity(entry, previous);
+            })) {
+            validateHit?.(identities);
+            return cached.value;
+        }
+        // A failed probe or read must not leave a previous successful value reusable.
+        this.#entries.delete(key);
+        const value = await read(resolvedPaths);
+        if (identities) {
+            if (this.#entries.size >= 64) {
+                const oldest = this.#entries.keys().next().value;
+                if (oldest !== undefined)
+                    this.#entries.delete(oldest);
+            }
+            this.#entries.set(key, { identities, value });
+        }
+        return value;
+    }
+}

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

@@ -28,7 +28,7 @@ type RefreshFileLockOptions = {
     onContended?: () => void;
     /** Synchronous, never awaited; throws and returned promise/thenable rejections are isolated. */
     onRenewalTimer?: (event: 'scheduled' | 'cancelled') => void;
-    onStep?: (step: 'stale-marker-stat' | 'stale-marker-claimed' | 'stale-lock-observed' | 'lock-read-ready' | 'lock-missing' | 'stale-lock-confirmed' | 'stale-lock-removed' | 'stale-lock-recreated' | 'eviction-marker-acquired' | 'renewal-owner-confirmed' | 'renewal-marker-unavailable' | 'renewal-write-fenced' | 'renewal-write-ready' | 'renewal-write-finished' | 'relinquish-read' | 'renewal-finished' | 'release-owner-confirmed') => void | Promise<void>;
+    onStep?: (step: 'stale-marker-stat' | 'stale-marker-claimed' | 'stale-lock-observed' | 'lease-contention-read-ready' | 'lock-read-ready' | 'lock-missing' | 'stale-lock-confirmed' | 'stale-lock-removed' | 'stale-lock-recreated' | 'eviction-marker-acquired' | 'renewal-owner-confirmed' | 'renewal-marker-unavailable' | 'renewal-write-fenced' | 'renewal-write-ready' | 'renewal-write-finished' | 'relinquish-read' | 'renewal-finished' | 'release-owner-confirmed') => void | Promise<void>;
 };
 /** Filesystem leases share wall time across all callers and processes. */
 export declare function acquireRefreshFileLock(options: RefreshFileLockOptions): Promise<RefreshFileLock | null>;

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

@@ -178,19 +178,28 @@ export async function acquireRefreshFileLockWithClock(options) {
     }
     async function leaseContention(error) {
         const code = error.code;
-        if (code === 'EEXIST') {
-            if (windowsPrivateFiles)
-                await readOwner();
-            return true;
-        }
-        if (code === 'EISDIR') {
-            if (windowsPrivateFiles) {
-                await verifyPrivate(lockPath, 'directory', true);
-                await readPrivateText(legacyOwnerPath, true);
+        if (code !== 'EEXIST' && code !== 'EISDIR')
+            return false;
+        if (windowsPrivateFiles) {
+            if (options.onStep)
+                await options.onStep('lease-contention-read-ready');
+            try {
+                if (code === 'EISDIR') {
+                    await verifyPrivate(lockPath, 'directory', true);
+                    await readPrivateText(legacyOwnerPath, true);
+                }
+                else
+                    await readOwner();
+            }
+            catch (readError) {
+                // The holder can release after exclusive creation reports a collision.
+                // Only absence permits another acquisition attempt; security and sharing
+                // refusals must still escape rather than being treated as contention.
+                if (readError.code !== 'ENOENT')
+                    throw readError;
             }
-            return true;
         }
-        return false;
+        return true;
     }
     async function tryAcquire() {
         if (windowsPrivateFiles)

package/dist/common-auth-embedded/quota/commit-interval.d.ts

@@ -0,0 +1,9 @@
+export declare const QUOTA_COMMIT_INTERVAL_MS = 30000;
+export interface QuotaCommitTimer {
+    now(): number;
+    schedule(delayMs: number, run: () => Promise<void>): {
+        cancel(): void;
+        unref?(): void;
+    };
+}
+export declare const quotaCommitTimer: QuotaCommitTimer;

package/dist/common-auth-embedded/quota/commit-interval.js

@@ -0,0 +1,18 @@
+// Atomic quota commits create locks, markers and a renamed temp file. Keep
+// those filesystem events at least 30 s apart under normal load; routing sees
+// pending readings immediately, while other processes may lag by one interval.
+// Shutdown drains and a full bounded pool queue can commit sooner.
+// The vault shares one gate per resolved path; each pool handle has its own.
+// N pool handles on one file can therefore make N normal commits per interval
+// in one process. These gates do not coordinate with other processes.
+export const QUOTA_COMMIT_INTERVAL_MS = 30_000;
+export const quotaCommitTimer = {
+    now: () => performance.now(),
+    schedule(delayMs, run) {
+        const timer = setTimeout(() => void run(), delayMs);
+        return {
+            cancel: () => clearTimeout(timer),
+            unref: () => timer.unref?.(),
+        };
+    },
+};

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

@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "package": "@cortexkit/common-auth",
-  "version": "0.26.0",
+  "version": "0.27.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.26.0.tgz",
-  "tarballSha256": "a5a6cb7051ee8c45e86e19cf7a918d0e28ce1b6a80301e982efbc7bb4b98208d",
-  "sri": "sha512-qTmQ9aMG+HcyDbhKie8Nq9wxKMRQ6GXH2hKq8Fab9kHqFfzswdp2NpXofGY52RhQ2VxuyMOQr5T6lUrkbny5VQ==",
-  "canonicalFiles": 141,
-  "canonicalBytes": 888503,
+  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.27.1.tgz",
+  "tarballSha256": "a74507a1f746c9d591501ab24a630fe8bab20fb305c92738770902f003edb387",
+  "sri": "sha512-k5oKV38HxXKqwVi7qU8K9fD+P0ca7kXu52TlulHJoiGO0Q8Ebv0URtW1UXKLYawOm3ZwfVwFEBzAhuj8kMh6rg==",
+  "canonicalFiles": 147,
+  "canonicalBytes": 981509,
   "generator": {
     "path": "packages/opencode/scripts/embed-common-auth.ts",
     "version": 3,
-    "sha256": "89dbeb07d77e0657abeb72a40fcc03a900e98292956865252349a01a15999ed0"
+    "sha256": "79e2db6c01d1048f7a8b90a5105848710890e68ebb0ff096ec5623ec96eb1012"
   },
   "files": [
     {
@@ -227,33 +227,33 @@
     {
       "source": "package/dist/claustrum/consumer.d.ts",
       "output": "claustrum/consumer.d.ts",
-      "bytes": 9907,
-      "sourceSha256": "8001ce3f928af1bc9124223071eb9c85ea3273436cd7be073c588217f942b248",
-      "outputSha256": "8001ce3f928af1bc9124223071eb9c85ea3273436cd7be073c588217f942b248",
+      "bytes": 13309,
+      "sourceSha256": "a33f8fb2750424f1dd1e80ee6e0f260d4d5b6bdf6be3b00b2ae503bfbadb4d17",
+      "outputSha256": "a33f8fb2750424f1dd1e80ee6e0f260d4d5b6bdf6be3b00b2ae503bfbadb4d17",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/consumer.js",
       "output": "claustrum/consumer.js",
-      "bytes": 26470,
-      "sourceSha256": "b2087accd6e8759fb49173dc744243ed703520d5011386ef514672be8fe79fbe",
-      "outputSha256": "b2087accd6e8759fb49173dc744243ed703520d5011386ef514672be8fe79fbe",
+      "bytes": 38516,
+      "sourceSha256": "46a8be88c8e5270d06bda0042235d7081dea06eaf1ae15f9a5fdf2ed93e478fd",
+      "outputSha256": "46a8be88c8e5270d06bda0042235d7081dea06eaf1ae15f9a5fdf2ed93e478fd",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.d.ts",
       "output": "claustrum/custody.d.ts",
-      "bytes": 14842,
-      "sourceSha256": "f776af511c7a02f8e5c4cb0361845d1e740eec96244fee5cfa1289d2212dffd9",
-      "outputSha256": "f776af511c7a02f8e5c4cb0361845d1e740eec96244fee5cfa1289d2212dffd9",
+      "bytes": 16192,
+      "sourceSha256": "ac8a3f2a47ec04ba0b6b5f69425db6672aa7660cd9249853f05fb2b4669698c2",
+      "outputSha256": "ac8a3f2a47ec04ba0b6b5f69425db6672aa7660cd9249853f05fb2b4669698c2",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/custody.js",
       "output": "claustrum/custody.js",
-      "bytes": 27016,
-      "sourceSha256": "5d2ead857d6e6384980dace94d308f1f47afe831c82e2b644ab434ffb0bcf151",
-      "outputSha256": "5d2ead857d6e6384980dace94d308f1f47afe831c82e2b644ab434ffb0bcf151",
+      "bytes": 30242,
+      "sourceSha256": "cfa9c256d59ac4740f5b88fc1662a3bbb29078973cbeaf6225448c305fa580a2",
+      "outputSha256": "cfa9c256d59ac4740f5b88fc1662a3bbb29078973cbeaf6225448c305fa580a2",
       "transform": "verbatim"
     },
     {
@@ -267,9 +267,9 @@
     {
       "source": "package/dist/claustrum/enrollment.js",
       "output": "claustrum/enrollment.js",
-      "bytes": 35060,
-      "sourceSha256": "a9ca3a23778cc86ab9798051ba19dcb3b2b8e3dc4c4fda356cbd56eca50097db",
-      "outputSha256": "a9ca3a23778cc86ab9798051ba19dcb3b2b8e3dc4c4fda356cbd56eca50097db",
+      "bytes": 36501,
+      "sourceSha256": "0a6aa09a8927ae9ba11e4cc4fbe81cd8a3248d5f7db71e8592667bc870899078",
+      "outputSha256": "0a6aa09a8927ae9ba11e4cc4fbe81cd8a3248d5f7db71e8592667bc870899078",
       "transform": "verbatim"
     },
     {
@@ -304,20 +304,36 @@
       "outputSha256": "59bd24af8dbf5d923750b6e2fb15de2ce8a59aa59e11a6740527e50d5f7f93d6",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/claustrum/hub.d.ts",
+      "output": "claustrum/hub.d.ts",
+      "bytes": 9169,
+      "sourceSha256": "07a5c385738649ec5c03b6afb7a916011e565c9f9d5463b280b9896024d8f0c0",
+      "outputSha256": "07a5c385738649ec5c03b6afb7a916011e565c9f9d5463b280b9896024d8f0c0",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/claustrum/hub.js",
+      "output": "claustrum/hub.js",
+      "bytes": 40718,
+      "sourceSha256": "50d57557ccd6e59989424e0df63df75570d97cdb5f71da37ce865d75f76297fd",
+      "outputSha256": "50d57557ccd6e59989424e0df63df75570d97cdb5f71da37ce865d75f76297fd",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/claustrum/index.d.ts",
       "output": "claustrum/index.d.ts",
-      "bytes": 3844,
-      "sourceSha256": "36c0b94c5e18972463f48bfd7e1506d9655372aa8df065786b3a47d199cdb5e0",
-      "outputSha256": "36c0b94c5e18972463f48bfd7e1506d9655372aa8df065786b3a47d199cdb5e0",
+      "bytes": 4728,
+      "sourceSha256": "524bec258d060b75e6aeefa1e39e102e9ad7370e6c74ba2c033fcc418a1db4d7",
+      "outputSha256": "524bec258d060b75e6aeefa1e39e102e9ad7370e6c74ba2c033fcc418a1db4d7",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/index.js",
       "output": "claustrum/index.js",
-      "bytes": 2529,
-      "sourceSha256": "42c9e67bb5ec6749de488933a56fb3ee253c3b9e3588d692f171d87c59bcbd89",
-      "outputSha256": "42c9e67bb5ec6749de488933a56fb3ee253c3b9e3588d692f171d87c59bcbd89",
+      "bytes": 3938,
+      "sourceSha256": "9868c6c475ba9390118bd45c3b5dafe18a51c13cfe4e61700496e9096143a42b",
+      "outputSha256": "9868c6c475ba9390118bd45c3b5dafe18a51c13cfe4e61700496e9096143a42b",
       "transform": "verbatim"
     },
     {
@@ -355,33 +371,41 @@
     {
       "source": "package/dist/claustrum/quota-writer.d.ts",
       "output": "claustrum/quota-writer.d.ts",
-      "bytes": 1112,
-      "sourceSha256": "35c3193c833ef169b5ebd9fdb03a8e08c234e9154b68b04d3cbea79975fffd14",
-      "outputSha256": "35c3193c833ef169b5ebd9fdb03a8e08c234e9154b68b04d3cbea79975fffd14",
+      "bytes": 1483,
+      "sourceSha256": "c3cafec7057092a67d443667bee50b19333dcf3a8d14b63c9fbe4ac3989ba389",
+      "outputSha256": "c3cafec7057092a67d443667bee50b19333dcf3a8d14b63c9fbe4ac3989ba389",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/quota-writer.js",
       "output": "claustrum/quota-writer.js",
-      "bytes": 7579,
-      "sourceSha256": "0054a12ca94aab2eecf50f9b5e090879ff184e7f286cc979f32d311e22011906",
-      "outputSha256": "0054a12ca94aab2eecf50f9b5e090879ff184e7f286cc979f32d311e22011906",
+      "bytes": 8527,
+      "sourceSha256": "5375e7d8a300e73f4398d610090834095fd22ba4b3830f3c62d142a67dcbe9fd",
+      "outputSha256": "5375e7d8a300e73f4398d610090834095fd22ba4b3830f3c62d142a67dcbe9fd",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/roster.d.ts",
       "output": "claustrum/roster.d.ts",
-      "bytes": 12574,
-      "sourceSha256": "c9ab3a89e04f72de09c5f15ccf1436b91f8a245e2253f24ec5998120058aebe7",
-      "outputSha256": "c9ab3a89e04f72de09c5f15ccf1436b91f8a245e2253f24ec5998120058aebe7",
+      "bytes": 15102,
+      "sourceSha256": "30fc3b4d572e43a08a700ff169ebcb52206d1200f7ca678d2bff0a3369aaa005",
+      "outputSha256": "30fc3b4d572e43a08a700ff169ebcb52206d1200f7ca678d2bff0a3369aaa005",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/roster.js",
       "output": "claustrum/roster.js",
-      "bytes": 30876,
-      "sourceSha256": "d02184fd4d32aa8917369919edea4c44328e7332e30f3ddc41ce350e5fd1df07",
-      "outputSha256": "d02184fd4d32aa8917369919edea4c44328e7332e30f3ddc41ce350e5fd1df07",
+      "bytes": 39326,
+      "sourceSha256": "f46fc75edcf4e418f02a5699c7395f1f44abd2e28b77067b89f7622af5890214",
+      "outputSha256": "f46fc75edcf4e418f02a5699c7395f1f44abd2e28b77067b89f7622af5890214",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/claustrum/shutdown.js",
+      "output": "claustrum/shutdown.js",
+      "bytes": 1270,
+      "sourceSha256": "6ccb19ab5e9bb84a978cb47a32b443abe432b4edfe69a318e45bb404ef75c45e",
+      "outputSha256": "6ccb19ab5e9bb84a978cb47a32b443abe432b4edfe69a318e45bb404ef75c45e",
       "transform": "verbatim"
     },
     {
@@ -512,6 +536,14 @@
       "outputSha256": "80779a8078e673ef68deaa7fdee3a0e1322078521a1f4156c0a595814c374044",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/fs/file-read-cache.js",
+      "output": "fs/file-read-cache.js",
+      "bytes": 2121,
+      "sourceSha256": "484d18996d76c44125c880347b3d3dcd10bb352743acf44c588d0b38e8e0f1a7",
+      "outputSha256": "484d18996d76c44125c880347b3d3dcd10bb352743acf44c588d0b38e8e0f1a7",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/fs/index.d.ts",
       "output": "fs/index.d.ts",
@@ -563,17 +595,17 @@
     {
       "source": "package/dist/fs/refresh-file-lock.d.ts",
       "output": "fs/refresh-file-lock.d.ts",
-      "bytes": 2125,
-      "sourceSha256": "ec643f4e081c108c1b42ceb17a83cf3e7e9997a4c75e1a61ffc33b5b44ccd414",
-      "outputSha256": "ec643f4e081c108c1b42ceb17a83cf3e7e9997a4c75e1a61ffc33b5b44ccd414",
+      "bytes": 2157,
+      "sourceSha256": "cbce15eb313d425501780dd4be657cbbaa7e41064bab4ae64fea91fbd54918e9",
+      "outputSha256": "cbce15eb313d425501780dd4be657cbbaa7e41064bab4ae64fea91fbd54918e9",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/refresh-file-lock.js",
       "output": "fs/refresh-file-lock.js",
-      "bytes": 29704,
-      "sourceSha256": "5c52aad573e84e8065dcf06259ecf38345e8b5a2c401029a23d942f28c7a8521",
-      "outputSha256": "5c52aad573e84e8065dcf06259ecf38345e8b5a2c401029a23d942f28c7a8521",
+      "bytes": 30222,
+      "sourceSha256": "314dadbe39b9f0664b6f2f6abff674197c8d86f61ba657e2031d5a8b08ec1030",
+      "outputSha256": "314dadbe39b9f0664b6f2f6abff674197c8d86f61ba657e2031d5a8b08ec1030",
       "transform": "verbatim"
     },
     {
@@ -712,6 +744,22 @@
       "outputSha256": "4e496ce03a8a23536b467168f1dc6a7ceffb06d00ae80cb8a8868f311b2f3a8a",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/quota/commit-interval.d.ts",
+      "output": "quota/commit-interval.d.ts",
+      "bytes": 283,
+      "sourceSha256": "8b1d8b541a382d1ce366d65d9845e9d3848445cf075751b68ad963fb660ee04a",
+      "outputSha256": "8b1d8b541a382d1ce366d65d9845e9d3848445cf075751b68ad963fb660ee04a",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/quota/commit-interval.js",
+      "output": "quota/commit-interval.js",
+      "bytes": 864,
+      "sourceSha256": "3281afb6df69d83a7c5898e1163287f34104068ddd4085b7460c4bb392967491",
+      "outputSha256": "3281afb6df69d83a7c5898e1163287f34104068ddd4085b7460c4bb392967491",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/quota/format.d.ts",
       "output": "quota/format.d.ts",
@@ -963,33 +1011,33 @@
     {
       "source": "package/dist/store/mutate.d.ts",
       "output": "store/mutate.d.ts",
-      "bytes": 9006,
-      "sourceSha256": "009fea657c03a49b37555aa3c445c8930132234f0a1f3e8808ded5c065293ead",
-      "outputSha256": "009fea657c03a49b37555aa3c445c8930132234f0a1f3e8808ded5c065293ead",
+      "bytes": 9196,
+      "sourceSha256": "4a46be98d9eb24a690e95f26b69bd3c461d5f225170bd31fcb89147c7baac41c",
+      "outputSha256": "4a46be98d9eb24a690e95f26b69bd3c461d5f225170bd31fcb89147c7baac41c",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/mutate.js",
       "output": "store/mutate.js",
-      "bytes": 19981,
-      "sourceSha256": "095842664fb1d805159902223b7765dd4a7349ad1a5bbb5e2c135c654739a434",
-      "outputSha256": "095842664fb1d805159902223b7765dd4a7349ad1a5bbb5e2c135c654739a434",
+      "bytes": 20171,
+      "sourceSha256": "d61d08f2caed6d7a803ca4c67511e5133d28f21a90a7417f76e23b49ed00591d",
+      "outputSha256": "d61d08f2caed6d7a803ca4c67511e5133d28f21a90a7417f76e23b49ed00591d",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/pool.d.ts",
       "output": "store/pool.d.ts",
-      "bytes": 11743,
-      "sourceSha256": "0693e165ef937c22c375a3f63d01209c844d101ddf1a6702c8acc99bb5fc2a9d",
-      "outputSha256": "0693e165ef937c22c375a3f63d01209c844d101ddf1a6702c8acc99bb5fc2a9d",
+      "bytes": 12144,
+      "sourceSha256": "64d6e7dd5600f436422e6d309a22b7f874a6afdd866873226ab1f4d5091ebc43",
+      "outputSha256": "64d6e7dd5600f436422e6d309a22b7f874a6afdd866873226ab1f4d5091ebc43",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/pool.js",
       "output": "store/pool.js",
-      "bytes": 6332,
-      "sourceSha256": "45a696753691027dfcadd8e94b38b111ad5085ba1cb4f769225b15efc68125d7",
-      "outputSha256": "45a696753691027dfcadd8e94b38b111ad5085ba1cb4f769225b15efc68125d7",
+      "bytes": 6358,
+      "sourceSha256": "1503b5c0f461678f9710a5fe22e345092de70e537a114e57b0cb651795928031",
+      "outputSha256": "1503b5c0f461678f9710a5fe22e345092de70e537a114e57b0cb651795928031",
       "transform": "verbatim"
     },
     {
@@ -1043,9 +1091,9 @@
     {
       "source": "package/dist/store/quota-writer.js",
       "output": "store/quota-writer.js",
-      "bytes": 12396,
-      "sourceSha256": "ade5fdda516011baf11e40f672263364cea07c45bdcbfc11107e22794e9aef21",
-      "outputSha256": "ade5fdda516011baf11e40f672263364cea07c45bdcbfc11107e22794e9aef21",
+      "bytes": 12960,
+      "sourceSha256": "7816549913b030045e5f7848dd57ca11841a3aa6051c30c96a7d09f82341700e",
+      "outputSha256": "7816549913b030045e5f7848dd57ca11841a3aa6051c30c96a7d09f82341700e",
       "transform": "verbatim"
     },
     {
@@ -1139,17 +1187,17 @@
     {
       "source": "package/dist/store/settings.d.ts",
       "output": "store/settings.d.ts",
-      "bytes": 2979,
-      "sourceSha256": "2be15ac325bcfed048f12e202eaf625a6eca3f85fc35f29dff5770a31d81b7c5",
-      "outputSha256": "2be15ac325bcfed048f12e202eaf625a6eca3f85fc35f29dff5770a31d81b7c5",
+      "bytes": 2994,
+      "sourceSha256": "32446dea1f8431e3fb7e38940d1dec7259dbd5c794b4117efe3875be92405fef",
+      "outputSha256": "32446dea1f8431e3fb7e38940d1dec7259dbd5c794b4117efe3875be92405fef",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/settings.js",
       "output": "store/settings.js",
-      "bytes": 5176,
-      "sourceSha256": "b96a54dfca4a59a592d6bfac82e388e9a4f4c158e4b01dc8864b4bc6becbc88c",
-      "outputSha256": "b96a54dfca4a59a592d6bfac82e388e9a4f4c158e4b01dc8864b4bc6becbc88c",
+      "bytes": 5766,
+      "sourceSha256": "5ed4e0458800923b843b9b8f0671cca0c04cb26e428453e3bcc8b6d06b51470f",
+      "outputSha256": "5ed4e0458800923b843b9b8f0671cca0c04cb26e428453e3bcc8b6d06b51470f",
       "transform": "verbatim"
     },
     {

package/dist/common-auth-embedded/store/mutate.d.ts

@@ -52,6 +52,8 @@ export type ReadResult = ({
     kind?: 'snapshot-contended';
     retryable?: true;
 };
+/** Settings need only the config classification, not a joined roster snapshot. */
+export declare function readPoolConfig(path: string): Promise<import("./schema.js").ConfigClassification>;
 /**
  * Validate config/state/config bytes without locks. Roster replacement writes
  * config before deleting old state credentials. Re-read a changed config so an

package/dist/common-auth-embedded/store/mutate.js

@@ -28,6 +28,10 @@ function parseFile(text) {
         return { exists: true, parseError };
     }
 }
+/** Settings need only the config classification, not a joined roster snapshot. */
+export async function readPoolConfig(path) {
+    return classifyConfig(parseFile(await readText(path)));
+}
 /**
  * Validate config/state/config bytes without locks. Roster replacement writes
  * config before deleting old state credentials. Re-read a changed config so an

package/dist/common-auth-embedded/store/pool.d.ts

@@ -1,3 +1,4 @@
+import type { QuotaCommitTimer } from '../quota/commit-interval.js';
 import { type Attribution } from './attribution.js';
 import type { PoolOperationError } from './errors.js';
 import type { PoolLogger } from './hooks.js';
@@ -24,11 +25,15 @@ export interface OpenPoolStoreOptions {
      * older reading replaces. Accepted readings appear in read/load
      * immediately, merged the same way; the returned promise still rejects
      * current-row refusals before queueing. Await dispose or close at shutdown
-     * to drain.
+     * to attempt a bounded drain; readings still pending at its timeout are
+     * discarded. Normal quota commits are at least 30 seconds apart; a full
+     * queue commits early so response handling never waits for that interval.
      */
     coalesceQuota?: boolean;
     /** Bounded quota drain on close/dispose, in milliseconds; defaults to 1,000. */
     quotaDrainTimeoutMs?: number;
+    /** Monotonic clock and scheduling seam for detached quota commits. */
+    quotaCommitTimer?: QuotaCommitTimer;
     /**
      * The codec of the provider state kept beside each row's credential (see
      * `ProviderStateCodec`). Without it no row shows a provider state, and

package/dist/common-auth-embedded/store/pool.js

@@ -82,7 +82,7 @@ export function openPoolStore(options) {
         firePull: (id, reason) => pulls.fire(id, reason),
     };
     const quotaWriter = options.coalesceQuota
-        ? new PoolQuotaWriter(rt, options.quotaDrainTimeoutMs)
+        ? new PoolQuotaWriter(rt, options.quotaDrainTimeoutMs, options.quotaCommitTimer)
         : undefined;
     const record = (id, attribution, observation) => quotaWriter
         ? quotaWriter.record(id, attribution, observation)

package/dist/common-auth-embedded/store/quota-writer.js

@@ -1,4 +1,5 @@
 import { createLogger } from '../logger/index.js';
+import { QUOTA_COMMIT_INTERVAL_MS, quotaCommitTimer, } from '../quota/commit-interval.js';
 import { assertQuotaEpoch, assertQuotaRow, mergedQuota, } from './attribution.js';
 import { PoolOperationError } from './errors.js';
 import { toFailure, withTransaction } from './mutate.js';
@@ -24,19 +25,22 @@ export const POOL_QUOTA_QUEUE_LIMIT = 128;
 export class PoolQuotaWriter {
     rt;
     timeoutMs;
+    clock;
     pending = new Map();
     warned = new Set();
     wake = new Set();
     logger;
     timer;
+    committedAt;
     running;
     closing;
     closed = false;
     stopped = false;
     failures = 0;
-    constructor(rt, timeoutMs = 1_000) {
+    constructor(rt, timeoutMs = 1_000, clock = quotaCommitTimer) {
         this.rt = rt;
         this.timeoutMs = timeoutMs;
+        this.clock = clock;
         this.logger = rt.ctx.logger ?? createLogger('store');
     }
     async record(id, attribution, observation) {
@@ -126,25 +130,33 @@ export class PoolQuotaWriter {
     schedule(delay) {
         if (this.running || this.timer || !this.pending.size || this.stopped)
             return;
-        this.timer = setTimeout(() => {
+        const remaining = this.closed
+            ? 0
+            : (this.committedAt ?? -Infinity) +
+                QUOTA_COMMIT_INTERVAL_MS -
+                this.clock.now();
+        this.timer = this.clock.schedule(Math.max(delay, remaining), () => {
             this.timer = undefined;
-            this.flush();
-        }, delay);
+            return this.flush();
+        });
         if (!this.closed)
             this.timer.unref?.();
     }
-    // Starts a flush now rather than at the coalescing timer or retry backoff;
-    // a flush already running is left to finish.
+    cancelTimer() {
+        this.timer?.cancel();
+        this.timer = undefined;
+    }
+    // A full queue overrides the interval: response handling must not wait for
+    // a quota commit slot. A flush already running is left to finish.
     flushNow() {
         if (this.running)
             return;
-        clearTimeout(this.timer);
-        this.timer = undefined;
+        this.cancelTimer();
         this.flush();
     }
     flush() {
         if (this.running || this.stopped || !this.pending.size)
-            return;
+            return this.running ?? Promise.resolve();
         // Every queued reading, each row's in arrival order.
         const batch = [...this.pending.values()].flat();
         // Short lock attempts allow retries to pick up freshly queued readings and
@@ -208,8 +220,10 @@ export class PoolQuotaWriter {
                         tx.setEntry(id, { ...entry, quota, needsFirstReading: false });
                         changed = true;
                     }
-                    if (changed && !this.stopped)
+                    if (changed && !this.stopped) {
                         await tx.commitConfig();
+                        this.committedAt = this.clock.now();
+                    }
                 }, { completeTorn: false });
                 const flushed = new Set(batch);
                 for (const [id, queue] of this.pending) {
@@ -240,6 +254,7 @@ export class PoolQuotaWriter {
                 this.schedule(delay);
             }
         })();
+        return this.running;
     }
     warn(message, data) {
         try {
@@ -257,8 +272,7 @@ export class PoolQuotaWriter {
         return this.closing;
     }
     async drain() {
-        clearTimeout(this.timer);
-        this.timer = undefined;
+        this.cancelTimer();
         let deadline;
         let wake;
         const drained = new Promise((done) => {
@@ -281,7 +295,7 @@ export class PoolQuotaWriter {
         finally {
             this.stopped = true;
             clearTimeout(deadline);
-            clearTimeout(this.timer);
+            this.cancelTimer();
             this.wake.delete(wake);
             if (this.pending.size)
                 this.warn('pool quota drain timed out; pending readings left', {

package/dist/common-auth-embedded/store/settings.d.ts

@@ -50,7 +50,7 @@ export type UpdateSettingsResult = {
     /** `unchanged` when the mutator left the settings as they were; nothing was written. */
     outcome: 'updated' | 'unchanged';
 };
-/** Reads the settings without taking a lock or writing anything. */
+/** Reads only the config's settings, without taking a lock or writing anything. */
 export declare function readPoolSettings(rt: StoreRuntime): Promise<SettingsRead>;
 /**
  * One locked read-modify-write of the plugin's settings in the config file