@poe-platform/safe-fs 0.1.54 → 0.1.56

package/dist/safe-fs/fs/webdav/webdav.d.ts

@@ -26,6 +26,7 @@ export interface WebDavFileSystemOptions {
     readonly maxResponseBytes?: number;
     readonly maxXmlBytes?: number;
     readonly maxEntries?: number;
+    /** Per-request and aggregate stat/write-preflight walk timeout; defaults to 30,000 ms. */
     readonly timeoutMs?: number;
     readonly overwritePolicy?: "lock" | "etag";
     readonly atomicEmptyDirectory?: WebDavAtomicEmptyDirectoryBinding;
@@ -72,6 +73,7 @@ export declare class WebDavFileSystem implements FileSystem {
     private readonly maxXmlBytes;
     private readonly maxEntries;
     private readonly timeoutMs;
+    private readonly walkDeadlines;
     private readonly overwritePolicy;
     private readonly configuredComparison;
     private readonly atomicEmptyDirectory;
@@ -94,7 +96,9 @@ export declare class WebDavFileSystem implements FileSystem {
     private mutation;
     private unsupported;
     private maybeStat;
+    private withWalkDeadline;
     stat(path: string, options?: FsOptions): Promise<FileStat>;
+    private statWithAncestors;
     lstat(path: string, options?: FsOptions): Promise<FileStat>;
     readdir(path: string, options?: FsOptions): Promise<DirectoryEntry[]>;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;

package/dist/safe-fs/fs/webdav/webdav.js

@@ -87,7 +87,7 @@ function normalize(path) {
     }
     return `/${segments.join("/")}`;
 }
-function validateDirectoryAccessPath(path) {
+function validateDirectoryWalkPath(path, syscall = "access") {
     if (typeof path !== "string")
         fail("EINVAL", "resolve", String(path), "invalid WebDAV path");
     let bytes = 0;
@@ -105,7 +105,7 @@ function validateDirectoryAccessPath(path) {
         if (point > 0xffff)
             offset++;
         if (bytes > 65_536 || components > 256) {
-            fail("ENAMETOOLONG", "access", path, "directory access exceeds the 64KiB path or 256 component limit");
+            fail("ENAMETOOLONG", syscall, path, "directory access exceeds the 64KiB path or 256 component limit");
         }
     }
 }
@@ -157,6 +157,7 @@ export class WebDavFileSystem {
     maxXmlBytes;
     maxEntries;
     timeoutMs;
+    walkDeadlines = new WeakMap();
     overwritePolicy;
     configuredComparison;
     atomicEmptyDirectory;
@@ -320,7 +321,10 @@ export class WebDavFileSystem {
     async *requestStream(method, path, options, init, consume, collection = false, received) {
         if (options.signal?.aborted)
             fail("ECANCELED", method, path);
-        const deadline = createRequestTimeout(this.timeoutMs);
+        const walk = this.walkDeadlines.get(options);
+        const deadline = walk?.deadline ?? createRequestTimeout(this.timeoutMs);
+        if (walk)
+            walk.deadline = deadline;
         const timeout = deadline.signal;
         try {
             const headers = new Headers(this.headers);
@@ -409,7 +413,8 @@ export class WebDavFileSystem {
             }
         }
         finally {
-            deadline.dispose();
+            if (!walk)
+                deadline.dispose();
         }
     }
     async bytes(response, limit, signal) {
@@ -679,27 +684,47 @@ export class WebDavFileSystem {
             throw error;
         }
     }
+    async withWalkDeadline(options, walk) {
+        if (this.walkDeadlines.has(options))
+            return walk(options);
+        const scopedOptions = { ...options };
+        const owned = {};
+        this.walkDeadlines.set(scopedOptions, owned);
+        try {
+            return await walk(scopedOptions);
+        }
+        finally {
+            owned.deadline?.dispose();
+            this.walkDeadlines.delete(scopedOptions);
+        }
+    }
     async stat(path, options = {}) {
+        validateDirectoryWalkPath(path, "stat");
+        return this.statWithAncestors(path, options);
+    }
+    async statWithAncestors(path, options) {
         const normalized = normalize(path);
         const collection = requiresCollection(path);
-        try {
-            const stat = (await this.entries(normalized, "0", options, collection)).get(normalized);
-            if (collection && stat.type !== "directory")
-                fail("ENOTDIR", "stat", path);
-            return stat;
-        }
-        catch (error) {
-            if (!isFsError(error, "ENOENT"))
-                throw error;
-            let parent = "";
-            for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
-                parent += `/${segment}`;
-                const ancestor = (await this.entries(parent, "0", options)).get(parent);
-                if (ancestor.type !== "directory")
+        return this.withWalkDeadline(options, async (scopedOptions) => {
+            try {
+                const stat = (await this.entries(normalized, "0", scopedOptions, collection)).get(normalized);
+                if (collection && stat.type !== "directory")
                     fail("ENOTDIR", "stat", path);
+                return stat;
             }
-            throw error;
-        }
+            catch (error) {
+                if (!isFsError(error, "ENOENT"))
+                    throw error;
+                let parent = "";
+                for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
+                    parent += `/${segment}`;
+                    const ancestor = (await this.entries(parent, "0", scopedOptions)).get(parent);
+                    if (ancestor.type !== "directory")
+                        fail("ENOTDIR", "stat", path);
+                }
+                throw error;
+            }
+        });
     }
     async lstat(path, options = {}) {
         return this.stat(path, options);
@@ -751,6 +776,7 @@ export class WebDavFileSystem {
         }.bind(this));
     }
     async prepareWrite(path, options) {
+        validateDirectoryWalkPath(path, "writeFile");
         const normalized = normalize(path);
         if (options.mode !== undefined)
             this.unsupported("writeFile mode", path);
@@ -760,37 +786,39 @@ export class WebDavFileSystem {
             fail("ECANCELED", "writeFile", path);
         if (normalized === "/")
             fail("EISDIR", "writeFile", path);
-        if (requiresCollection(path)) {
-            await this.stat(path, options);
-            fail("EISDIR", "writeFile", path);
-        }
-        let parent = "";
-        for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
-            parent += `/${segment}`;
-            await this.stat(`${parent}/`, options);
-        }
-        const exclusive = options.flag === "wx" || options.flag === "ax";
-        const existing = exclusive ? undefined : await this.maybeStat(normalized, options);
-        if (existing?.type === "directory")
-            fail("EISDIR", "writeFile", path);
-        let prefix = new Uint8Array();
-        const headers = { "Content-Type": "application/octet-stream" };
-        if (exclusive || (options.flag === "a" && !existing))
-            headers["If-None-Match"] = "*";
-        if (options.flag === "a" && existing) {
-            const snapshot = await this.request("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {
-                if (response.status !== 200)
-                    this.httpError(response.status, "GET", path);
-                const etag = strongEtag(response.headers.get("ETag"), path);
-                if (response.headers.get("Content-Encoding") && response.headers.get("Content-Encoding").toLowerCase() !== "identity") {
-                    fail("ENOTSUP", "appendFile", path, "conditional append requires an identity representation");
-                }
-                return { etag, data: await this.bytes(response, this.maxResponseBytes, signal) };
-            });
-            prefix = snapshot.data;
-            headers["If-Match"] = snapshot.etag;
-        }
-        return { normalized, headers, prefix };
+        return this.withWalkDeadline(options, async (scopedOptions) => {
+            if (requiresCollection(path)) {
+                await this.stat(path, scopedOptions);
+                fail("EISDIR", "writeFile", path);
+            }
+            let parent = "";
+            for (const segment of normalized.slice(1).split("/").slice(0, -1)) {
+                parent += `/${segment}`;
+                await this.stat(`${parent}/`, scopedOptions);
+            }
+            const exclusive = options.flag === "wx" || options.flag === "ax";
+            const existing = exclusive ? undefined : await this.maybeStat(normalized, scopedOptions);
+            if (existing?.type === "directory")
+                fail("EISDIR", "writeFile", path);
+            let prefix = new Uint8Array();
+            const headers = { "Content-Type": "application/octet-stream" };
+            if (exclusive || (options.flag === "a" && !existing))
+                headers["If-None-Match"] = "*";
+            if (options.flag === "a" && existing) {
+                const snapshot = await this.request("GET", normalized, scopedOptions, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {
+                    if (response.status !== 200)
+                        this.httpError(response.status, "GET", path);
+                    const etag = strongEtag(response.headers.get("ETag"), path);
+                    if (response.headers.get("Content-Encoding") && response.headers.get("Content-Encoding").toLowerCase() !== "identity") {
+                        fail("ENOTSUP", "appendFile", path, "conditional append requires an identity representation");
+                    }
+                    return { etag, data: await this.bytes(response, this.maxResponseBytes, signal) };
+                });
+                prefix = snapshot.data;
+                headers["If-Match"] = snapshot.etag;
+            }
+            return { normalized, headers, prefix };
+        });
     }
     async writeFile(path, data, options = {}) {
         if (!(data instanceof Uint8Array))
@@ -1165,8 +1193,9 @@ export class WebDavFileSystem {
         if (mode & 2)
             this.unsupported("access write/execute permission checks", path);
         if (mode & 1)
-            validateDirectoryAccessPath(path);
-        const stat = await this.stat(path, options);
+            validateDirectoryWalkPath(path);
+        // Non-execute probes do not inherit stat's raw-path limits.
+        const stat = await (mode & 1 ? this.stat(path, options) : this.statWithAncestors(path, options));
         if (options.signal?.aborted)
             fail("ECANCELED", "access", path);
         if ((mode & 1) && stat.type !== "directory")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.54",
+  "version": "0.1.56",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",