@openclaw/fs-safe 0.17.0 → 0.18.0

package/dist/file-store-sync-directory.js

@@ -28,116 +28,6 @@ function inspectStoreDirectory(params) {
         return stat;
     }, params.expected);
 }
-function observeStoreDirectory(params) {
-    return {
-        dir: params.dir,
-        stat: inspectStoreDirectory(params),
-    };
-}
-function inspectReceiptCurrent(receipt, messagePrefix, root) {
-    try {
-        const stat = inspectStoreDirectory({
-            dir: receipt.dir,
-            expected: receipt.stat,
-            messagePrefix,
-            root,
-        });
-        if (stat.dev !== receipt.stat.dev || stat.ino !== receipt.stat.ino) {
-            throw changedStoreDirectory(messagePrefix);
-        }
-        return stat;
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-}
-function assertRootCurrent(rootReceipt, rootReal, messagePrefix) {
-    const stat = inspectReceiptCurrent(rootReceipt, messagePrefix, true);
-    try {
-        if (storeDirectoryRealPath(rootReceipt.dir) !== rootReal) {
-            throw changedStoreDirectory(messagePrefix);
-        }
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    return stat;
-}
-function assertAdmittedEdgeCurrent(receipts, rootReal, messagePrefix) {
-    const rootReceipt = receipts[0];
-    const targetIndex = receipts.length - 1;
-    const targetReceipt = receipts[targetIndex];
-    if (!rootReceipt || !targetReceipt) {
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    }
-    const rootStat = rootReal === undefined
-        ? inspectReceiptCurrent(rootReceipt, messagePrefix, true)
-        : assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    if (targetIndex === 0)
-        return rootStat;
-    const parent = receipts[targetIndex - 1];
-    if (!parent)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    if (targetIndex > 1)
-        inspectReceiptCurrent(parent, messagePrefix, false);
-    const targetStat = inspectReceiptCurrent(targetReceipt, messagePrefix, false);
-    if (path.dirname(targetReceipt.dir) !== parent.dir) {
-        throw changedStoreDirectory(messagePrefix);
-    }
-    return targetStat;
-}
-function assertModeTargetCurrent(receipts, rootReal, messagePrefix) {
-    const root = receipts[0];
-    const target = receipts.at(-1);
-    if (!root || !target)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    // The target's canonical observation shares the exact identity fence. Keep
-    // the trailing root canonical check: an ancestor relocation can retain IDs.
-    assertAdmittedEdgeCurrent(receipts, undefined, messagePrefix);
-    let targetReal;
-    try {
-        targetReal = storeDirectoryRealPath(target.dir);
-    }
-    catch (error) {
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    if (target === root ? targetReal !== rootReal : !isPathInside(rootReal, targetReal)) {
-        throw changedStoreDirectory(messagePrefix);
-    }
-    return assertAdmittedEdgeCurrent(receipts, rootReal, messagePrefix);
-}
-function assertReceiptChain(receipts, rootReal, messagePrefix) {
-    const rootReceipt = receipts[0];
-    const finalReceipt = receipts.at(-1);
-    if (!rootReceipt || !finalReceipt) {
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    }
-    assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    let finalStat = rootReceipt.stat;
-    for (const [index, receipt] of receipts.entries()) {
-        if (index === 0)
-            continue;
-        finalStat = inspectReceiptCurrent(receipt, messagePrefix, false);
-    }
-    let finalReal;
-    try {
-        finalReal = storeDirectoryRealPath(finalReceipt.dir);
-    }
-    catch (error) {
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-    if (!isPathInside(rootReal, finalReal))
-        throw changedStoreDirectory(messagePrefix);
-    assertRootCurrent(rootReceipt, rootReal, messagePrefix);
-    if (finalReceipt !== rootReceipt) {
-        finalStat = inspectReceiptCurrent(finalReceipt, messagePrefix, false);
-    }
-    return { finalReal, finalStat };
-}
 function directoryOpenFlags() {
     const { O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY } = fs.constants;
     if ([O_DIRECTORY, O_NOFOLLOW, O_NONBLOCK, O_RDONLY]
@@ -169,106 +59,209 @@ function hasErrorCode(error, code) {
     }
     return false;
 }
-function openStoreDirectoryForMode(params) {
-    let openError;
-    try {
-        return fs.openSync(pathForWindowsFilesystem(params.receipt.dir), directoryOpenFlags());
-    }
-    catch (error) {
-        openError = error;
+class StoreDirectoryChain {
+    messagePrefix;
+    receipts = [];
+    rootReal;
+    constructor(rootDir, messagePrefix) {
+        this.messagePrefix = messagePrefix;
+        this.observe(rootDir);
+        this.rootReal = storeDirectoryRealPath(rootDir);
+    }
+    observe(dir) {
+        this.receipts.push({
+            dir,
+            stat: inspectStoreDirectory({
+                dir,
+                messagePrefix: this.messagePrefix,
+                root: this.receipts.length === 0,
+            }),
+        });
     }
-    const searchFlags = hasErrorCode(openError, "EACCES") ? directorySearchFlags() : undefined;
-    if (searchFlags !== undefined) {
+    inspectReceipt(receipt, root = false) {
         try {
-            return fs.openSync(pathForWindowsFilesystem(params.receipt.dir), searchFlags);
+            const stat = inspectStoreDirectory({
+                dir: receipt.dir,
+                expected: receipt.stat,
+                messagePrefix: this.messagePrefix,
+                root,
+            });
+            if (stat.dev !== receipt.stat.dev || stat.ino !== receipt.stat.ino) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+            return stat;
         }
-        catch (searchError) {
-            openError = createSuppressedError(searchError, openError, "ordinary and search-only directory opens both failed");
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
     }
-    try {
-        assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-    }
-    catch (boundaryError) {
-        throw changedStoreDirectory(params.messagePrefix, createSuppressedError(boundaryError, openError, "directory acquisition and boundary revalidation both failed"));
-    }
-    if (hasErrorCode(openError, "EACCES")) {
-        throw new FsSafeError("permission-unverified", `${params.messagePrefix} directory cannot be safely mode-repaired through a Node descriptor`, { cause: openError });
-    }
-    throw openError;
-}
-function requestedDirectoryMode(mode) {
-    return BigInt(mode & 0o7777);
-}
-function inspectOpenedStoreDirectory(descriptor, receipt, messagePrefix) {
-    try {
-        const stat = inspectFileIdentitySync(() => fs.fstatSync(descriptor, { bigint: true }), receipt.stat);
-        if (!stat.isDirectory() || stat.isSymbolicLink()) {
-            throw changedStoreDirectory(messagePrefix);
+    assertRoot() {
+        const root = this.receipts[0];
+        const stat = this.inspectReceipt(root, true);
+        try {
+            if (storeDirectoryRealPath(root.dir) !== this.rootReal) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+        }
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
         return stat;
     }
-    catch (error) {
-        if (error instanceof FsSafeError && error.code === "outside-workspace")
-            throw error;
-        throw changedStoreDirectory(messagePrefix, error);
-    }
-}
-function finalizeDirectoryMode(params) {
-    const receipt = params.receipts.at(-1);
-    if (!receipt)
-        throw new FsSafeError("helper-failed", "store directory receipt is missing");
-    const requestedMode = requestedDirectoryMode(params.mode);
-    if ((receipt.stat.mode & 4095n) === requestedMode || process.platform === "win32") {
-        const current = assertAdmittedEdgeCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        // Identity can remain stable while permissions change after the first receipt.
-        if (process.platform === "win32" || (current.mode & 4095n) === requestedMode) {
-            return { ...receipt, stat: current };
+    assertEdge(canonicalRoot = true) {
+        const targetIndex = this.receipts.length - 1;
+        const rootStat = canonicalRoot
+            ? this.assertRoot() : this.inspectReceipt(this.receipts[0], true);
+        if (targetIndex === 0)
+            return rootStat;
+        const parent = this.receipts[targetIndex - 1];
+        if (targetIndex > 1)
+            this.inspectReceipt(parent);
+        const target = this.receipts[targetIndex];
+        const targetStat = this.inspectReceipt(target);
+        if (path.dirname(target.dir) !== parent.dir) {
+            throw changedStoreDirectory(this.messagePrefix);
         }
-    }
-    // Repair owns the stronger pre/post mode-target fence below, including an
-    // admission check on acquisition failure; no earlier admission is needed.
-    const descriptor = openStoreDirectoryForMode({
-        receipt,
-        receipts: params.receipts,
-        rootReal: params.rootReal,
-        messagePrefix: params.messagePrefix,
-    });
-    let finalStat;
-    let operationFailed = false;
-    let operationError;
-    try {
-        const opened = inspectOpenedStoreDirectory(descriptor, receipt, params.messagePrefix);
-        assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        if ((opened.mode & 4095n) !== requestedMode) {
-            fs.fchmodSync(descriptor, Number(requestedMode));
+        return targetStat;
+    }
+    assertModeTarget() {
+        const root = this.receipts[0];
+        const target = this.receipts.at(-1);
+        // The target's canonical observation shares the exact identity fence. Keep
+        // the trailing root canonical check: an ancestor relocation can retain IDs.
+        this.assertEdge(false);
+        let targetReal;
+        try {
+            targetReal = storeDirectoryRealPath(target.dir);
         }
-        const finalized = inspectOpenedStoreDirectory(descriptor, receipt, params.messagePrefix);
-        const pathname = assertModeTargetCurrent(params.receipts, params.rootReal, params.messagePrefix);
-        if ((finalized.mode & 4095n) !== requestedMode ||
-            (pathname.mode & 4095n) !== requestedMode) {
-            throw new FsSafeError("insecure-permissions", `${params.messagePrefix} directory mode could not be finalized`);
+        catch (error) {
+            throw changedStoreDirectory(this.messagePrefix, error);
         }
-        finalStat = pathname;
-    }
-    catch (error) {
-        operationFailed = true;
-        operationError = error;
+        if (target === root ? targetReal !== this.rootReal : !isPathInside(this.rootReal, targetReal)) {
+            throw changedStoreDirectory(this.messagePrefix);
+        }
+        return this.assertEdge();
+    }
+    finish(dir) {
+        const root = this.receipts[0];
+        const target = this.receipts.at(-1);
+        this.assertRoot();
+        let finalStat = root.stat;
+        for (const [index, receipt] of this.receipts.entries()) {
+            if (index === 0)
+                continue;
+            finalStat = this.inspectReceipt(receipt);
+        }
+        let finalReal;
+        try {
+            finalReal = storeDirectoryRealPath(target.dir);
+        }
+        catch (error) {
+            throw changedStoreDirectory(this.messagePrefix, error);
+        }
+        if (!isPathInside(this.rootReal, finalReal))
+            throw changedStoreDirectory(this.messagePrefix);
+        this.assertRoot();
+        if (target !== root)
+            finalStat = this.inspectReceipt(target);
+        return { dir, realPath: finalReal, exactStat: finalStat };
+    }
+    openForMode(receipt) {
+        let openError;
+        try {
+            return fs.openSync(pathForWindowsFilesystem(receipt.dir), directoryOpenFlags());
+        }
+        catch (error) {
+            openError = error;
+        }
+        const searchFlags = hasErrorCode(openError, "EACCES") ? directorySearchFlags() : undefined;
+        if (searchFlags !== undefined) {
+            try {
+                return fs.openSync(pathForWindowsFilesystem(receipt.dir), searchFlags);
+            }
+            catch (searchError) {
+                openError = createSuppressedError(searchError, openError, "ordinary and search-only directory opens both failed");
+            }
+        }
+        try {
+            this.assertModeTarget();
+        }
+        catch (boundaryError) {
+            throw changedStoreDirectory(this.messagePrefix, createSuppressedError(boundaryError, openError, "directory acquisition and boundary revalidation both failed"));
+        }
+        if (hasErrorCode(openError, "EACCES")) {
+            throw new FsSafeError("permission-unverified", `${this.messagePrefix} directory cannot be safely mode-repaired through a Node descriptor`, { cause: openError });
+        }
+        throw openError;
     }
-    try {
-        fs.closeSync(descriptor);
+    inspectOpened(descriptor, receipt) {
+        try {
+            const stat = inspectFileIdentitySync(() => fs.fstatSync(descriptor, { bigint: true }), receipt.stat);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                throw changedStoreDirectory(this.messagePrefix);
+            }
+            return stat;
+        }
+        catch (error) {
+            if (error instanceof FsSafeError && error.code === "outside-workspace")
+                throw error;
+            throw changedStoreDirectory(this.messagePrefix, error);
+        }
     }
-    catch (closeError) {
-        if (operationFailed) {
-            throw createSuppressedError(closeError, operationError, "store directory finalization and close both failed");
+    finalizeMode(mode) {
+        const receipt = this.receipts.at(-1);
+        const requestedMode = BigInt(mode & 0o7777);
+        if ((receipt.stat.mode & 4095n) === requestedMode || process.platform === "win32") {
+            const current = this.assertEdge();
+            // Identity can remain stable while permissions change after the first receipt.
+            if (process.platform === "win32" || (current.mode & 4095n) === requestedMode) {
+                this.receipts[this.receipts.length - 1] = { ...receipt, stat: current };
+                return;
+            }
+        }
+        // Repair owns the stronger pre/post mode-target fence below, including an
+        // admission check on acquisition failure; no earlier admission is needed.
+        const descriptor = this.openForMode(receipt);
+        let finalStat;
+        let operationFailed = false;
+        let operationError;
+        try {
+            const opened = this.inspectOpened(descriptor, receipt);
+            this.assertModeTarget();
+            if ((opened.mode & 4095n) !== requestedMode) {
+                fs.fchmodSync(descriptor, Number(requestedMode));
+            }
+            const finalized = this.inspectOpened(descriptor, receipt);
+            const pathname = this.assertModeTarget();
+            if ((finalized.mode & 4095n) !== requestedMode ||
+                (pathname.mode & 4095n) !== requestedMode) {
+                throw new FsSafeError("insecure-permissions", `${this.messagePrefix} directory mode could not be finalized`);
+            }
+            finalStat = pathname;
         }
-        throw closeError;
+        catch (error) {
+            operationFailed = true;
+            operationError = error;
+        }
+        try {
+            fs.closeSync(descriptor);
+        }
+        catch (closeError) {
+            if (operationFailed) {
+                throw createSuppressedError(closeError, operationError, "store directory finalization and close both failed");
+            }
+            throw closeError;
+        }
+        if (operationFailed)
+            throw operationError;
+        if (!finalStat)
+            throw new FsSafeError("helper-failed", "store directory mode receipt is missing");
+        this.receipts[this.receipts.length - 1] = { ...receipt, stat: finalStat };
     }
-    if (operationFailed)
-        throw operationError;
-    if (!finalStat)
-        throw new FsSafeError("helper-failed", "store directory mode receipt is missing");
-    return { ...receipt, stat: finalStat };
 }
 export function ensureSyncStoreDirectory(params) {
     assertNoWindowsPathAlias(params.rootDir, "filesystem", "store root uses a Windows filesystem namespace alias");
@@ -282,53 +275,23 @@ export function ensureSyncStoreDirectory(params) {
         throw new FsSafeError("outside-workspace", "file path escapes store root");
     }
     fs.mkdirSync(recursiveMkdirPath(pathForWindowsFilesystem(rootDir)), { recursive: true, mode: params.mode });
-    const receipts = [observeStoreDirectory({
-            dir: rootDir,
-            messagePrefix: params.messagePrefix,
-            root: true,
-        })];
-    const rootReal = storeDirectoryRealPath(rootDir);
-    receipts[0] = finalizeDirectoryMode({
-        receipts,
-        rootReal,
-        mode: params.mode,
-        messagePrefix: params.messagePrefix,
-    });
+    const chain = new StoreDirectoryChain(rootDir, params.messagePrefix);
+    chain.finalizeMode(params.mode);
     let current = rootDir;
     for (const segment of relative.split(path.sep).filter(Boolean)) {
         current = path.join(current, segment);
-        let receipt;
         try {
-            receipt = observeStoreDirectory({
-                dir: current,
-                messagePrefix: params.messagePrefix,
-                root: false,
-            });
+            chain.observe(current);
         }
         catch (error) {
             if (error.code !== "ENOENT")
                 throw error;
             fs.mkdirSync(pathForWindowsFilesystem(current), { mode: params.mode });
-            receipt = observeStoreDirectory({
-                dir: current,
-                messagePrefix: params.messagePrefix,
-                root: false,
-            });
+            chain.observe(current);
         }
-        receipts.push(receipt);
-        receipts[receipts.length - 1] = finalizeDirectoryMode({
-            receipts,
-            rootReal,
-            mode: params.mode,
-            messagePrefix: params.messagePrefix,
-        });
+        chain.finalizeMode(params.mode);
     }
-    const finalChain = assertReceiptChain(receipts, rootReal, params.messagePrefix);
-    return {
-        dir,
-        realPath: finalChain.finalReal,
-        exactStat: finalChain.finalStat,
-    };
+    return chain.finish(dir);
 }
 export function assertSyncStoreDirectoryReceipt(receipt) {
     try {

package/dist/file-store-sync-write.d.ts

@@ -7,4 +7,3 @@ export declare function writeFileSyncAtomic(params: {
     dirMode: number;
     mode: number;
 }): string;
-//# sourceMappingURL=file-store-sync-write.d.ts.map

package/dist/file-store-sync-write.js

@@ -4,21 +4,14 @@ import path from "node:path";
 import { syncDirectorySync } from "./directory-durability.js";
 import { createDirectoryReceiptFromIdentity } from "./directory-receipt.js";
 import { FsSafeError } from "./errors.js";
-import { assertSyncDirectoryGuard, ensureParentSync, ensureStoreDirectorySync, } from "./file-store-boundary.js";
+import { ensureParentSync, ensureStoreDirectorySync, } from "./file-store-boundary.js";
+import { assertSyncStoreDirectoryReceipt } from "./file-store-sync-directory.js";
 import { isPathInside } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { writeTempFileSync } from "./replace-file-descriptor.js";
 import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-function ensurePrivateDirectorySync(rootDir, targetDir, mode) {
-    return ensureStoreDirectorySync({
-        rootDir,
-        targetDir,
-        mode,
-        messagePrefix: "private store",
-    });
-}
 function verifyStoreFile(fd, expected, filePath) {
     const assertFile = (stat, allowUnknown = false) => {
         const unknown = allowUnknown && process.platform === "win32" && (stat.dev === 0n || stat.ino === 0n);
@@ -55,7 +48,12 @@ export function writeFileSyncAtomic(params) {
     }
     let parentGuard;
     if (params.privateMode) {
-        parentGuard = ensurePrivateDirectorySync(params.rootDir, path.dirname(filePath), params.dirMode);
+        parentGuard = ensureStoreDirectorySync({
+            rootDir: params.rootDir,
+            targetDir: path.dirname(filePath),
+            mode: params.dirMode,
+            messagePrefix: "private store",
+        });
         try {
             const stat = fs.lstatSync(filePath);
             if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -75,14 +73,12 @@ export function writeFileSyncAtomic(params) {
             mode: params.dirMode,
         });
     }
-    const tempPath = path.join(parentGuard?.dir ?? path.dirname(filePath), `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
+    const tempPath = path.join(parentGuard.dir, `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
     const owner = new SyncAtomicTempOwner(tempPath);
     let originalFailure;
     try {
         getFsSafeTestHooks()?.beforeFileStoreSyncPrivateWrite?.(filePath);
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         owner.start();
         const temp = writeTempFileSync({
             fsModule: fs, tempPath, content: params.content, mode: params.mode, sync: false,
@@ -101,14 +97,10 @@ export function writeFileSyncAtomic(params) {
         if (params.durable)
             fs.fsyncSync(temp.fd);
         verifyStoreFile(temp.fd, owner.identity, tempPath);
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         fs.renameSync(tempPath, filePath);
         owner.markRenamed();
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-        }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         try {
             verifyStoreFile(temp.fd, owner.identity, filePath);
         }
@@ -120,13 +112,11 @@ export function writeFileSyncAtomic(params) {
                 cause: error instanceof Error ? error : undefined,
             });
         }
-        if (parentGuard) {
-            assertSyncDirectoryGuard(parentGuard);
-            if (params.durable) {
-                syncDirectorySync(createDirectoryReceiptFromIdentity(parentGuard.dir, parentGuard.realPath, parentGuard.exactStat), { label: "store parent" });
-            }
-            assertSyncDirectoryGuard(parentGuard);
+        assertSyncStoreDirectoryReceipt(parentGuard);
+        if (params.durable) {
+            syncDirectorySync(createDirectoryReceiptFromIdentity(parentGuard.dir, parentGuard.realPath, parentGuard.exactStat), { label: "store parent" });
         }
+        assertSyncStoreDirectoryReceipt(parentGuard);
         return filePath;
     }
     catch (error) {

package/dist/file-store.d.ts

@@ -63,4 +63,3 @@ export type FileStoreSync = {
 };
 export declare function fileStore(options: FileStoreOptions): FileStore;
 export declare function fileStoreSync(options: FileStoreOptions): FileStoreSync;
-//# sourceMappingURL=file-store.d.ts.map

package/dist/file-store.js

@@ -74,18 +74,17 @@ async function copyIntoRoot(params) {
         throw new FsSafeError("not-file", "source path is not a file");
     }
     assertFileStoreMaxBytes(sourceStat.size, params.maxBytes);
-    const dirMode = params.dirMode ?? 0o700;
     const scopedRoot = await openWritableStoreRoot({
         rootDir: params.rootDir,
-        dirMode,
+        dirMode: params.dirMode,
         maxBytes: params.maxBytes,
     });
-    await ensureParentInRoot(scopedRoot, relativePath, dirMode);
+    await ensureParentInRoot(scopedRoot, relativePath, params.dirMode);
     await scopedRoot.copyIn(relativePath, params.sourcePath, {
         durable: params.durable,
         maxBytes: params.maxBytes,
         mkdir: false,
-        mode: params.mode ?? 0o600,
+        mode: params.mode,
     });
     return destination;
 }

package/dist/file-sync.d.ts

@@ -2,4 +2,3 @@ import fs from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 export declare function syncFileBestEffort(handle: Pick<FileHandle, "sync">): Promise<void>;
 export declare function syncFileBestEffortSync(fd: number, fsModule?: Pick<typeof fs, "fsyncSync">): void;
-//# sourceMappingURL=file-sync.d.ts.map

package/dist/filename.d.ts

@@ -6,4 +6,3 @@ export declare function fitFileNameToPortableComponent(params: {
     suffix: string;
 }): string;
 export declare function sanitizeUntrustedFileName(fileName: string, fallbackName: string): string;
-//# sourceMappingURL=filename.d.ts.map

package/dist/filename.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { WINDOWS_RESERVED_DEVICE_NAMES } from "./device-path.js";
 import { maxNormalizedUtf8Bytes } from "./unicode-path.js";
+import { hasWindowsDrivePrefix } from "./windows-path-syntax.js";
 const INVALID_FILE_NAME_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/g;
 const HAS_INVALID_FILE_NAME_CHARACTER = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/;
 const HAS_RETAINED_FILE_NAME_CHARACTER = /[^\u0000-\u001f\u007f-\u009f<>:"/\\|?*\s]/;
@@ -53,13 +54,6 @@ function isBoundedSanitizedFileName(fileName, trimmedFileName) {
         !HAS_INVALID_FILE_NAME_CHARACTER.test(fileName) &&
         suffixWindowsReservedDeviceName(fileName) === fileName;
 }
-function hasWindowsDrivePrefix(value) {
-    if (value.length < 2 || value.charCodeAt(1) !== 0x3a)
-        return false;
-    const firstCodeUnit = value.charCodeAt(0);
-    return (firstCodeUnit >= 0x41 && firstCodeUnit <= 0x5a) ||
-        (firstCodeUnit >= 0x61 && firstCodeUnit <= 0x7a);
-}
 function normalizedFileNameBytes(value) {
     return maxNormalizedUtf8Bytes(value, true);
 }

package/dist/fs.d.ts

@@ -10,4 +10,3 @@ export declare function pathExists(filePath: string): Promise<boolean>;
  * semantics.
  */
 export declare function pathExistsSync(filePath: string): boolean;
-//# sourceMappingURL=fs.d.ts.map

package/dist/guarded-mkdir.d.ts

@@ -23,4 +23,3 @@ export declare function mkdirPathComponentsWithGuards(params: {
     retainedTargetPath?: string;
     rootIdentity?: RootBoundaryIdentity;
 }): Promise<string>;
-//# sourceMappingURL=guarded-mkdir.d.ts.map

package/dist/guarded-mutation.d.ts

@@ -13,21 +13,15 @@ export declare function guardedRename(params: {
     onRenamed?: () => void;
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRenameSync(params: {
     from: string;
     to: string;
-    targetRoot?: string;
-    verifyAfter?: boolean;
 }): void;
 export declare function guardedRm(params: {
     target: string;
     assertBeforeMutation?: () => void;
     recursive?: boolean;
-    force?: boolean;
-    verifyAfter?: boolean;
 }): Promise<void>;
 export declare function guardedRmSync(params: {
     target: string;
@@ -36,4 +30,3 @@ export declare function guardedRmSync(params: {
     force?: boolean;
     verifyAfter?: boolean;
 }): void;
-//# sourceMappingURL=guarded-mutation.d.ts.map