@cortexkit/antigravity-auth-core 3.0.3 → 3.0.4

package/dist/common-auth-embedded/logger/engine.js

@@ -1,4 +1,7 @@
 import { appendFileSync, chmodSync, existsSync, renameSync, statSync, } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { createPrivateBytes, ensurePrivateDirectory, privateOperation, replaceWindowsFile, verifyPrivate, windowsPrivateFiles, } from '../fs/private-files.js';
 import { createRedactor } from './redact.js';
 const ORDER = {
     error: 0,
@@ -36,6 +39,75 @@ function rotateIfNeeded(f) {
         /* never throw */
     }
 }
+async function closeWindowsFile(sink) {
+    const { file, handle } = sink;
+    sink.file = undefined;
+    sink.handle = undefined;
+    if (file && handle)
+        await privateOperation(file, 'log-close', () => handle.close());
+}
+async function openWindowsFile(sink, file) {
+    await ensurePrivateDirectory(dirname(file));
+    try {
+        await verifyPrivate(file, 'file', true);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        try {
+            await createPrivateBytes(file, '');
+        }
+        catch (creationError) {
+            if (creationError.code !== 'EEXIST')
+                throw creationError;
+            await verifyPrivate(file, 'file', true);
+        }
+    }
+    // The safe-parent policy denies other ordinary users the ability to create, replace or link entries between verification and fs.open.
+    // This protects against other ordinary users, not the owner or administrators, whose ability to change that namespace is outside our threat model.
+    sink.handle = await privateOperation(file, 'log-open', () => open(file, 'a'));
+    sink.file = file;
+    return sink.handle;
+}
+async function flushWindowsFile(sink, file, text) {
+    file = resolve(file);
+    try {
+        if (sink.file !== file)
+            await closeWindowsFile(sink);
+        let handle = sink.handle ?? (await openWindowsFile(sink, file));
+        const info = await privateOperation(file, 'log-stat', () => handle.stat());
+        if (info.size >= MAX_BYTES) {
+            await closeWindowsFile(sink);
+            for (let i = ROTATE_KEEP - 1; i >= 0; i--) {
+                const source = i === 0 ? file : `${file}.${i}`;
+                const target = `${file}.${i + 1}`;
+                try {
+                    await verifyPrivate(source, 'file', true);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        continue;
+                    throw error;
+                }
+                try {
+                    await verifyPrivate(target, 'file', true);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                await replaceWindowsFile(source, target);
+                await verifyPrivate(target, 'file');
+            }
+            handle = await openWindowsFile(sink, file);
+        }
+        await privateOperation(file, 'log-append', () => handle.appendFile(text, 'utf8'));
+    }
+    catch (error) {
+        await closeWindowsFile(sink).catch(() => { });
+        throw error;
+    }
+}
 function safeSerialize(data) {
     try {
         return ` ${JSON.stringify(data)}`;
@@ -63,7 +135,19 @@ function createEngine(options) {
     let captureSink;
     let buffer = [];
     let timer;
+    let orderedSink = Promise.resolve();
+    let sinkError;
+    const windowsFile = {};
+    function queueWindows(operation) {
+        const next = orderedSink.then(operation);
+        orderedSink = next.catch((error) => {
+            sinkError = error;
+        });
+        return next;
+    }
     function configure(next) {
+        if (windowsPrivateFiles && next.file !== logFileSource)
+            void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => { });
         logFileSource = next.file;
         initLevelSource = next.level;
         redactor = createRedactor(next);
@@ -89,25 +173,49 @@ function createEngine(options) {
             return floor;
         return 'info';
     }
-    function flushLogs() {
+    function flushLogs(close = true) {
         if (timer) {
             clearTimeout(timer);
             timer = undefined;
         }
-        if (!buffer.length)
+        if (!buffer.length) {
+            if (windowsPrivateFiles)
+                return queueWindows(async () => {
+                    if (close)
+                        await closeWindowsFile(windowsFile);
+                    if (sinkError)
+                        throw sinkError;
+                });
             return;
+        }
         let file;
         try {
             file = logFilePath();
         }
         catch {
             buffer = [];
+            if (windowsPrivateFiles && close)
+                return queueWindows(() => closeWindowsFile(windowsFile));
             return;
         }
         const text = buffer.join('');
         buffer = [];
-        if (!file)
+        if (!file) {
+            if (windowsPrivateFiles && close)
+                return queueWindows(() => closeWindowsFile(windowsFile));
             return;
+        }
+        if (windowsPrivateFiles) {
+            return queueWindows(async () => {
+                try {
+                    await flushWindowsFile(windowsFile, file, text);
+                }
+                finally {
+                    if (close)
+                        await closeWindowsFile(windowsFile);
+                }
+            });
+        }
         try {
             rotateIfNeeded(file);
             if (existsSync(file))
@@ -122,7 +230,9 @@ function createEngine(options) {
         if (!timer)
             timer = setTimeout(() => {
                 timer = undefined;
-                flushLogs();
+                const flushed = flushLogs(false);
+                if (flushed instanceof Promise)
+                    void flushed.catch(() => { });
             }, 500);
     }
     function emit(channel, level, message, data) {
@@ -157,8 +267,11 @@ function createEngine(options) {
             if (logFileSource === undefined)
                 return;
             buffer.push(line);
-            if (buffer.length >= 50)
-                flushLogs();
+            if (buffer.length >= 50) {
+                const flushed = flushLogs(false);
+                if (flushed instanceof Promise)
+                    void flushed.catch(() => { });
+            }
             else
                 schedule();
         }
@@ -176,6 +289,9 @@ function createEngine(options) {
         };
     }
     function reset() {
+        if (windowsPrivateFiles)
+            void queueWindows(() => closeWindowsFile(windowsFile)).catch(() => { });
+        sinkError = undefined;
         buffer = [];
         if (timer) {
             clearTimeout(timer);
@@ -222,18 +338,17 @@ export function setLogLevel(l) {
     defaultEngine.setLogLevel(l);
 }
 /**
- * Write whatever the default logger has buffered. Safe to call synchronously
- * from a process-exit handler, which is how each host drains the buffer on
- * shutdown.
+ * Write whatever the default logger has buffered. On Windows await the
+ * promise before shutdown; POSIX keeps synchronous process-exit flushing.
  */
 export function flushLogs() {
-    defaultEngine.flushLogs();
+    return defaultEngine.flushLogs();
 }
 export function createLogger(channel) {
     return defaultEngine.createLogger(channel);
 }
 export async function flushForTest() {
-    defaultEngine.flushLogs();
+    return defaultEngine.flushLogs();
 }
 /**
  * Return the default logger to its uninitialised state. Only a test needs

package/dist/common-auth-embedded/pi-slot/slot.d.ts

@@ -5,6 +5,8 @@ export declare class PiSlotError extends Error {
     constructor(code: PiSlotErrorCode);
 }
 export interface PiSlotOptions {
+    /** Windows checks safe ancestry and creates missing parents owner-only, regardless of this option. POSIX keeps its existing directory policy. */
+    privateParents?: boolean;
     authPath: string;
     provider: string;
     /**

package/dist/common-auth-embedded/pi-slot/slot.js

@@ -4,6 +4,7 @@ import { lstat, mkdir, open, unlink } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { writeJsonAtomic } from '../fs/atomic-write.js';
+import { ensurePrivateDirectory, PrivateFileError, readPrivateBuffer, windowsPrivateFiles, } from '../fs/private-files.js';
 import { acquirePiLock } from './lock.js';
 /** Errors deliberately contain neither paths nor credentials nor underlying error messages. */
 export class PiSlotError extends Error {
@@ -96,6 +97,21 @@ function code(error) {
     return object(error) ? error.code : undefined;
 }
 async function safeRead(path, privateFile = false, afterReadCheck) {
+    if (windowsPrivateFiles) {
+        try {
+            await afterReadCheck?.(path);
+            const bytes = await readPrivateBuffer(path, true);
+            const text = bytes.toString('utf8');
+            if (!bytes.equals(Buffer.from(text)))
+                throw new PiSlotError(privateFile ? 'invalid-stash' : 'invalid-auth');
+            return text;
+        }
+        catch (error) {
+            if (code(error) === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
     let file;
     try {
         file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
@@ -188,6 +204,10 @@ function replaceEntry(auth, provider, next) {
     return `${text.slice(0, offset)}${last ? ',' : ''}${JSON.stringify(provider)}:${next}${text.slice(offset)}`;
 }
 async function syncDir(path) {
+    // Windows flushes file bytes before rename but cannot promise persisted
+    // directory metadata, so this Pi transition deliberately skips directory sync.
+    if (windowsPrivateFiles)
+        return;
     const dir = await open(path, 'r');
     try {
         await dir.sync();
@@ -200,6 +220,7 @@ async function atomicWrite(path, text, assertLock, beforeRename) {
     await writeJsonAtomic(path, null, {
         serialize: () => text,
         durable: true,
+        durability: windowsPrivateFiles ? 'file-only-on-windows' : undefined,
         beforeRename: async () => {
             await beforeRename?.(path);
             assertLock();
@@ -274,7 +295,10 @@ export function createPiSlot(options, onStep, hooks) {
                 throw new PiSlotError('lock-compromised');
         };
         try {
-            await mkdir(dirname(authPath), { recursive: true, mode: 0o700 });
+            if (windowsPrivateFiles)
+                await ensurePrivateDirectory(dirname(authPath));
+            else
+                await mkdir(dirname(authPath), { recursive: true, mode: 0o700 });
             const deadline = Date.now() + timeout;
             let retry = 0;
             while (!release) {
@@ -300,7 +324,7 @@ export function createPiSlot(options, onStep, hooks) {
             return result;
         }
         catch (error) {
-            if (error instanceof PiSlotError)
+            if (error instanceof PiSlotError || error instanceof PrivateFileError)
                 throw error;
             throw new PiSlotError('io');
         }
@@ -342,10 +366,14 @@ export function createPiSlot(options, onStep, hooks) {
             if (stash && digest(auth.entry) !== stash.sha256)
                 throw new PiSlotError('conflict');
             if (!stash) {
-                await mkdir(dirname(stashPath), { recursive: true, mode: 0o700 });
-                const dir = await lstat(dirname(stashPath));
-                if (!dir.isDirectory() || (dir.mode & 0o777) !== 0o700)
-                    throw new PiSlotError('unsafe-path');
+                if (windowsPrivateFiles)
+                    await ensurePrivateDirectory(dirname(stashPath));
+                else {
+                    await mkdir(dirname(stashPath), { recursive: true, mode: 0o700 });
+                    const dir = await lstat(dirname(stashPath));
+                    if (!dir.isDirectory() || (dir.mode & 0o777) !== 0o700)
+                        throw new PiSlotError('unsafe-path');
+                }
                 const saved = {
                     version: 1,
                     provider,

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

@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "package": "@cortexkit/common-auth",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "artifactStatus": "released",
   "publicRoots": {
     "./store": {
@@ -37,15 +37,15 @@
       "import": "./dist/pi-slot/index.js"
     }
   },
-  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.14.2.tgz",
-  "tarballSha256": "bf0f0828d155183dec1c29e5277ededd6cbd46e6b839ca696434e477f081216b",
-  "sri": "sha512-cGG0Ye6MsLL7K5cTddI4UShOoVR6Zas2G1aSspJZURDyHwiMY1qzCVav7p1DF49uBp5qTK3t3cahZ3cvjxVyHQ==",
-  "canonicalFiles": 129,
-  "canonicalBytes": 696000,
+  "input": "tools/common-auth-build/inputs/cortexkit-common-auth-0.15.0.tgz",
+  "tarballSha256": "a23db89b43bedba8d371cd9d45e5f35306040cda3f425efb49fbce5610aa9c6b",
+  "sri": "sha512-1EQVggxbrijCtfdyv4z60eSl0dmZRGO6i1q2m8w20VxwdowWkUV0Y/7kErhp1/2ZNvmDZK65RICMiTcokidxiw==",
+  "canonicalFiles": 131,
+  "canonicalBytes": 730840,
   "generator": {
     "path": "packages/opencode/scripts/embed-common-auth.ts",
     "version": 3,
-    "sha256": "1717582e7006925e7bd875d1bcc57d9e2809df5614c920cf820f097550102938"
+    "sha256": "158eda37ce92ca20155ccf2c74aca00072a600d976e7d74d8bce0059ea351867"
   },
   "files": [
     {
@@ -243,17 +243,17 @@
     {
       "source": "package/dist/claustrum/enrollment.d.ts",
       "output": "claustrum/enrollment.d.ts",
-      "bytes": 7453,
-      "sourceSha256": "855f7cd2a52665c4a699bd9b8a06e50a807a21012e7ef031146aaeb0599d71e4",
-      "outputSha256": "855f7cd2a52665c4a699bd9b8a06e50a807a21012e7ef031146aaeb0599d71e4",
+      "bytes": 7528,
+      "sourceSha256": "5b2f01bd0a6dd5f92a8450c43619717f08d1ca9aea0ed20f3f7071cc94c1c1bf",
+      "outputSha256": "5b2f01bd0a6dd5f92a8450c43619717f08d1ca9aea0ed20f3f7071cc94c1c1bf",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/claustrum/enrollment.js",
       "output": "claustrum/enrollment.js",
-      "bytes": 31343,
-      "sourceSha256": "be5dadd916be59dfa8234c9d7d4e98c5d9d94a17e46483690bd468a3e9dca051",
-      "outputSha256": "be5dadd916be59dfa8234c9d7d4e98c5d9d94a17e46483690bd468a3e9dca051",
+      "bytes": 33305,
+      "sourceSha256": "e03e33e3f43daf5563d7e2138450c6a5347017a82627c5b8e1d1998b4ce4c42f",
+      "outputSha256": "e03e33e3f43daf5563d7e2138450c6a5347017a82627c5b8e1d1998b4ce4c42f",
       "transform": "verbatim"
     },
     {
@@ -331,9 +331,9 @@
     {
       "source": "package/dist/claustrum/roster.js",
       "output": "claustrum/roster.js",
-      "bytes": 23786,
-      "sourceSha256": "508fed4aed11daef7cb407089c3c8e739aec6c0b29a9922cdcd7a010e8af0b63",
-      "outputSha256": "508fed4aed11daef7cb407089c3c8e739aec6c0b29a9922cdcd7a010e8af0b63",
+      "bytes": 23840,
+      "sourceSha256": "8f9d247e7d614e997cebb9728eaeb96fd0f32955cebfccc3d016351ad39a3947",
+      "outputSha256": "8f9d247e7d614e997cebb9728eaeb96fd0f32955cebfccc3d016351ad39a3947",
       "transform": "verbatim"
     },
     {
@@ -435,33 +435,33 @@
     {
       "source": "package/dist/fs/atomic-write.d.ts",
       "output": "fs/atomic-write.d.ts",
-      "bytes": 1093,
-      "sourceSha256": "fd51dfeca6176e931d9b297dd4d4077f67e3cbb019fffd80928cde27952d09f6",
-      "outputSha256": "fd51dfeca6176e931d9b297dd4d4077f67e3cbb019fffd80928cde27952d09f6",
+      "bytes": 1465,
+      "sourceSha256": "d2117894a4fe94d3786dd7a126bce1d72748ba4c8f5838bcb880607b376886c4",
+      "outputSha256": "d2117894a4fe94d3786dd7a126bce1d72748ba4c8f5838bcb880607b376886c4",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/atomic-write.js",
       "output": "fs/atomic-write.js",
-      "bytes": 2610,
-      "sourceSha256": "2afb3e4c275fcb5d53baa9cca43d72264583225f465e1380a68f73e06424b17a",
-      "outputSha256": "2afb3e4c275fcb5d53baa9cca43d72264583225f465e1380a68f73e06424b17a",
+      "bytes": 3450,
+      "sourceSha256": "80779a8078e673ef68deaa7fdee3a0e1322078521a1f4156c0a595814c374044",
+      "outputSha256": "80779a8078e673ef68deaa7fdee3a0e1322078521a1f4156c0a595814c374044",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/index.d.ts",
       "output": "fs/index.d.ts",
-      "bytes": 508,
-      "sourceSha256": "69344577a9fd8efdac1cbb83d8e3e21ca7f09645623f2f35a22b3cf3ba914edd",
-      "outputSha256": "69344577a9fd8efdac1cbb83d8e3e21ca7f09645623f2f35a22b3cf3ba914edd",
+      "bytes": 626,
+      "sourceSha256": "31ad80c3a005dfd3c78d1b8d1a2d4c23ce9d47dd9f6b5b8c3b9ec4f07c4b5cdb",
+      "outputSha256": "31ad80c3a005dfd3c78d1b8d1a2d4c23ce9d47dd9f6b5b8c3b9ec4f07c4b5cdb",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/index.js",
       "output": "fs/index.js",
-      "bytes": 454,
-      "sourceSha256": "27412caa40574b195c48045d60c32880d0906109e1101bc1b6447118a2d48b14",
-      "outputSha256": "27412caa40574b195c48045d60c32880d0906109e1101bc1b6447118a2d48b14",
+      "bytes": 509,
+      "sourceSha256": "26127c5a818c2ff0f66374f2dbbd93f57c6de7266acb2b2f61117e6e17e57f2b",
+      "outputSha256": "26127c5a818c2ff0f66374f2dbbd93f57c6de7266acb2b2f61117e6e17e57f2b",
       "transform": "verbatim"
     },
     {
@@ -480,36 +480,52 @@
       "outputSha256": "cd60090325fa8c4c17dddfc216a4ed326f2a6e48525e724a4dd260bf88041231",
       "transform": "verbatim"
     },
+    {
+      "source": "package/dist/fs/private-files.d.ts",
+      "output": "fs/private-files.d.ts",
+      "bytes": 3228,
+      "sourceSha256": "1882d869cfebb3cebc8b9db47fb15083f8300c51c26c71666e898377fcd9a1ba",
+      "outputSha256": "1882d869cfebb3cebc8b9db47fb15083f8300c51c26c71666e898377fcd9a1ba",
+      "transform": "verbatim"
+    },
+    {
+      "source": "package/dist/fs/private-files.js",
+      "output": "fs/private-files.js",
+      "bytes": 12025,
+      "sourceSha256": "4b46f7b37c11da02f655a6ca841fa51189ceefffaa4476f4fa7a27f953c54ad4",
+      "outputSha256": "4b46f7b37c11da02f655a6ca841fa51189ceefffaa4476f4fa7a27f953c54ad4",
+      "transform": "verbatim"
+    },
     {
       "source": "package/dist/fs/refresh-file-lock.d.ts",
       "output": "fs/refresh-file-lock.d.ts",
-      "bytes": 1701,
-      "sourceSha256": "55473d70c407f4521eb285c2f44b1398391fc56326914c0e51bf7fbea2518781",
-      "outputSha256": "55473d70c407f4521eb285c2f44b1398391fc56326914c0e51bf7fbea2518781",
+      "bytes": 1765,
+      "sourceSha256": "72996a1247d498a34ac157d23c34ef03bcbdb68c79e8751be4874885aed7e843",
+      "outputSha256": "72996a1247d498a34ac157d23c34ef03bcbdb68c79e8751be4874885aed7e843",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/refresh-file-lock.js",
       "output": "fs/refresh-file-lock.js",
-      "bytes": 19961,
-      "sourceSha256": "e621abceca8fb963aa4851aa456309ed3014ff9c0fb5e3250ede6423b9f35222",
-      "outputSha256": "e621abceca8fb963aa4851aa456309ed3014ff9c0fb5e3250ede6423b9f35222",
+      "bytes": 28985,
+      "sourceSha256": "6bf0f944bd70c60f1679bdc4c2764d19ed0047c77dbf737c13088bb8c478e5e2",
+      "outputSha256": "6bf0f944bd70c60f1679bdc4c2764d19ed0047c77dbf737c13088bb8c478e5e2",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/with-lock.d.ts",
       "output": "fs/with-lock.d.ts",
-      "bytes": 934,
-      "sourceSha256": "a505c744baef71ad72a62c806db60ab052f97687a7e28d11e69411f969848a37",
-      "outputSha256": "a505c744baef71ad72a62c806db60ab052f97687a7e28d11e69411f969848a37",
+      "bytes": 1153,
+      "sourceSha256": "a0509ca4ee64b392b69c7a8555c7b33c0c223a8e58aec48848c3216350f1ba0c",
+      "outputSha256": "a0509ca4ee64b392b69c7a8555c7b33c0c223a8e58aec48848c3216350f1ba0c",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/fs/with-lock.js",
       "output": "fs/with-lock.js",
-      "bytes": 1507,
-      "sourceSha256": "284251aa245860f2ca64cfbdae0bfbbceed77f33950650cf5eafa1a6ed896387",
-      "outputSha256": "284251aa245860f2ca64cfbdae0bfbbceed77f33950650cf5eafa1a6ed896387",
+      "bytes": 1697,
+      "sourceSha256": "35b4ed6dec77ffcb7850e655a35957da15c14a0fa27b6f3d1d634e243de43456",
+      "outputSha256": "35b4ed6dec77ffcb7850e655a35957da15c14a0fa27b6f3d1d634e243de43456",
       "transform": "verbatim"
     },
     {
@@ -531,17 +547,17 @@
     {
       "source": "package/dist/logger/engine.d.ts",
       "output": "logger/engine.d.ts",
-      "bytes": 4607,
-      "sourceSha256": "646d7438df2aa50853dc8f8220236cee75e480342545d8d94718ea34259ae522",
-      "outputSha256": "646d7438df2aa50853dc8f8220236cee75e480342545d8d94718ea34259ae522",
+      "bytes": 4612,
+      "sourceSha256": "48e339153dcd7f5389ce9c10e4ad4a06066bcece866d62c70c0fa39f87f0bb1a",
+      "outputSha256": "48e339153dcd7f5389ce9c10e4ad4a06066bcece866d62c70c0fa39f87f0bb1a",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/logger/engine.js",
       "output": "logger/engine.js",
-      "bytes": 7925,
-      "sourceSha256": "3ebcd0e8ad5aca437cee85e4b9087ba15d7efbcb07b5fefff937092f2de3f829",
-      "outputSha256": "3ebcd0e8ad5aca437cee85e4b9087ba15d7efbcb07b5fefff937092f2de3f829",
+      "bytes": 12539,
+      "sourceSha256": "03d858547caa2e6f0e9c36759f11f442dfd6c11a20a6714eae35dea832f1444f",
+      "outputSha256": "03d858547caa2e6f0e9c36759f11f442dfd6c11a20a6714eae35dea832f1444f",
       "transform": "verbatim"
     },
     {
@@ -603,17 +619,17 @@
     {
       "source": "package/dist/pi-slot/slot.d.ts",
       "output": "pi-slot/slot.d.ts",
-      "bytes": 2214,
-      "sourceSha256": "02d78c35ec1f3b336db91c1267c7a85d8e93736c24dce5df1818d8fa85321ba3",
-      "outputSha256": "02d78c35ec1f3b336db91c1267c7a85d8e93736c24dce5df1818d8fa85321ba3",
+      "bytes": 2394,
+      "sourceSha256": "b92f1590f1f0e4dbbc6331923b9d2cf95e3200936063d5ed192a186f3271eb17",
+      "outputSha256": "b92f1590f1f0e4dbbc6331923b9d2cf95e3200936063d5ed192a186f3271eb17",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/pi-slot/slot.js",
       "output": "pi-slot/slot.js",
-      "bytes": 13872,
-      "sourceSha256": "f7a5a70d074a0890833ffded094fb09036b6199db2570a775dfb7cbc32303957",
-      "outputSha256": "f7a5a70d074a0890833ffded094fb09036b6199db2570a775dfb7cbc32303957",
+      "bytes": 15120,
+      "sourceSha256": "13a7d5941b79c6d444cf9dc6f23263cf9237146c7dd5de7d162dbc21e015532c",
+      "outputSha256": "13a7d5941b79c6d444cf9dc6f23263cf9237146c7dd5de7d162dbc21e015532c",
       "transform": "verbatim"
     },
     {
@@ -883,25 +899,25 @@
     {
       "source": "package/dist/store/mutate.js",
       "output": "store/mutate.js",
-      "bytes": 19927,
-      "sourceSha256": "27ef7aba48dca42081d0d78218b59c8b8b8b84714ca8e4c14846468d22b4ce59",
-      "outputSha256": "27ef7aba48dca42081d0d78218b59c8b8b8b84714ca8e4c14846468d22b4ce59",
+      "bytes": 19981,
+      "sourceSha256": "095842664fb1d805159902223b7765dd4a7349ad1a5bbb5e2c135c654739a434",
+      "outputSha256": "095842664fb1d805159902223b7765dd4a7349ad1a5bbb5e2c135c654739a434",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/pool.d.ts",
       "output": "store/pool.d.ts",
-      "bytes": 10698,
-      "sourceSha256": "bc7952bff586abb98f426bfb34518686159819160b0210ead63b6b68f691ef55",
-      "outputSha256": "bc7952bff586abb98f426bfb34518686159819160b0210ead63b6b68f691ef55",
+      "bytes": 10754,
+      "sourceSha256": "901b2881e94f067c6b454002f1e3922b75f248f2a25ef7548c399cafd9611159",
+      "outputSha256": "901b2881e94f067c6b454002f1e3922b75f248f2a25ef7548c399cafd9611159",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/pool.js",
       "output": "store/pool.js",
-      "bytes": 5590,
-      "sourceSha256": "f2a1ce55a2be5ca090e333700ae46ca7d14d1657153e6a5819a3bc348552fd0e",
-      "outputSha256": "f2a1ce55a2be5ca090e333700ae46ca7d14d1657153e6a5819a3bc348552fd0e",
+      "bytes": 5713,
+      "sourceSha256": "678cca0578ac32eb1d9e45408614c6a7b56a6dcb94672a961c8c13bca55171fd",
+      "outputSha256": "678cca0578ac32eb1d9e45408614c6a7b56a6dcb94672a961c8c13bca55171fd",
       "transform": "verbatim"
     },
     {
@@ -955,17 +971,17 @@
     {
       "source": "package/dist/store/refresh-lock.d.ts",
       "output": "store/refresh-lock.d.ts",
-      "bytes": 2318,
-      "sourceSha256": "04d05f036f5bd460cf29511957aa86ba39cd914db2bee2262d2a19e240ac7387",
-      "outputSha256": "04d05f036f5bd460cf29511957aa86ba39cd914db2bee2262d2a19e240ac7387",
+      "bytes": 2442,
+      "sourceSha256": "5b4230fad8b94abc23d9b4a9c72cf21d7c961ac6359561a4da28e1e807bcb0ca",
+      "outputSha256": "5b4230fad8b94abc23d9b4a9c72cf21d7c961ac6359561a4da28e1e807bcb0ca",
       "transform": "verbatim"
     },
     {
       "source": "package/dist/store/refresh-lock.js",
       "output": "store/refresh-lock.js",
-      "bytes": 4471,
-      "sourceSha256": "94b6397ae32b38329058d536c3e0e4d113b5730d14c56ae025ada91bb8919617",
-      "outputSha256": "94b6397ae32b38329058d536c3e0e4d113b5730d14c56ae025ada91bb8919617",
+      "bytes": 4681,
+      "sourceSha256": "035a03e02a0690ec51d92df0b61e2ae6abb7b8d6a141112640f8d649eb583949",
+      "outputSha256": "035a03e02a0690ec51d92df0b61e2ae6abb7b8d6a141112640f8d649eb583949",
       "transform": "verbatim"
     },
     {

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

@@ -1,6 +1,6 @@
-import { readFile } from 'node:fs/promises';
 import { setTimeout as snapshotDelay } from 'node:timers/promises';
 import { AtomicSyncError, syncJsonFile, writeJsonAtomic, writeJsonAtomicTracked, } from '../fs/atomic-write.js';
+import { readPrivateText, windowsPrivateFiles } from '../fs/private-files.js';
 import { LockContentionError, LockOwnershipError } from '../fs/with-lock.js';
 import { PoolOperationError, } from './errors.js';
 import { callFailureHook } from './hooks.js';
@@ -10,7 +10,7 @@ import { CREDENTIAL_STAMP_KEY, classifyConfig, classifyState, ensureEntries, ent
 import { completeTornRows, loadRows } from './torn.js';
 async function readText(path) {
     try {
-        return await readFile(path, 'utf8');
+        return await readPrivateText(path, windowsPrivateFiles);
     }
     catch (error) {
         if (error.code === 'ENOENT')

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

@@ -66,6 +66,7 @@ export interface OpenPoolStoreOptions {
     hold?: (point: HoldPoint, rowId: string) => void | Promise<void>;
     onLockEvent?: LockEnvironment['onLockEvent'];
     onLockStep?: LockEnvironment['onLockStep'];
+    onRenewalTimer?: LockEnvironment['onRenewalTimer'];
 }
 export type PoolLoad = {
     status: 'ready';

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

@@ -60,6 +60,9 @@ export function openPoolStore(options) {
             now: options.now ?? Date.now,
             ...(options.onLockEvent ? { onLockEvent: options.onLockEvent } : {}),
             ...(options.onLockStep ? { onLockStep: options.onLockStep } : {}),
+            ...(options.onRenewalTimer
+                ? { onRenewalTimer: options.onRenewalTimer }
+                : {}),
         },
         removedIds: memory.removedIds,
         requireCredentialStamps: options.requireCredentialStamps === true,

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

@@ -30,6 +30,10 @@ export interface LockEnvironment {
         name: string;
         path: string;
     }, step: LockStep) => void | Promise<void>;
+    onRenewalTimer?: (lock: {
+        name: string;
+        path: string;
+    }, event: 'scheduled' | 'cancelled') => void;
 }
 export interface HeldLock {
     readonly name: string;

package/dist/common-auth-embedded/store/refresh-lock.js

@@ -45,6 +45,11 @@ export async function acquirePoolLock(spec, defaults, env) {
             now: env.now,
             renew: options.renew,
             onContended: () => emit('contended'),
+            ...(env.onRenewalTimer
+                ? {
+                    onRenewalTimer: (event) => env.onRenewalTimer?.({ name: spec.name, path: spec.path }, event),
+                }
+                : {}),
             ...(options.renewIntervalMs !== undefined
                 ? { renewIntervalMs: options.renewIntervalMs }
                 : {}),