@openclaw/fs-safe 0.12.0 → 0.13.0

package/dist/install-path.js

@@ -3,6 +3,7 @@ import fsSync from "node:fs";
 import path from "node:path";
 import { isPathInside } from "./path.js";
 import { realpathSync } from "./realpath.js";
+import { hasWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export function safeDirName(input) {
     const trimmed = input.trim();
     if (!trimmed) {
@@ -40,10 +41,24 @@ export function safePathSegmentHashedV2(input) {
     return `id-v2-${hash}`;
 }
 export function resolveSafeInstallDir(params) {
+    const baseDir = params.baseDir;
+    if (hasWindowsPathAlias(baseDir, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
     const encodedName = (params.nameEncoder ?? safeDirName)(params.id);
-    const targetDir = path.join(params.baseDir, encodedName);
-    const resolvedBase = path.resolve(params.baseDir);
+    if (hasWindowsPathAlias(encodedName, "relative")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
+    const targetDir = path.join(baseDir, encodedName);
+    if (hasWindowsPathAlias(targetDir, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
+    const resolvedBase = resolvePathPreservingWindowsRoot(baseDir);
     const resolvedTarget = path.resolve(targetDir);
+    if (hasWindowsPathAlias(resolvedBase, "filesystem") ||
+        hasWindowsPathAlias(resolvedTarget, "filesystem")) {
+        return { ok: false, error: params.invalidNameMessage };
+    }
     const relative = path.relative(resolvedBase, resolvedTarget);
     if (!relative ||
         relative === ".." ||
@@ -54,40 +69,58 @@ export function resolveSafeInstallDir(params) {
     return { ok: true, path: resolvedTarget };
 }
 export async function assertCanonicalPathWithinBase(params) {
-    const baseDir = path.resolve(params.baseDir);
-    const candidatePath = path.resolve(params.candidatePath);
+    const baseDirInput = params.baseDir;
+    const candidatePathInput = params.candidatePath;
+    const boundaryLabel = params.boundaryLabel;
+    const invalidPath = () => new Error(`Invalid path: must stay within ${boundaryLabel}`);
+    const assertAdmittedPath = (value) => {
+        if (hasWindowsPathAlias(value, "filesystem"))
+            throw invalidPath();
+    };
+    assertAdmittedPath(baseDirInput);
+    assertAdmittedPath(candidatePathInput);
+    const baseDir = resolvePathPreservingWindowsRoot(baseDirInput);
+    const candidatePath = resolvePathPreservingWindowsRoot(candidatePathInput);
+    assertAdmittedPath(baseDir);
+    assertAdmittedPath(candidatePath);
     if (!isPathInside(baseDir, candidatePath)) {
-        throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+        throw invalidPath();
     }
-    const baseLstat = fsSync.lstatSync(baseDir);
+    const baseOperationPath = pathForWindowsFilesystem(baseDir);
+    const baseLstat = fsSync.lstatSync(baseOperationPath);
     if (baseLstat.isSymbolicLink()) {
-        const baseStat = fsSync.statSync(baseDir);
+        const baseStat = fsSync.statSync(baseOperationPath);
         if (!baseStat.isDirectory()) {
-            throw new Error(`Invalid ${params.boundaryLabel}: base directory must resolve to a directory`);
+            throw new Error(`Invalid ${boundaryLabel}: base directory must resolve to a directory`);
         }
     }
     else if (!baseLstat.isDirectory()) {
-        throw new Error(`Invalid ${params.boundaryLabel}: base directory must be a directory`);
+        throw new Error(`Invalid ${boundaryLabel}: base directory must be a directory`);
     }
-    const baseRealPath = realpathSync.native(baseDir);
+    const baseRealPath = realpathSync.native(baseOperationPath);
+    assertAdmittedPath(baseRealPath);
     const validateDirectory = async (dirPath) => {
-        const resolvedDirPath = path.resolve(dirPath);
-        const dirLstat = fsSync.lstatSync(dirPath);
+        assertAdmittedPath(dirPath);
+        const resolvedDirPath = resolvePathPreservingWindowsRoot(dirPath);
+        assertAdmittedPath(resolvedDirPath);
+        const operationPath = pathForWindowsFilesystem(dirPath);
+        const dirLstat = fsSync.lstatSync(operationPath);
         if (dirLstat.isSymbolicLink()) {
             if (resolvedDirPath !== baseDir) {
-                throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+                throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
             }
-            const dirStat = fsSync.statSync(dirPath);
+            const dirStat = fsSync.statSync(operationPath);
             if (!dirStat.isDirectory()) {
-                throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+                throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
             }
         }
         else if (!dirLstat.isDirectory()) {
-            throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+            throw new Error(`Invalid path: must stay within ${boundaryLabel}`);
         }
-        const dirRealPath = realpathSync.native(dirPath);
+        const dirRealPath = realpathSync.native(operationPath);
+        assertAdmittedPath(dirRealPath);
         if (!isPathInside(baseRealPath, dirRealPath)) {
-            throw new Error(`Invalid path: must stay within ${params.boundaryLabel}`);
+            throw invalidPath();
         }
     };
     try {
@@ -100,5 +133,7 @@ export async function assertCanonicalPathWithinBase(params) {
             throw err;
         }
     }
-    await validateDirectory(path.dirname(candidatePath));
+    const candidateParent = path.dirname(candidatePath);
+    assertAdmittedPath(candidateParent);
+    await validateDirectory(candidateParent);
 }

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

@@ -4,6 +4,12 @@ export type DurableQueueEntryPathsLike = {
     deliveredPath: string;
     processingPath?: string;
 };
+export type ValidatedDurableQueueEntryPaths = Readonly<{
+    jsonPath: string;
+    deliveredPath: string;
+    processingPath: string;
+}>;
+export declare function validateDurableQueueEntryPaths(paths: DurableQueueEntryPathsLike): ValidatedDurableQueueEntryPaths;
 export declare function durableQueueProcessingPath(paths: DurableQueueEntryPathsLike): string;
 export declare function claimDurableQueueEntry(paths: DurableQueueEntryPathsLike, options?: {
     skipUnowned?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"json-durable-queue-ownership.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-ownership.ts"],"names":[],"mappings":"AAEA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AASnD,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAKpF;AAwED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGxB;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAC9C,KAAK,EAAE,0BAA0B,EACjC,QAAQ,EAAE,WAAW,EACrB,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACnC,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxE,OAAO,CAAC,CAAC,CAAC,CAkCZ;AAED,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,OAAO,CAAC,CAalB;AAED,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED,wBAAsB,6BAA6B,CAAC,MAAM,EAAE;IAC1D,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDhB;AAKD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI1D"}
+{"version":3,"file":"json-durable-queue-ownership.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-ownership.ts"],"names":[],"mappings":"AAEA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAUnD,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC,CAAC;AAUH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,0BAA0B,GAChC,+BAA+B,CAkBjC;AAiBD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,0BAA0B,GAAG,MAAM,CAIpF;AA0ED,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,0BAA0B,EACjC,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,GACtC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOxB;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAC9C,KAAK,EAAE,0BAA0B,EACjC,QAAQ,EAAE,WAAW,EACrB,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACnC,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxE,OAAO,CAAC,CAAC,CAAC,CAmCZ;AAED,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,OAAO,CAAC,CAclB;AAED,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAED,wBAAsB,6BAA6B,CAAC,MAAM,EAAE;IAC1D,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDhB;AAKD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI1D"}

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

@@ -8,12 +8,48 @@ import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { serializePathWrite } from "./write-queue.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+const validatedDurableQueueEntryPaths = new WeakSet();
+function assertQueuePathString(value, label) {
+    if (typeof value !== "string") {
+        throw new FsSafeError("invalid-path", `${label} must be a string`);
+    }
+}
+export function validateDurableQueueEntryPaths(paths) {
+    const jsonPath = paths.jsonPath;
+    const deliveredPath = paths.deliveredPath;
+    const requestedProcessingPath = paths.processingPath;
+    assertQueuePathString(jsonPath, "queue JSON path");
+    assertQueuePathString(deliveredPath, "queue delivered path");
+    if (requestedProcessingPath !== undefined) {
+        assertQueuePathString(requestedProcessingPath, "queue processing path");
+    }
+    assertNoWindowsPathAlias(jsonPath);
+    assertNoWindowsPathAlias(deliveredPath);
+    if (requestedProcessingPath !== undefined) {
+        assertNoWindowsPathAlias(requestedProcessingPath);
+    }
+    const processingPath = requestedProcessingPath || processingPathFromJsonPath(jsonPath);
+    const validated = Object.freeze({ deliveredPath, jsonPath, processingPath });
+    validatedDurableQueueEntryPaths.add(validated);
+    return validated;
+}
+function ownDurableQueueEntryPaths(paths) {
+    if (validatedDurableQueueEntryPaths.has(paths)) {
+        return paths;
+    }
+    return validateDurableQueueEntryPaths(paths);
+}
+function processingPathFromJsonPath(jsonPath) {
+    return jsonPath.endsWith(".json")
+        ? `${jsonPath.slice(0, -".json".length)}.processing`
+        : `${jsonPath}.processing`;
+}
 export function durableQueueProcessingPath(paths) {
-    if (paths.processingPath)
-        return paths.processingPath;
-    return paths.jsonPath.endsWith(".json")
-        ? `${paths.jsonPath.slice(0, -".json".length)}.processing`
-        : `${paths.jsonPath}.processing`;
+    const processingPath = paths.processingPath;
+    if (processingPath)
+        return processingPath;
+    return processingPathFromJsonPath(paths.jsonPath);
 }
 async function regularQueueFileIdentity(filePath) {
     const identity = await lstatOrNull(filePath);
@@ -25,10 +61,12 @@ async function regularQueueFileIdentity(filePath) {
     return identity;
 }
 async function withQueueEntryLock(paths, run) {
-    return await serializePathWrite(paths.jsonPath, async () => await withQueueTransferLock(path.resolve(paths.jsonPath), run));
+    const resolvedJsonPath = path.resolve(paths.jsonPath);
+    assertNoWindowsPathAlias(resolvedJsonPath);
+    return await serializePathWrite(paths.jsonPath, async () => await withQueueTransferLock(resolvedJsonPath, run));
 }
 async function claimDurableQueueEntryUnlocked(paths, options = {}) {
-    const processingPath = durableQueueProcessingPath(paths);
+    const processingPath = paths.processingPath;
     await recoverDurableQueueRetirement({ jsonPath: paths.jsonPath, processingPath });
     const existingProcessing = await regularQueueFileIdentity(processingPath);
     if (existingProcessing) {
@@ -80,14 +118,16 @@ async function claimDurableQueueEntryUnlocked(paths, options = {}) {
     return processingPath;
 }
 export async function claimDurableQueueEntry(paths, options = {}) {
-    if (!(await lstatOrNull(path.dirname(paths.jsonPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
         return null;
-    return await withQueueEntryLock(paths, async () => await claimDurableQueueEntryUnlocked(paths, options));
+    return await withQueueEntryLock(validatedPaths, async () => await claimDurableQueueEntryUnlocked(validatedPaths, options));
 }
 // The caller retains its read pin until this owner releases it or migration settles.
 export async function migrateDurableQueueEntry(paths, expected, releaseReadPin, run) {
-    return await withQueueEntryLock(paths, async () => {
-        const processingPath = durableQueueProcessingPath(paths);
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    return await withQueueEntryLock(validatedPaths, async () => {
+        const processingPath = validatedPaths.processingPath;
         const assertCurrent = async () => {
             try {
                 await inspectFileIdentity(() => {
@@ -118,83 +158,90 @@ export async function migrateDurableQueueEntry(paths, expected, releaseReadPin,
     });
 }
 export async function completeDeliveredQueueEntry(paths) {
-    if (!(await lstatOrNull(path.dirname(paths.deliveredPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.deliveredPath))))
         return false;
-    return await withQueueEntryLock(paths, async () => {
-        if (!(await regularQueueFileIdentity(paths.deliveredPath)))
+    return await withQueueEntryLock(validatedPaths, async () => {
+        if (!(await regularQueueFileIdentity(validatedPaths.deliveredPath)))
             return false;
-        if (await regularQueueFileIdentity(durableQueueProcessingPath(paths))) {
-            await fs.unlink(paths.deliveredPath);
-            await syncDirectory(path.dirname(paths.deliveredPath));
+        if (await regularQueueFileIdentity(validatedPaths.processingPath)) {
+            await fs.unlink(validatedPaths.deliveredPath);
+            await syncDirectory(path.dirname(validatedPaths.deliveredPath));
             return false;
         }
-        await fs.unlink(paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
+        await fs.unlink(validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
         return true;
     });
 }
 export async function acknowledgeDurableQueueEntry(paths) {
-    if (!(await lstatOrNull(path.dirname(paths.jsonPath))))
+    const validatedPaths = ownDurableQueueEntryPaths(paths);
+    if (!(await lstatOrNull(path.dirname(validatedPaths.jsonPath))))
         return;
-    await withQueueEntryLock(paths, async () => {
-        const processingPath = durableQueueProcessingPath(paths);
+    await withQueueEntryLock(validatedPaths, async () => {
+        const processingPath = validatedPaths.processingPath;
         const processing = await regularQueueFileIdentity(processingPath);
-        const delivered = await regularQueueFileIdentity(paths.deliveredPath);
+        const delivered = await regularQueueFileIdentity(validatedPaths.deliveredPath);
         if (!processing) {
             if (delivered) {
-                await fs.unlink(paths.deliveredPath);
+                await fs.unlink(validatedPaths.deliveredPath);
             }
-            await syncDirectory(path.dirname(paths.deliveredPath));
-            if (await regularQueueFileIdentity(paths.jsonPath)) {
+            await syncDirectory(path.dirname(validatedPaths.deliveredPath));
+            if (await regularQueueFileIdentity(validatedPaths.jsonPath)) {
                 throw new FsSafeError("path-mismatch", "queue acknowledgement requires a processing claim");
             }
             return;
         }
         if (delivered)
-            await fs.unlink(paths.deliveredPath);
-        await fs.rename(processingPath, paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
-        await fs.unlink(paths.deliveredPath);
-        await syncDirectory(path.dirname(paths.deliveredPath));
+            await fs.unlink(validatedPaths.deliveredPath);
+        await fs.rename(processingPath, validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
+        await fs.unlink(validatedPaths.deliveredPath);
+        await syncDirectory(path.dirname(validatedPaths.deliveredPath));
     });
 }
 export async function moveDurableQueueEntryToFailed(params) {
-    await withQueueEntryLock(params.paths, async () => {
-        const processingPath = durableQueueProcessingPath(params.paths);
+    const pathsInput = params.paths;
+    const paths = ownDurableQueueEntryPaths(pathsInput);
+    const failedPath = params.failedPath;
+    assertQueuePathString(failedPath, "failed queue path");
+    assertNoWindowsPathAlias(failedPath);
+    await withQueueEntryLock(paths, async () => {
+        const processingPath = paths.processingPath;
         const processing = await regularQueueFileIdentity(processingPath);
-        const existingFailed = await regularQueueFileIdentity(params.failedPath);
+        const existingFailed = await regularQueueFileIdentity(failedPath);
         if (!processing && existingFailed) {
-            await syncDirectory(path.dirname(params.failedPath));
+            await syncDirectory(path.dirname(failedPath));
             await syncDirectory(path.dirname(processingPath));
-            const recoveredFailed = await regularQueueFileIdentity(params.failedPath);
+            const recoveredFailed = await regularQueueFileIdentity(failedPath);
             if (!recoveredFailed ||
                 !sameFileIdentityForCleanup(existingFailed, recoveredFailed)) {
                 throw new FsSafeError("path-mismatch", "failed queue destination changed during recovery");
             }
-            if (await regularQueueFileIdentity(params.paths.jsonPath)) {
+            if (await regularQueueFileIdentity(paths.jsonPath)) {
                 throw new FsSafeError("already-exists", "failed queue destination already exists");
             }
             return;
         }
         const sourcePath = processing
             ? processingPath
-            : await claimDurableQueueEntryUnlocked(params.paths);
+            : await claimDurableQueueEntryUnlocked(paths);
         if (!sourcePath) {
             throw Object.assign(new Error("queue entry does not exist"), { code: "ENOENT" });
         }
         const source = await regularQueueFileIdentity(sourcePath);
-        const failed = await regularQueueFileIdentity(params.failedPath);
+        const failed = await regularQueueFileIdentity(failedPath);
         if (failed) {
             if (source && sameFileIdentityForCleanup(source, failed)) {
-                await syncDirectory(path.dirname(params.failedPath));
+                await syncDirectory(path.dirname(failedPath));
                 await fs.unlink(sourcePath);
                 await syncDirectory(path.dirname(sourcePath));
                 return;
             }
             throw new FsSafeError("already-exists", "failed queue destination already exists");
         }
-        await fs.link(sourcePath, params.failedPath);
-        await syncDirectory(path.dirname(params.failedPath));
+        await fs.link(sourcePath, failedPath);
+        await syncDirectory(path.dirname(failedPath));
         await fs.unlink(sourcePath);
         await syncDirectory(path.dirname(sourcePath));
     });

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

@@ -0,0 +1,11 @@
+export type QueueValidationRoot = {
+    path: string;
+    allowSymlinkBase: boolean;
+};
+export declare function resolveQueueFilesystemPath(value: string): string;
+export declare function queueValidationRoots(queueDir: string, failedDir: string): Promise<{
+    queueRoot: QueueValidationRoot;
+    failedRoot: QueueValidationRoot;
+}>;
+export declare function queueValidationRoot(dir: string): QueueValidationRoot;
+//# sourceMappingURL=json-durable-queue-paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-durable-queue-paths.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-paths.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhE;AAqBD,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,SAAS,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAU9E;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAKpE"}

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

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+export function resolveQueueFilesystemPath(value) {
+    const resolved = resolvePathPreservingWindowsRoot(value);
+    assertNoWindowsPathAlias(resolved);
+    return resolved;
+}
+function commonPathAncestor(paths) {
+    const resolved = paths.map(resolveQueueFilesystemPath);
+    const root = path.parse(resolved[0] ?? process.cwd()).root;
+    const parts = resolved.map((entry) => path.relative(root, entry).split(path.sep));
+    const common = [];
+    for (let index = 0; parts.every((part) => index < part.length); index++) {
+        const segment = parts[0]?.[index];
+        if (!segment || !parts.every((part) => part[index] === segment))
+            break;
+        common.push(segment);
+    }
+    return path.join(root, ...common);
+}
+function samePathRoot(paths) {
+    const roots = paths.map((entry) => path.parse(resolveQueueFilesystemPath(entry)).root);
+    const first = process.platform === "win32" ? roots[0]?.toLowerCase() : roots[0];
+    return roots.every((root) => (process.platform === "win32" ? root.toLowerCase() : root) === first);
+}
+export async function queueValidationRoots(queueDir, failedDir) {
+    if (samePathRoot([queueDir, failedDir])) {
+        const common = commonPathAncestor([queueDir, failedDir]);
+        const root = queueValidationRoot(common);
+        return { failedRoot: root, queueRoot: root };
+    }
+    return {
+        failedRoot: queueValidationRoot(failedDir),
+        queueRoot: queueValidationRoot(queueDir),
+    };
+}
+export function queueValidationRoot(dir) {
+    return {
+        path: path.parse(resolveQueueFilesystemPath(dir)).root,
+        allowSymlinkBase: process.platform === "darwin",
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"json-durable-queue-read.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-read.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM/C,eAAO,MAAM,0CAA0C,QAAmB,CAAC;AA8B3E,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9B,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,CAAC,CA8BZ"}
+{"version":3,"file":"json-durable-queue-read.d.ts","sourceRoot":"","sources":["../src/json-durable-queue-read.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAO/C,eAAO,MAAM,0CAA0C,QAAmB,CAAC;AA8B3E,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAC9B,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GACxF,OAAO,CAAC,CAAC,CAAC,CA+BZ"}

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

@@ -3,6 +3,7 @@ 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 { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export const DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES = 16 * 1024 * 1024;
 async function inspectQueueEntry(inspect, maxBytes, expected) {
     let inspectionFailed = false;
@@ -36,6 +37,7 @@ export async function withJsonDurableQueueEntry(filePath, options, run) {
     const maxBytes = normalizeMaxBytes(options.maxBytes, {
         defaultValue: DEFAULT_JSON_DURABLE_QUEUE_ENTRY_MAX_BYTES,
     });
+    assertNoWindowsPathAlias(filePath);
     const inspectPath = () => fs.lstatSync(filePath, { bigint: true });
     const initialStat = await inspectQueueEntry(inspectPath, maxBytes);
     const handle = await fs.promises.open(filePath, resolveReadOpenFlags());

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

@@ -1 +1 @@
-{"version":3,"file":"json-durable-queue.d.ts","sourceRoot":"","sources":["../src/json-durable-queue.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,0CAA0C,EAAE,MAAM,8BAA8B,CAAC;AAE1F,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAWF,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtE;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpF;AAmBD,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,0BAA0B,CAO5B;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAiLD,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;AAgBD,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,CAAC,CAAC,CAEZ;AAgBD,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/F;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAqBpB;AAED,wBAAsB,kCAAkC,CAAC,CAAC,EACxD,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,EAAE,CAAC,CAqEd;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,OAAO,CAAC,IAAI,CAAC,CAShB"}
+{"version":3,"file":"json-durable-queue.d.ts","sourceRoot":"","sources":["../src/json-durable-queue.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAE,0CAA0C,EAAE,MAAM,8BAA8B,CAAC;AAE1F,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAMF,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGtE;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAWpF;AAmBD,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,0BAA0B,CAQ5B;AAED,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQhB;AAwID,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;AAmBD,wBAAsB,yBAAyB,CAAC,CAAC,EAC/C,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GAClC,OAAO,CAAC,CAAC,CAAC,CAEZ;AAgBD,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/F;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE;IACzD,KAAK,EAAE,0BAA0B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAwBpB;AAED,wBAAsB,kCAAkC,CAAC,CAAC,EACxD,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,GACtC,OAAO,CAAC,CAAC,EAAE,CAAC,CA2Ed;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,OAAO,CAAC,IAAI,CAAC,CAehB"}