@openclaw/fs-safe 0.17.0 → 0.18.1

package/dist/json-durable-queue-ownership.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import { syncDirectory } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
-import { inspectFileIdentity } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { serializePathWrite } from "./write-queue.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 const validatedDurableQueueEntryPaths = new WeakSet();
@@ -45,12 +45,14 @@ function processingPathFromJsonPath(jsonPath) {
         ? `${jsonPath.slice(0, -".json".length)}.processing`
         : `${jsonPath}.processing`;
 }
-async function regularQueueFileIdentity(filePath) {
-    const identity = await lstatOrNull(filePath);
+function regularQueueFileIdentity(filePath, subject = "entry") {
+    const identity = lstatOrNull(filePath);
     if (!identity)
         return null;
     if (identity.isSymbolicLink() || !identity.isFile()) {
-        throw new Error(`queue entry is not a regular file: ${filePath}`);
+        throw subject === "retirement"
+            ? new FsSafeError("path-mismatch", "queue retirement path is not a regular file")
+            : new Error(`queue entry is not a regular file: ${filePath}`);
     }
     return identity;
 }
@@ -62,9 +64,9 @@ async function withQueueEntryLock(paths, run) {
 async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     const processingPath = paths.processingPath;
     await recoverDurableQueueRetirement({ jsonPath: paths.jsonPath, processingPath });
-    const existingProcessing = await regularQueueFileIdentity(processingPath);
+    const existingProcessing = regularQueueFileIdentity(processingPath);
     if (existingProcessing) {
-        const pending = await lstatOrNull(paths.jsonPath);
+        const pending = lstatOrNull(paths.jsonPath);
         const retiresPending = pending !== null &&
             !pending.isSymbolicLink() &&
             pending.isFile() &&
@@ -80,7 +82,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
         }
         return processingPath;
     }
-    const pending = await lstatOrNull(paths.jsonPath);
+    const pending = lstatOrNull(paths.jsonPath);
     if (!pending || pending.isSymbolicLink() || !pending.isFile())
         return null;
     if (pending.nlink > 1n || !sameFileIdentityForCleanup(pending, pending)) {
@@ -94,7 +96,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     }
     catch (error) {
         if (getErrorCode(error) === "EEXIST") {
-            if (!(await regularQueueFileIdentity(processingPath)))
+            if (!regularQueueFileIdentity(processingPath))
                 return null;
             await syncDirectory(path.dirname(processingPath));
             return processingPath;
@@ -104,7 +106,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
         throw error;
     }
     await syncDirectory(path.dirname(processingPath));
-    const claimed = await regularQueueFileIdentity(processingPath);
+    const claimed = regularQueueFileIdentity(processingPath);
     if (!claimed || claimed.nlink > 2n) {
         throw new FsSafeError("path-mismatch", "queue claim is not an owned regular file");
     }
@@ -113,7 +115,7 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
 }
 export async function claimDurableQueueEntry(paths, options = {}) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.jsonPath)))
         return null;
     return await withQueueEntryLock(validatedPaths, async () => await claimDurableQueueEntryUnlocked(validatedPaths, options));
 }
@@ -122,9 +124,9 @@ export async function migrateDurableQueueEntry(paths, expected, releaseReadPin,
     const validatedPaths = ownDurableQueueEntryPaths(paths);
     return await withQueueEntryLock(validatedPaths, async () => {
         const processingPath = validatedPaths.processingPath;
-        const assertCurrent = async () => {
+        const assertCurrent = () => {
             try {
-                await inspectFileIdentity(() => {
+                inspectFileIdentitySync(() => {
                     const current = fsSync.lstatSync(processingPath, { bigint: true });
                     if (current.isSymbolicLink() || !current.isFile() || current.nlink !== 1n) {
                         throw new FsSafeError("path-mismatch", "queue migration requires its original processing claim");
@@ -139,26 +141,26 @@ export async function migrateDurableQueueEntry(paths, expected, releaseReadPin,
                 throw error;
             }
         };
-        await assertCurrent();
+        assertCurrent();
         return await run(processingPath, async () => {
-            await assertCurrent();
+            assertCurrent();
             if (process.platform === "win32") {
                 // Windows cannot replace our still-open target. Keep the transfer lock
                 // across release and reject changes made while the async close settles.
                 await releaseReadPin();
-                await assertCurrent();
+                assertCurrent();
             }
         });
     });
 }
 export async function completeDeliveredQueueEntry(paths) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.deliveredPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.deliveredPath)))
         return false;
     return await withQueueEntryLock(validatedPaths, async () => {
-        if (!(await regularQueueFileIdentity(validatedPaths.deliveredPath)))
+        if (!regularQueueFileIdentity(validatedPaths.deliveredPath))
             return false;
-        const processing = await regularQueueFileIdentity(validatedPaths.processingPath);
+        const processing = regularQueueFileIdentity(validatedPaths.processingPath);
         await fs.unlink(validatedPaths.deliveredPath);
         await syncDirectory(path.dirname(validatedPaths.deliveredPath));
         return !processing;
@@ -166,18 +168,18 @@ export async function completeDeliveredQueueEntry(paths) {
 }
 export async function acknowledgeDurableQueueEntry(paths) {
     const validatedPaths = ownDurableQueueEntryPaths(paths);
-    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
+    if (!lstatOrNull(path.dirname(validatedPaths.jsonPath)))
         return;
     await withQueueEntryLock(validatedPaths, async () => {
         const processingPath = validatedPaths.processingPath;
-        const processing = await regularQueueFileIdentity(processingPath);
-        const delivered = await regularQueueFileIdentity(validatedPaths.deliveredPath);
+        const processing = regularQueueFileIdentity(processingPath);
+        const delivered = regularQueueFileIdentity(validatedPaths.deliveredPath);
         if (!processing) {
             if (delivered) {
                 await fs.unlink(validatedPaths.deliveredPath);
             }
             await syncDirectory(path.dirname(validatedPaths.deliveredPath));
-            if (await regularQueueFileIdentity(validatedPaths.jsonPath)) {
+            if (regularQueueFileIdentity(validatedPaths.jsonPath)) {
                 throw new FsSafeError("path-mismatch", "queue acknowledgement requires a processing claim");
             }
             return;
@@ -198,17 +200,17 @@ export async function moveDurableQueueEntryToFailed(params) {
     assertNoWindowsPathAlias(failedPath);
     await withQueueEntryLock(paths, async () => {
         const processingPath = paths.processingPath;
-        const processing = await regularQueueFileIdentity(processingPath);
-        const existingFailed = await regularQueueFileIdentity(failedPath);
+        const processing = regularQueueFileIdentity(processingPath);
+        const existingFailed = regularQueueFileIdentity(failedPath);
         if (!processing && existingFailed) {
             await syncDirectory(path.dirname(failedPath));
             await syncDirectory(path.dirname(processingPath));
-            const recoveredFailed = await regularQueueFileIdentity(failedPath);
+            const recoveredFailed = regularQueueFileIdentity(failedPath);
             if (!recoveredFailed ||
                 !sameFileIdentityForCleanup(existingFailed, recoveredFailed)) {
                 throw new FsSafeError("path-mismatch", "failed queue destination changed during recovery");
             }
-            if (await regularQueueFileIdentity(paths.jsonPath)) {
+            if (regularQueueFileIdentity(paths.jsonPath)) {
                 throw new FsSafeError("already-exists", "failed queue destination already exists");
             }
             return;
@@ -219,18 +221,13 @@ export async function moveDurableQueueEntryToFailed(params) {
         if (!sourcePath) {
             throw Object.assign(new Error("queue entry does not exist"), { code: "ENOENT" });
         }
-        const source = await regularQueueFileIdentity(sourcePath);
-        const failed = await regularQueueFileIdentity(failedPath);
-        if (failed) {
-            if (source && sameFileIdentityForCleanup(source, failed)) {
-                await syncDirectory(path.dirname(failedPath));
-                await fs.unlink(sourcePath);
-                await syncDirectory(path.dirname(sourcePath));
-                return;
-            }
+        const source = regularQueueFileIdentity(sourcePath);
+        const failed = regularQueueFileIdentity(failedPath);
+        if (failed && (!source || !sameFileIdentityForCleanup(source, failed))) {
             throw new FsSafeError("already-exists", "failed queue destination already exists");
         }
-        await fs.link(sourcePath, failedPath);
+        if (!failed)
+            await fs.link(sourcePath, failedPath);
         await syncDirectory(path.dirname(failedPath));
         await fs.unlink(sourcePath);
         await syncDirectory(path.dirname(sourcePath));
@@ -243,7 +240,7 @@ export function getErrorCode(error) {
         ? String(error.code)
         : null;
 }
-async function lstatOrNull(filePath) {
+function lstatOrNull(filePath) {
     try {
         return fsSync.lstatSync(filePath, { bigint: true });
     }
@@ -258,28 +255,11 @@ function assertDirectory(identity, label) {
         throw new FsSafeError("path-mismatch", `${label} is not an owned directory`);
     }
 }
-async function regularFileIdentity(filePath) {
-    const identity = await lstatOrNull(filePath);
-    if (!identity)
-        return null;
-    if (identity.isSymbolicLink() || !identity.isFile()) {
-        throw new FsSafeError("path-mismatch", "queue retirement path is not a regular file");
-    }
-    return identity;
-}
 function retirementPaths(jsonPath) {
     const rootPath = path.join(path.dirname(jsonPath), RETIREMENT_ROOT_NAME);
     const dirPath = path.join(rootPath, path.basename(jsonPath));
     return { dirPath, entryPath: path.join(dirPath, RETIREMENT_ENTRY_NAME), rootPath };
 }
-async function inspectRetirementRoot(jsonPath) {
-    const rootPath = retirementPaths(jsonPath).rootPath;
-    const root = await lstatOrNull(rootPath);
-    if (!root)
-        return null;
-    assertDirectory(root, "queue retirement root");
-    return rootPath;
-}
 async function ensureRetirementRoot(jsonPath) {
     const parentPath = path.dirname(jsonPath);
     const rootPath = retirementPaths(jsonPath).rootPath;
@@ -300,11 +280,12 @@ async function removeRetirementRecord(params) {
     await syncDirectory(params.rootPath);
 }
 async function recoverDurableQueueRetirement(params) {
-    const rootPath = await inspectRetirementRoot(params.jsonPath);
-    if (!rootPath)
+    const { rootPath, dirPath, entryPath } = retirementPaths(params.jsonPath);
+    const root = lstatOrNull(rootPath);
+    if (!root)
         return;
-    const { dirPath, entryPath } = retirementPaths(params.jsonPath);
-    const dir = await lstatOrNull(dirPath);
+    assertDirectory(root, "queue retirement root");
+    const dir = lstatOrNull(dirPath);
     if (!dir)
         return;
     assertDirectory(dir, "queue retirement record");
@@ -316,13 +297,13 @@ async function recoverDurableQueueRetirement(params) {
     if (names.length !== 1 || names[0] !== RETIREMENT_ENTRY_NAME) {
         throw new FsSafeError("path-mismatch", "queue retirement record is ambiguous");
     }
-    const entry = await regularFileIdentity(entryPath);
-    const processing = await regularFileIdentity(params.processingPath);
+    const entry = regularQueueFileIdentity(entryPath, "retirement");
+    const processing = regularQueueFileIdentity(params.processingPath, "retirement");
     if (!entry || !processing) {
         throw new FsSafeError("path-mismatch", "queue retirement ownership is incomplete");
     }
     if (!sameFileIdentityForCleanup(entry, processing)) {
-        const pending = await regularFileIdentity(params.jsonPath);
+        const pending = regularQueueFileIdentity(params.jsonPath, "retirement");
         if (!pending) {
             await fs.link(entryPath, params.jsonPath);
             await syncDirectory(path.dirname(params.jsonPath));

package/dist/json-durable-queue-read.d.ts

@@ -3,4 +3,3 @@ export declare const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES: number;
 export declare function withJsonDurableQueueEntry<T, R>(filePath: string, options: {
     maxBytes?: number;
 }, run: (entry: T, identity: BigIntStats, releaseReadPin: () => Promise<void>) => Promise<R>): Promise<R>;
-//# sourceMappingURL=json-durable-queue-read.d.ts.map

package/dist/json-durable-queue-read.js

@@ -2,13 +2,13 @@ import fs, {} from "node:fs";
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { readBoundedAsync } from "./bounded-read.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { inspectFileIdentity } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
-async function inspectQueueEntry(inspect, maxBytes, expected) {
+function inspectQueueEntry(inspect, maxBytes, expected) {
     let inspectionFailed = false;
     try {
-        return await inspectFileIdentity(async () => {
+        return inspectFileIdentitySync(() => {
             try {
                 const stat = inspect();
                 if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -39,13 +39,14 @@ export async function withJsonDurableQueueEntry(filePath, options, run) {
     });
     assertNoWindowsPathAlias(filePath);
     const inspectPath = () => fs.lstatSync(filePath, { bigint: true });
-    const initialStat = await inspectQueueEntry(inspectPath, maxBytes);
+    const initialStat = inspectQueueEntry(inspectPath, maxBytes);
     const handle = await fs.promises.open(filePath, resolveReadOpenFlags());
     let closePromise;
     const releaseReadPin = () => closePromise ??= (async () => { await handle.close(); })();
+    let result;
     try {
-        const openedStat = await inspectQueueEntry(() => fs.fstatSync(handle.fd, { bigint: true }), maxBytes, initialStat);
-        await inspectQueueEntry(inspectPath, maxBytes, openedStat);
+        const openedStat = inspectQueueEntry(() => fs.fstatSync(handle.fd, { bigint: true }), maxBytes, initialStat);
+        inspectQueueEntry(inspectPath, maxBytes, openedStat);
         const bytes = await readBoundedAsync(maxBytes, async (buffer, length) => (await handle.read(buffer, 0, length, null)).bytesRead, {
             initialSize: openedStat.size >= 0n && Number.isSafeInteger(Number(openedStat.size))
                 ? Number(openedStat.size) : undefined,
@@ -53,9 +54,12 @@ export async function withJsonDurableQueueEntry(filePath, options, run) {
         });
         // The migration owner may release this pin only at the verified publication
         // boundary; until then an unlinked inode cannot be recycled into a new claim.
-        return await run(JSON.parse(bytes.toString("utf8")), openedStat, releaseReadPin);
+        result = await run(JSON.parse(bytes.toString("utf8")), openedStat, releaseReadPin);
     }
-    finally {
-        await releaseReadPin();
+    catch (error) {
+        await releaseReadPin().catch(() => undefined);
+        throw error;
     }
+    await releaseReadPin();
+    return result;
 }

package/dist/json-durable-queue.d.ts

@@ -43,4 +43,3 @@ export declare function moveJsonDurableQueueEntryToFailed(params: {
     failedDir: string;
     id: string;
 }): Promise<void>;
-//# sourceMappingURL=json-durable-queue.d.ts.map

package/dist/json-durable-queue.js

@@ -1,17 +1,13 @@
 import fs, {} from "node:fs";
 import path from "node:path";
 import { syncDirectory } from "./directory-durability.js";
-import { syncQueueDirectoryCreation } from "./json-durable-queue-directory.js";
-import { queueValidationRoot, queueValidationRoots, resolveQueueFilesystemPath, } from "./json-durable-queue-paths.js";
+import { queueDirectories } from "./json-durable-queue-directory.js";
 import { getErrorCode, acknowledgeDurableQueueEntry, claimDurableQueueEntry, completeDeliveredQueueEntry, migrateDurableQueueEntry, moveDurableQueueEntryToFailed, validateDurableQueueEntryPaths, } from "./json-durable-queue-ownership.js";
 import { withJsonDurableQueueEntry } from "./json-durable-queue-read.js";
 import { stringifyJsonDocument } from "./json-stringify.js";
-import { realpathSync } from "./realpath.js";
-import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { replaceFileAtomicWithDirectorySync } from "./replace-file.js";
 import { assertSafePathSegment } from "./safe-path-segment.js";
-import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
-import { assertNoWindowsPathAlias, hasWindowsPathAlias, } from "./windows-path-alias.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias, hasWindowsPathAlias, } from "./windows-path-alias.js";
 export { DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES } from "./json-durable-queue-read.js";
 function assertSafeQueueEntryId(id) {
     assertSafePathSegment(id, { label: "queue entry id" });
@@ -61,129 +57,9 @@ export async function ensureJsonDurableQueueDirs(params) {
     const failedDir = params.failedDir;
     assertNoWindowsPathAlias(queueDir);
     assertNoWindowsPathAlias(failedDir);
-    const roots = await queueValidationRoots(queueDir, failedDir);
-    await ensureJsonDurableQueueDir(queueDir, roots.queueRoot);
-    await ensureJsonDurableQueueDir(failedDir, roots.failedRoot);
-}
-async function ensureJsonDurableQueueDir(dir, validationRoot) {
-    const root = validationRoot
-        ? validationRoot
-        : queueValidationRoot(dir);
-    await assertNoSymlinkDirectorySegments(root, dir, true);
-    await fs.promises.mkdir(recursiveMkdirPath(dir), { recursive: true, mode: 0o700 });
-    await assertNoSymlinkDirectorySegments(root, dir, false);
-    await chmodQueueDirectory(dir);
-    await syncQueueDirectoryCreation(dir, root.path);
-}
-async function assertJsonDurableQueueDir(dir, validationRoot) {
-    const root = validationRoot
-        ? validationRoot
-        : queueValidationRoot(dir);
-    await assertNoSymlinkDirectorySegments(root, dir, false);
-}
-async function isDarwinSystemAlias(dir, stat) {
-    if (process.platform !== "darwin" || !stat.isSymbolicLink()) {
-        return false;
-    }
-    const resolved = path.resolve(dir);
-    if (resolved !== "/tmp" && resolved !== "/var") {
-        return false;
-    }
-    try {
-        return realpathSync.native(resolved) === `/private${resolved}`;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertNoSymlinkDirectorySegments(validationRoot, dir, allowMissing) {
-    let base = resolveQueueFilesystemPath(validationRoot.path);
-    let target = resolveQueueFilesystemPath(dir);
-    let current = base;
-    let baseStat = fs.lstatSync(base);
-    if (baseStat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
-        const relative = path.relative(base, target);
-        if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-            throw new Error(`durable queue path is not a directory: ${dir}`);
-        }
-        base = realpathSync.native(base);
-        target = path.join(base, ...relative.split(path.sep).filter(Boolean));
-        current = base;
-        baseStat = fs.lstatSync(base);
-    }
-    if (baseStat.isSymbolicLink() || !baseStat.isDirectory()) {
-        throw new Error(`durable queue path is not a directory: ${dir}`);
-    }
-    const segments = path.relative(base, target).split(path.sep).filter(Boolean);
-    for (let index = 0; index < segments.length; index++) {
-        const segment = segments[index];
-        if (segment === undefined) {
-            continue;
-        }
-        current = path.join(current, segment);
-        let stat;
-        try {
-            stat = fs.lstatSync(current);
-        }
-        catch (error) {
-            if (allowMissing && error.code === "ENOENT") {
-                return;
-            }
-            throw error;
-        }
-        if (stat.isSymbolicLink() || !stat.isDirectory()) {
-            if (stat.isSymbolicLink() && validationRoot.allowSymlinkBase) {
-                if (await isDarwinSystemAlias(current, stat)) {
-                    current = realpathSync.native(current);
-                    continue;
-                }
-            }
-            throw new Error(`durable queue path is not a directory: ${dir}`);
-        }
-    }
-}
-async function chmodQueueDirectory(dir) {
-    const noFollow = typeof fs.constants.O_NOFOLLOW === "number" && process.platform !== "win32"
-        ? fs.constants.O_NOFOLLOW
-        : 0;
-    const directoryFlag = typeof fs.constants.O_DIRECTORY === "number" && process.platform !== "win32"
-        ? fs.constants.O_DIRECTORY
-        : 0;
-    if (noFollow || directoryFlag) {
-        let handle;
-        try {
-            handle = await fs.promises.open(dir, fs.constants.O_RDONLY | noFollow | directoryFlag);
-            const stat = fs.fstatSync(handle.fd);
-            if (!stat.isDirectory()) {
-                throw new Error(`durable queue path is not a directory: ${dir}`);
-            }
-            try {
-                await handle.chmod(0o700);
-            }
-            catch {
-                // Best-effort on platforms that do not enforce POSIX modes.
-            }
-            return;
-        }
-        finally {
-            try {
-                await handle?.close();
-            }
-            catch {
-                // Best-effort cleanup after chmod/open failures.
-            }
-        }
-    }
-    const stat = fs.lstatSync(dir);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`durable queue path is not a directory: ${dir}`);
-    }
-    try {
-        await fs.promises.chmod(dir, 0o700);
-    }
-    catch {
-        // Best-effort on platforms that do not enforce POSIX modes.
-    }
+    const directories = await queueDirectories(queueDir, failedDir);
+    await directories.queue.ensure();
+    await directories.failed.ensure();
 }
 export async function writeJsonDurableQueueEntry(params) {
     await writeQueueEntry(params);
@@ -328,9 +204,9 @@ export async function moveJsonDurableQueueEntryToFailed(params) {
     assertSafeQueueEntryId(id);
     assertNoWindowsPathAlias(queueDir);
     assertNoWindowsPathAlias(failedDir);
-    const roots = await queueValidationRoots(queueDir, failedDir);
-    await assertJsonDurableQueueDir(queueDir, roots.queueRoot);
-    await ensureJsonDurableQueueDir(failedDir, roots.failedRoot);
+    const directories = await queueDirectories(queueDir, failedDir);
+    await directories.queue.assert();
+    await directories.failed.ensure();
     const paths = validateDurableQueueEntryPaths(resolveJsonDurableQueueEntryPaths(queueDir, id));
     await moveDurableQueueEntryToFailed({
         paths,

package/dist/json-store.d.ts

@@ -6,4 +6,3 @@ export type JsonStoreOptions<T> = JsonFileStoreOptions & {
 };
 export type { JsonFileStoreOptions, JsonStore, JsonStoreLockOptions };
 export declare function jsonStore<T>(options: JsonStoreOptions<T>): JsonStore<T>;
-//# sourceMappingURL=json-store.d.ts.map

package/dist/json-store.js

@@ -1,8 +1,7 @@
 import path from "node:path";
 import { fileStore } from "./file-store.js";
 import {} from "./json-document-store.js";
-import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
-import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export function jsonStore(options) {
     const filePathInput = admitStandalonePublicationPath(options.filePath);
     const filePath = path.resolve(filePathInput);

package/dist/json-stringify.d.ts

@@ -1,2 +1 @@
 export declare function stringifyJsonDocument(value: unknown, replacer?: Parameters<typeof JSON.stringify>[1], space?: Parameters<typeof JSON.stringify>[2]): string;
-//# sourceMappingURL=json-stringify.d.ts.map

package/dist/json.d.ts

@@ -47,4 +47,3 @@ export declare function readJsonIfExists<T>(filePath: string, options?: ReadJson
 export declare function readJsonSync<T = unknown>(filePath: string, options?: ReadJsonOptions): T;
 export type WriteJsonOptions = Pick<WriteTextAtomicOptions, "dirMode" | "durable" | "mode" | "trailingNewline">;
 export declare function writeJson(filePath: string, value: unknown, options?: WriteJsonOptions): Promise<void>;
-//# sourceMappingURL=json.d.ts.map

package/dist/json.js

@@ -9,31 +9,27 @@ import { openRootFileSync } from "./root-file.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { writeTempFileSync } from "./replace-file-descriptor.js";
 import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
-import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { writeTextAtomic } from "./text-atomic.js";
 import { sleep } from "./timing.js";
-import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 const READ_RETRY_MAX_ATTEMPTS = 5;
 const READ_RETRY_BASE_DELAY_MS = 50;
-function isRetryableReadError(err, options) {
+function isRetryableReadError(err) {
     if (err instanceof FsSafeError && err.code === "path-mismatch") {
         return true;
     }
-    if (options.retryOpenRaceErrors !== true) {
-        return false;
-    }
     const code = getErrorCode(err);
     return code === "ENOENT" || code === "EPERM";
 }
-async function readRegularFileWithRetry(filePath, options = {}) {
+async function readRegularFileWithRetry(filePath, maxBytes) {
     let lastErr;
     for (let attempt = 0; attempt < READ_RETRY_MAX_ATTEMPTS; attempt++) {
         try {
-            return (await readRegularFile({ filePath, maxBytes: options.maxBytes })).buffer;
+            return (await readRegularFile({ filePath, maxBytes })).buffer;
         }
         catch (err) {
             lastErr = err;
-            if (!isRetryableReadError(err, options) || attempt === READ_RETRY_MAX_ATTEMPTS - 1) {
+            if (!isRetryableReadError(err) || attempt === READ_RETRY_MAX_ATTEMPTS - 1) {
                 throw err;
             }
             await sleep(READ_RETRY_BASE_DELAY_MS * Math.pow(2, attempt));
@@ -46,10 +42,7 @@ async function readRegularFileIfExistsWithRetry(filePath, options = {}) {
     if (initial.missing) {
         return null;
     }
-    return await readRegularFileWithRetry(filePath, {
-        maxBytes: options.maxBytes,
-        retryOpenRaceErrors: true,
-    });
+    return await readRegularFileWithRetry(filePath, options.maxBytes);
 }
 const JSON_FILE_MODE = 0o600;
 const JSON_DIR_MODE = 0o700;
@@ -269,10 +262,7 @@ export async function tryReadJson(filePath, options = {}) {
 export async function readJson(filePath, options = {}) {
     let raw;
     try {
-        raw = (await readRegularFileWithRetry(filePath, {
-            maxBytes: options.maxBytes,
-            retryOpenRaceErrors: true,
-        })).toString("utf8");
+        raw = (await readRegularFileWithRetry(filePath, options.maxBytes)).toString("utf8");
     }
     catch (err) {
         throw new JsonFileReadError(filePath, "read", err);

package/dist/local-file-access.d.ts

@@ -6,4 +6,3 @@ export declare function assertNoWindowsNetworkPath(filePath: string, label?: str
 export declare function safeFileURLToPath(fileUrl: string, platform?: NodeJS.Platform): string;
 export declare function trySafeFileURLToPath(fileUrl: string, platform?: NodeJS.Platform): string | undefined;
 export declare function basenameFromMediaSource(source?: string): string | undefined;
-//# sourceMappingURL=local-file-access.d.ts.map

package/dist/local-file-access.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { fileURLToPath, URL } from "node:url";
 import { normalizeLowercaseStringOrEmpty } from "./string-coerce.js";
 import { hasWindowsPathAlias } from "./windows-path-alias.js";
+import { isWindowsSeparator, rootedWindowsDriveColonIndex, windowsNamespaceMarker, } from "./windows-path-syntax.js";
 const ENCODED_FILE_URL_SEPARATOR_RE = /%(?:2f|5c)/i;
 const FILE_URL_PREFIX_RE = /^file:\/\//i;
 export function isFileUrl(input) {
@@ -18,16 +19,8 @@ export function isWindowsNetworkPath(filePath, platform = process.platform) {
     if (platform !== "win32") {
         return false;
     }
-    const normalized = filePath.replace(/\//g, "\\");
-    const extendedDrive = normalized.length >= 7 &&
-        normalized.startsWith("\\\\?\\") &&
-        /^[a-z]$/i.test(normalized[4] ?? "") &&
-        normalized[5] === ":" &&
-        normalized[6] === "\\";
-    if (extendedDrive) {
-        return false;
-    }
-    return normalized.startsWith("\\\\");
+    return isWindowsSeparator(filePath, 0) && isWindowsSeparator(filePath, 1) &&
+        !(windowsNamespaceMarker(filePath) === "?" && rootedWindowsDriveColonIndex(filePath) === 5);
 }
 export function isWindowsDriveLetterPath(filePath, platform = process.platform) {
     return platform === "win32" && /^[A-Za-z]:[\\/]/.test(filePath);

package/dist/local-file-descriptor.d.ts

@@ -14,4 +14,3 @@ export declare function openLocalFileDescriptor(filePath: string, options?: {
     readWrite?: true;
 }): Promise<OwnedLocalFile>;
 export {};
-//# sourceMappingURL=local-file-descriptor.d.ts.map

package/dist/local-roots.d.ts

@@ -23,4 +23,3 @@ export type ReadLocalFileFromRootsOptions = LocalRootsInputOptions & {
 };
 export declare function resolveLocalPathFromRootsSync(options: ResolveLocalPathFromRootsSyncOptions): LocalRootsPathResult | null;
 export declare function readLocalFileFromRoots(options: ReadLocalFileFromRootsOptions): Promise<LocalRootsReadResult | null>;
-//# sourceMappingURL=local-roots.d.ts.map

package/dist/lock-config.d.ts

@@ -7,4 +7,3 @@ export type FsSafeLockConfig = {
 };
 export declare function configureFsSafeLocks(config: Partial<FsSafeLockConfig>): void;
 export declare function getFsSafeLockConfig(): FsSafeLockConfig;
-//# sourceMappingURL=lock-config.d.ts.map

package/dist/move-path-cleanup.d.ts

@@ -28,4 +28,3 @@ export declare function assertSourceStillMatches(sourcePath: string, identity: E
 export declare function createCleanupCopiedEntryState(sourcePath: string, manifest: CopiedEntryManifest): CleanupCopiedEntryState;
 export declare function cleanupCopiedEntry(sourcePath: string, manifest: CopiedEntryManifest, state: CleanupCopiedEntryState, assertBeforeMutation: (() => void) | undefined): Promise<CleanupCopiedEntryResult>;
 export {};
-//# sourceMappingURL=move-path-cleanup.d.ts.map

package/dist/move-path-stage.d.ts

@@ -5,4 +5,3 @@ export declare function createMoveStageOwner(staged: string): Promise<{
     published(): void;
     cleanup(): Promise<void>;
 }>;
-//# sourceMappingURL=move-path-stage.d.ts.map

package/dist/move-path.d.ts

@@ -18,4 +18,3 @@ type MoveCopyFallbackReason = "cross-device" | "windows-rename-denied";
 export declare function moveCopyFallbackReasonForRenameError(error: unknown, platform?: NodeJS.Platform): MoveCopyFallbackReason | undefined;
 export declare function movePathWithCopyFallback(options: MovePathWithCopyFallbackOptions): Promise<void>;
 export {};
-//# sourceMappingURL=move-path.d.ts.map