@openclaw/fs-safe 0.8.3 → 0.8.5

package/dist/root-impl.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
+import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { normalizeMaxBytes } from "./byte-budget.js";
@@ -87,7 +87,7 @@ async function openVerifiedLocalFile(filePath, options) {
     // results that get sent to messaging channels). See openclaw/openclaw#31186.
     try {
         preOpenStat = await inspectFileIdentity(async () => {
-            const stat = await fs.lstat(filePath, { bigint: true });
+            const stat = fsSync.lstatSync(filePath, { bigint: true });
             observedBeforeOpen = true;
             if (stat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
                 throw new FsSafeError("symlink", "symlink not allowed");
@@ -127,13 +127,13 @@ async function openVerifiedLocalFile(filePath, options) {
     }
     try {
         await fsSafeTestHooks?.afterOpen?.(filePath, handle);
-        const stat = await handle.stat();
+        const stat = fsSync.fstatSync(handle.fd);
         if (!stat.isFile()) {
             throw new FsSafeError("not-file", "not a file");
         }
         // Keep numeric Stats for the public receipt, never for identity verification.
         let openedIdentity;
-        const identity = await inspectFileIdentity(async () => (openedIdentity = await handle.stat({ bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
+        const identity = await inspectFileIdentity(async () => (openedIdentity = fsSync.fstatSync(handle.fd, { bigint: true })), preOpenStat && !preOpenStat.isSymbolicLink() ? preOpenStat : undefined).catch(async (error) => {
             if ([0, 1].includes(stat.nlink)) {
                 await recordPreOpenFileChange(error, handle, filePath, preOpenStat, openedIdentity);
             }
@@ -156,8 +156,8 @@ async function openVerifiedLocalFile(filePath, options) {
         };
         await inspectPathIdentity(async () => {
             const pathStat = options?.symlinks === "follow-within-root"
-                ? await fs.stat(filePath, { bigint: true })
-                : await fs.lstat(filePath, { bigint: true });
+                ? fsSync.statSync(filePath, { bigint: true })
+                : fsSync.lstatSync(filePath, { bigint: true });
             if (pathStat.isSymbolicLink() && options?.symlinks !== "follow-within-root") {
                 throw new FsSafeError("symlink", "symlink not allowed");
             }
@@ -176,7 +176,7 @@ async function openVerifiedLocalFile(filePath, options) {
         await inspectPathIdentity(async () => {
             // Reuse the post-realpath observation; unknown Windows identities still
             // get a fresh observation on inspectFileIdentity's retry.
-            const realStat = resolvedStat ?? await fs.stat(realPath, { bigint: true });
+            const realStat = resolvedStat ?? fsSync.statSync(realPath, { bigint: true });
             resolvedStat = undefined;
             if (options?.hardlinks === "reject" && realStat.nlink > 1n) {
                 throw hardlinkedPathNotAllowedError();
@@ -275,6 +275,7 @@ export class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
         });
     }
     async remove(relativePath, options = {}) {
@@ -307,6 +308,7 @@ export class RootHandle {
             mode: this.defaults.mode,
             renameIdentity: this.defaults.renameIdentity,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
         });
     }
     async create(relativePath, data, options = {}) {
@@ -317,6 +319,7 @@ export class RootHandle {
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
             ...this.mutationOptions(options),
+            durable: options.durable ?? this.defaults.durable ?? true,
             overwrite: false,
         });
     }
@@ -486,7 +489,7 @@ async function writeTempFileForAtomicReplace(params) {
         }
         return {
             handle: tempHandle,
-            identity: await tempHandle.stat({ bigint: true }),
+            identity: fsSync.fstatSync(tempHandle.fd, { bigint: true }),
         };
     }
     catch (error) {
@@ -525,7 +528,7 @@ async function openWritableFileInRoot(root, params) {
         ? resolved
         : await prepareRootWriteTarget(rootReal, resolved);
     try {
-        const resolvedRealPath = await fs.realpath(ioPath);
+        const resolvedRealPath = fsSync.realpathSync.native(ioPath);
         if (!isPathInside(rootWithSep, resolvedRealPath)) {
             throw outsideWorkspaceError();
         }
@@ -574,7 +577,7 @@ async function openWritableFileInRoot(root, params) {
     let realPathForCleanup = null;
     let createdIdentity = null;
     try {
-        const stat = await handle.stat();
+        const stat = fsSync.fstatSync(handle.fd);
         if (createdForWrite) {
             createdIdentity = stat;
         }
@@ -585,7 +588,7 @@ async function openWritableFileInRoot(root, params) {
             throw hardlinkedPathNotAllowedError();
         }
         try {
-            const lstat = await fs.lstat(ioPath);
+            const lstat = fsSync.lstatSync(ioPath);
             if (lstat.isSymbolicLink() || !lstat.isFile()) {
                 throw new FsSafeError(lstat.isSymbolicLink() ? "symlink" : "not-file", "path is not a regular file under root");
             }
@@ -600,7 +603,7 @@ async function openWritableFileInRoot(root, params) {
         }
         const realPath = await resolveOpenedFileRealPathForHandle(handle, ioPath);
         realPathForCleanup = realPath;
-        const realStat = await fs.stat(realPath);
+        const realStat = fsSync.statSync(realPath);
         if (!sameFileIdentity(stat, realStat)) {
             throw new FsSafeError("path-mismatch", "path mismatch");
         }
@@ -663,8 +666,9 @@ async function appendFileInRoot(root, params) {
             const payload = prefix.length > 0 ? Buffer.concat([Buffer.from(prefix, "utf8"), params.data]) : params.data;
             await target.handle.appendFile(payload);
         }
-        await target.handle.sync();
-        if (target.createdForWrite) {
+        if (params.durable !== false)
+            await target.handle.sync();
+        if (params.durable !== false && target.createdForWrite) {
             await syncDirectoryBestEffort(path.dirname(target.realPath));
         }
     }
@@ -720,6 +724,7 @@ async function commitPinnedWriteInRoot(root, pinned, params) {
             renameIdentity: params.renameIdentity,
             mkdir: params.mkdir !== false,
             mode: params.mode ?? pinned.mode,
+            sync: params.durable !== false,
             overwrite: params.overwrite,
             input: { kind: "buffer", data: params.data, encoding: params.encoding },
             rootIdentity: root.rootIdentity,
@@ -803,12 +808,12 @@ async function copyFileInRoot(root, params) {
     }
 }
 async function assertCopySourceCurrent(source, identity) {
-    await inspectFileIdentity(() => source.handle.stat({ bigint: true }), identity);
+    await inspectFileIdentity(() => fsSync.fstatSync(source.handle.fd, { bigint: true }), identity);
     await assertCopySourcePathCurrent(source, identity);
 }
 async function assertCopySourcePathCurrent(source, identity) {
     await inspectFileIdentity(async () => {
-        const current = await fs.lstat(source.realPath, { bigint: true });
+        const current = fsSync.lstatSync(source.realPath, { bigint: true });
         if (current.isSymbolicLink() || !current.isFile()) {
             throw new FsSafeError("path-mismatch", "copy source path changed");
         }
@@ -817,7 +822,7 @@ async function assertCopySourcePathCurrent(source, identity) {
 }
 async function removePathIfIdentityUnchanged(targetPath, identity) {
     const parentGuard = await createAsyncDirectoryGuard(path.dirname(targetPath));
-    const current = await fs.lstat(targetPath);
+    const current = fsSync.lstatSync(targetPath);
     if (current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity)) {
         return;
     }
@@ -847,7 +852,7 @@ async function resolvePinnedWriteTargetInRoot(root, relativePath, requestedMode,
     // and alias checks, but never open a competing owner's record just to reject it.
     if (!overwrite) {
         try {
-            const existing = await fs.stat(resolved);
+            const existing = fsSync.statSync(resolved);
             if (!existing.isFile())
                 throw new FsSafeError("not-file", "not a file");
             if (existing.nlink > 1)
@@ -945,7 +950,7 @@ async function prepareRemoveGuard(targetPath) {
 async function removePathFallback(resolved) {
     const guard = await prepareRemoveGuard(resolved.resolved);
     try {
-        await ((await fs.lstat(resolved.resolved)).isDirectory() ? fs.rmdir(resolved.resolved) : fs.rm(resolved.resolved));
+        await (fsSync.lstatSync(resolved.resolved).isDirectory() ? fs.rmdir(resolved.resolved) : fs.rm(resolved.resolved));
     }
     catch (error) {
         throw normalizeRemovePathError(error);
@@ -961,7 +966,7 @@ async function mkdirPathFallback(resolved) {
 async function statPathFallback(root, relativePath) {
     const resolved = await resolvePinnedPathInRoot(root, { relativePath, allowRoot: true });
     try {
-        const stat = pathStatFromStats(await fs.lstat(resolved.resolved));
+        const stat = pathStatFromStats(fsSync.lstatSync(resolved.resolved));
         await assertRootIdentityCurrent(root);
         return stat;
     }
@@ -985,7 +990,7 @@ async function listPathFallback(root, relativePath, withFileTypes) {
         for (const name of sortedNames) {
             entries.push({
                 name,
-                ...pathStatFromStats(await fs.lstat(path.join(resolved.resolved, name))),
+                ...pathStatFromStats(fsSync.lstatSync(path.join(resolved.resolved, name))),
             });
         }
         await assertRootIdentityCurrent(root);
@@ -1034,7 +1039,11 @@ async function movePathFallback(root, params) {
                 relativePath: params.toRelative,
                 policy: PATH_ALIAS_POLICIES.unlinkTarget,
             });
-            const targetStat = await fs.lstat(resolvedTarget.resolved).catch(() => undefined);
+            let targetStat;
+            try {
+                targetStat = fsSync.lstatSync(resolvedTarget.resolved);
+            }
+            catch { /* Advisory lookup. */ }
             return !(process.platform !== "win32" &&
                 params.overwrite &&
                 targetStat?.isSymbolicLink() === true);
@@ -1042,7 +1051,7 @@ async function movePathFallback(root, params) {
     });
     let sourceStat;
     try {
-        sourceStat = await fs.lstat(source.resolved);
+        sourceStat = fsSync.lstatSync(source.resolved);
     }
     catch (error) {
         if (isNotFoundPathError(error)) {
@@ -1061,7 +1070,7 @@ async function movePathFallback(root, params) {
     }
     if (!params.overwrite) {
         try {
-            await fs.lstat(target.resolved);
+            fsSync.lstatSync(target.resolved);
             throw new FsSafeError("already-exists", "destination exists");
         }
         catch (error) {
@@ -1171,8 +1180,8 @@ async function writeMissingFileFallback(root, params) {
             const handle = await fs.open(targetPath, OPEN_WRITE_CREATE_FLAGS, params.mode ?? 0o600).catch((error) => recordExclusiveCreateFailure(error, targetPath));
             created = true;
             try {
-                createdIdentity = await handle.stat();
-                const writtenStat = await handle.stat({ bigint: true });
+                createdIdentity = fsSync.fstatSync(handle.fd);
+                const writtenStat = fsSync.fstatSync(handle.fd, { bigint: true });
                 if (typeof params.data === "string") {
                     await handle.writeFile(params.data, params.encoding ?? "utf8");
                 }

package/dist/root-path-existing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAqBA,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA0B7E"}
+{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAoBA,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA0B7E"}

package/dist/root-path-existing.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import fsp from "node:fs/promises";
 import path from "node:path";
 import { isNotFoundPathError } from "./path.js";
 function isFilesystemRoot(candidate) {
@@ -7,7 +6,7 @@ function isFilesystemRoot(candidate) {
 }
 async function pathExists(targetPath) {
     try {
-        await fsp.lstat(targetPath);
+        fs.lstatSync(targetPath);
         return true;
     }
     catch (error) {
@@ -33,7 +32,7 @@ export async function resolvePathViaExistingAncestor(targetPath) {
         return normalized;
     }
     try {
-        const resolvedAncestor = path.resolve(await fsp.realpath(cursor));
+        const resolvedAncestor = path.resolve(fs.realpathSync.native(cursor));
         return missingSuffix.length === 0
             ? resolvedAncestor
             : path.resolve(resolvedAncestor, ...missingSuffix);

package/dist/root-path-symlink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AAUA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAiBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAQR"}
+{"version":3,"file":"root-path-symlink.d.ts","sourceRoot":"","sources":["../src/root-path-symlink.ts"],"names":[],"mappings":"AASA,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAiBF,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,MAAM,CAAC,CAQjB;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAQR"}

package/dist/root-path-symlink.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import fsp from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { isNotFoundPathError, isSymlinkOpenError } from "./path.js";
@@ -16,11 +15,11 @@ function normalizeSymlinkResolutionError(error, options) {
 }
 export async function resolveSymlinkHopPath(symlinkPath, options = {}) {
     try {
-        return path.resolve(await fsp.realpath(symlinkPath));
+        return path.resolve(fs.realpathSync.native(symlinkPath));
     }
     catch (error) {
         normalizeSymlinkResolutionError(error, options);
-        const linkTarget = await fsp.readlink(symlinkPath);
+        const linkTarget = fs.readlinkSync(symlinkPath);
         return resolvePathViaExistingAncestor(path.resolve(path.dirname(symlinkPath), linkTarget));
     }
 }

package/dist/root-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAsCD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}
+{"version":3,"file":"root-path.d.ts","sourceRoot":"","sources":["../src/root-path.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E,KAAK,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,wBAAwB;aACnC,MAAM;;;;aAIN,YAAY;;;;CAIJ,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAEnF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC5B,CAAC;AAEF,wBAAsB,eAAe,CACnC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAsCD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,qBAAqB,GAAG,gBAAgB,CAMnF"}

package/dist/root-path.js

@@ -1,5 +1,4 @@
 import fs from "node:fs";
-import fsp from "node:fs/promises";
 import path from "node:path";
 import { formatErrorDetail, shortPath } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
@@ -234,7 +233,7 @@ async function resolveRootPathLexicalAsync(params) {
         state.lexicalCursor = path.join(state.lexicalCursor, segment);
         let stat;
         try {
-            stat = await fsp.lstat(state.lexicalCursor);
+            stat = fs.lstatSync(state.lexicalCursor);
         }
         catch (error) {
             if (handleLexicalLstatFailure(context, error, idx))
@@ -423,8 +422,8 @@ function buildResolvedRootPath(params) {
 async function getPathKind(absolutePath, preserveFinalSymlink) {
     try {
         const stat = preserveFinalSymlink
-            ? await fsp.lstat(absolutePath)
-            : await fsp.stat(absolutePath);
+            ? fs.lstatSync(absolutePath)
+            : fs.statSync(absolutePath);
         return { exists: true, kind: toResolvedKind(stat) };
     }
     catch (error) {

package/dist/root-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"root-paths.d.ts","sourceRoot":"","sources":["../src/root-paths.ts"],"names":[],"mappings":"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"}

package/dist/root-paths.js

@@ -1,3 +1,4 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { formatErrorDetail } from "./error-detail.js";
@@ -16,7 +17,7 @@ function pathStaysWithinRoot(rootDir, candidatePath) {
 }
 async function resolveRealPathIfExists(targetPath) {
     try {
-        return await fs.realpath(targetPath);
+        return fsSync.realpathSync.native(targetPath);
     }
     catch {
         return undefined;
@@ -24,11 +25,11 @@ async function resolveRealPathIfExists(targetPath) {
 }
 async function resolveTrustedRootRealPath(rootDir) {
     try {
-        const rootLstat = await fs.lstat(rootDir);
+        const rootLstat = fsSync.lstatSync(rootDir);
         if (!rootLstat.isDirectory() || rootLstat.isSymbolicLink()) {
             return undefined;
         }
-        return await fs.realpath(rootDir);
+        return fsSync.realpathSync.native(rootDir);
     }
     catch {
         return undefined;
@@ -36,7 +37,7 @@ async function resolveTrustedRootRealPath(rootDir) {
 }
 async function validateCanonicalPathWithinRoot(params) {
     try {
-        const candidateLstat = await fs.lstat(params.candidatePath);
+        const candidateLstat = fsSync.lstatSync(params.candidatePath);
         if (candidateLstat.isSymbolicLink()) {
             return "invalid";
         }
@@ -49,7 +50,7 @@ async function validateCanonicalPathWithinRoot(params) {
         if (params.expect === "file" && candidateLstat.nlink > 1) {
             return "invalid";
         }
-        const candidateRealPath = await fs.realpath(params.candidatePath);
+        const candidateRealPath = fsSync.realpathSync.native(params.candidatePath);
         return isPathInside(params.rootRealPath, candidateRealPath) ? "ok" : "invalid";
     }
     catch (err) {
@@ -109,7 +110,7 @@ async function resolveNearestExistingPath(targetPath) {
     let current = path.resolve(targetPath);
     while (true) {
         try {
-            await fs.lstat(current);
+            fsSync.lstatSync(current);
             return current;
         }
         catch (err) {
@@ -133,7 +134,7 @@ async function assertNoSymlinkSegments(params) {
     for (const segment of relative.split(path.sep).filter(Boolean)) {
         current = path.join(current, segment);
         try {
-            const stat = await fs.lstat(current);
+            const stat = fsSync.lstatSync(current);
             if (stat.isSymbolicLink()) {
                 throw new FsSafeError("symlink", `Invalid path: must not traverse symlinks within ${params.scopeLabel}`);
             }
@@ -163,14 +164,14 @@ export async function ensureDirectoryWithinRoot(params) {
             return lexical;
         const rootDir = path.resolve(params.rootDir);
         const targetPath = lexical.path;
-        const rootStat = await fs.lstat(rootDir);
+        const rootStat = fsSync.lstatSync(rootDir);
         if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
             return invalidPath(scopeLabel);
         }
         await assertNoSymlinkSegments({ rootDir, targetPath, scopeLabel });
-        const rootReal = await fs.realpath(rootDir);
+        const rootReal = fsSync.realpathSync.native(rootDir);
         const nearestExistingPath = await resolveNearestExistingPath(targetPath);
-        const nearestExistingReal = await fs.realpath(nearestExistingPath);
+        const nearestExistingReal = fsSync.realpathSync.native(nearestExistingPath);
         if (!isPathInside(rootReal, nearestExistingReal)) {
             return invalidPath(scopeLabel);
         }
@@ -180,7 +181,7 @@ export async function ensureDirectoryWithinRoot(params) {
             current = path.join(current, segment);
             while (true) {
                 try {
-                    const stat = await fs.lstat(current);
+                    const stat = fsSync.lstatSync(current);
                     if (stat.isSymbolicLink() || !stat.isDirectory()) {
                         return invalidPath(scopeLabel);
                     }
@@ -201,12 +202,12 @@ export async function ensureDirectoryWithinRoot(params) {
                     }
                 }
             }
-            const currentReal = await fs.realpath(current);
+            const currentReal = fsSync.realpathSync.native(current);
             if (!isPathInside(rootReal, currentReal)) {
                 return invalidPath(scopeLabel);
             }
         }
-        const targetReal = await fs.realpath(targetPath);
+        const targetReal = fsSync.realpathSync.native(targetPath);
         if (!isPathInside(rootReal, targetReal)) {
             return invalidPath(scopeLabel);
         }
@@ -308,7 +309,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
             return lexicalPathResult;
         }
         try {
-            const resolvedExistingPath = await fs.realpath(raw);
+            const resolvedExistingPath = fsSync.realpathSync.native(raw);
             const relativePath = path.relative(rootRealPath, resolvedExistingPath);
             if (!isInRoot(relativePath)) {
                 return lexicalPathResult;
@@ -350,7 +351,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
                         scopeLabel: params.scopeLabel,
                     });
                     const existingPath = await resolveNearestExistingPath(pathResult.fallbackPath);
-                    const existingRealPath = await fs.realpath(existingPath);
+                    const existingRealPath = fsSync.realpathSync.native(existingPath);
                     if (!isPathInside(rootRealPath, existingRealPath)) {
                         return invalidPath(params.scopeLabel);
                     }

package/dist/root-write-mode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-write-mode.d.ts","sourceRoot":"","sources":["../src/root-write-mode.ts"],"names":[],"mappings":"AASA,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwClB"}
+{"version":3,"file":"root-write-mode.d.ts","sourceRoot":"","sources":["../src/root-write-mode.ts"],"names":[],"mappings":"AAUA,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwClB"}

package/dist/root-write-mode.js

@@ -1,3 +1,4 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
@@ -8,7 +9,7 @@ import { inspectFileIdentity } from "./strict-file-identity.js";
 // The caller has already resolved and guarded this write target.
 export async function inheritWriteTargetMode(params) {
     try {
-        const existing = await inspectFileIdentity(() => fs.lstat(params.targetPath, { bigint: true }));
+        const existing = await inspectFileIdentity(() => fsSync.lstatSync(params.targetPath, { bigint: true }));
         if (existing.isSymbolicLink())
             throw new FsSafeError("path-alias", "path alias escape blocked");
         if (!existing.isFile())
@@ -22,7 +23,7 @@ export async function inheritWriteTargetMode(params) {
         const handle = await fs.open(params.targetPath, resolveReadOpenFlags());
         try {
             // Bind admission to the inode whose metadata is inherited.
-            if (!sameFileIdentity(await handle.stat({ bigint: true }), existing)) {
+            if (!sameFileIdentity(fsSync.fstatSync(handle.fd, { bigint: true }), existing)) {
                 throw new FsSafeError("path-mismatch", "write target changed during mode inheritance");
             }
         }
@@ -32,11 +33,11 @@ export async function inheritWriteTargetMode(params) {
         try {
             // A parent can change after guarded resolution. Do not inherit metadata
             // from an outside inode, even if the parent is restored before publication.
-            const realPath = await fs.realpath(params.targetPath);
+            const realPath = fsSync.realpathSync.native(params.targetPath);
             if (!isPathInside(params.rootWithSep, realPath))
                 throw outsideWorkspaceError();
             await inspectFileIdentity(async () => {
-                const current = await fs.stat(realPath, { bigint: true });
+                const current = fsSync.statSync(realPath, { bigint: true });
                 if (!current.isFile())
                     throw new FsSafeError("not-file", "not a file");
                 if (current.nlink > 1n)

package/dist/root-write-verification.js

@@ -46,16 +46,16 @@ export async function verifyAtomicWriteResult(params) {
     try {
         // This descriptor remains owned by the writer, even when final mode forbids opens.
         const stat = assertDescriptor();
-        assertPath(await fs.lstat(params.targetPath, { bigint: true }));
+        assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
         const { realPath } = await resolveOpenedFileRealPathForFd(params.fd, stat, params.targetPath);
-        assertPath(await fs.stat(realPath, { bigint: true }));
+        assertPath(fsSync.statSync(realPath, { bigint: true }));
         if (!isPathInside(params.root.rootWithSep, realPath)) {
             throw outsideWorkspaceError();
         }
         await assertAsyncDirectoryGuard(params.parentGuard);
         await assertRootIdentityCurrent(params.root);
         // Recheck after canonical resolution and directory checks, including late links.
-        assertPath(await fs.lstat(params.targetPath, { bigint: true }));
+        assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
         assertDescriptor();
         if (needsPathOpen) {
             // A retained fd cannot prove that an opaque Windows pathname still names it.
@@ -73,15 +73,15 @@ export async function verifyAtomicWriteResult(params) {
             });
             try {
                 const reopenedStat = assertDescriptor(opened.fd);
-                assertPath(await fs.lstat(params.targetPath, { bigint: true }));
+                assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
                 const { realPath: reopenedPath } = await resolveOpenedFileRealPathForFd(opened.fd, reopenedStat, params.targetPath);
-                assertPath(await fs.stat(reopenedPath, { bigint: true }));
+                assertPath(fsSync.statSync(reopenedPath, { bigint: true }));
                 if (!isPathInside(params.root.rootWithSep, reopenedPath)) {
                     throw outsideWorkspaceError();
                 }
                 await assertAsyncDirectoryGuard(params.parentGuard);
                 await assertRootIdentityCurrent(params.root);
-                assertPath(await fs.lstat(params.targetPath, { bigint: true }));
+                assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
                 assertDescriptor(opened.fd);
             }
             finally {

package/dist/secret-file.js

@@ -140,7 +140,7 @@ async function enforcePrivateDirectoryMode(params) {
 }
 async function inspectPrivateDirectory(directory, kind) {
     return await inspectFileIdentity(async () => {
-        const stat = await fsp.lstat(directory, { bigint: true });
+        const stat = fs.lstatSync(directory, { bigint: true });
         if (stat.isSymbolicLink()) {
             throw new Error(`Private secret ${kind} ${directory} must not be a symlink.`);
         }
@@ -260,7 +260,7 @@ export async function prepareSecretFileWrite(params) {
 async function materializeSecretFileAtomic(params, createOnly) {
     const { mode, rootGuard, parentGuard, fileName, finalFilePath } = await prepareSecretFileWrite(params);
     try {
-        const stat = await fsp.lstat(finalFilePath);
+        const stat = fs.lstatSync(finalFilePath);
         if (createOnly) {
             throw new FsSafeError("secret-exists", `Private secret file ${finalFilePath} already exists.`);
         }

package/dist/strict-file-identity.d.ts

@@ -1,6 +1,6 @@
 import type { BigIntStats } from "node:fs";
 type ExactFileIdentity = Pick<BigIntStats, "dev" | "ino">;
-export declare function inspectFileIdentity<T extends ExactFileIdentity>(inspect: () => Promise<T>, expected?: ExactFileIdentity, platform?: NodeJS.Platform): Promise<T>;
+export declare function inspectFileIdentity<T extends ExactFileIdentity>(inspect: () => T | Promise<T>, expected?: ExactFileIdentity, platform?: NodeJS.Platform): Promise<T>;
 export declare function inspectFileIdentitySync<T extends ExactFileIdentity>(inspect: () => T, expected?: ExactFileIdentity, platform?: NodeJS.Platform): T;
 export {};
 //# sourceMappingURL=strict-file-identity.d.ts.map

package/dist/strict-file-identity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strict-file-identity.d.ts","sourceRoot":"","sources":["../src/strict-file-identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,KAAK,iBAAiB,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AA+B1D,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,iBAAiB,EACnE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,iBAAiB,EACjE,OAAO,EAAE,MAAM,CAAC,EAChB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,CAAC,CAOH"}
+{"version":3,"file":"strict-file-identity.d.ts","sourceRoot":"","sources":["../src/strict-file-identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,KAAK,iBAAiB,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,CAAC,CAAC;AA+B1D,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,iBAAiB,EACnE,OAAO,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC7B,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,iBAAiB,EACjE,OAAO,EAAE,MAAM,CAAC,EAChB,QAAQ,CAAC,EAAE,iBAAiB,EAC5B,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,CAAC,CAOH"}

package/dist/symlink-parents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symlink-parents.d.ts","sourceRoot":"","sources":["../src/symlink-parents.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAyBF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,6BAA6B,GACpC,IAAI,CA6BN"}
+{"version":3,"file":"symlink-parents.d.ts","sourceRoot":"","sources":["../src/symlink-parents.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAyBF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,6BAA6B,GACpC,OAAO,CAAC,IAAI,CAAC,CA6Bf;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,6BAA6B,GACpC,IAAI,CA6BN"}

package/dist/symlink-parents.js

@@ -1,5 +1,4 @@
 import fsSync from "node:fs";
-import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { hasNodeErrorCode, isPathRelativeEscape } from "./path.js";
@@ -30,7 +29,7 @@ export async function assertNoSymlinkParents(params) {
     for (const [index, segment] of walk.segments.entries()) {
         current = path.join(current, segment);
         try {
-            const stat = await fs.lstat(current);
+            const stat = fsSync.lstatSync(current);
             if (stat.isSymbolicLink()) {
                 if (params.allowRootChildSymlink && path.dirname(current) === walk.root) {
                     continue;