@poe-platform/safe-fs 0.1.727 → 0.1.728

package/dist/safe-fs/fs/s3/filesystem.js

@@ -3,6 +3,7 @@ import { FsError, isFsError } from "../../contracts/errors.js";
 import { composeAbortSignals } from "../../contracts/abort.js";
 import { collectBytes, readBytes } from "../../contracts/io.js";
 import { compareEntries, registerEntryAuthority } from "../mount/comparison.js";
+import { chargeScopedTransportCall } from "#safe-fs-platform";
 import { compareOwnedS3Entries, queryS3Head, recordS3Stat, registerS3EntryOwner } from "./authority.js";
 import { encodeCopySource } from "./transport.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
@@ -63,6 +64,26 @@ function validateLimit(value, name, minimum, maximum = Number.MAX_SAFE_INTEGER)
     }
     return value;
 }
+function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+function exceedsComponentByteLimit(value) {
+    return value.length > 85 && (value.length > 255 || utf8ByteLength(value) > 255);
+}
 function isWellFormed(value) {
     return !/[\uD800-\uDFFF]/u.test(value);
 }
@@ -82,6 +103,8 @@ export class S3FileSystem {
     maxReadBytes;
     maxStreamBytes;
     maxListEntries;
+    maxRequests;
+    requests = 0;
     removalLimits;
     removalBudgets = new WeakMap();
     constructor(options) {
@@ -101,7 +124,7 @@ export class S3FileSystem {
             throw new FsError("EINVAL", { message: "prefix must be a canonical relative object-key prefix" });
         }
         this.prefix = prefix === "" || prefix.endsWith("/") ? prefix : `${prefix}/`;
-        if (Buffer.byteLength(this.prefix) > 1024)
+        if (utf8ByteLength(this.prefix) > 1024)
             throw new FsError("ENAMETOOLONG", { message: "S3 prefix exceeds 1024 UTF-8 bytes" });
         this.transport = options.transport;
         this.bucket = options.bucket;
@@ -110,6 +133,7 @@ export class S3FileSystem {
         this.maxReadBytes = options.maxReadBytes === undefined ? Infinity : validateLimit(options.maxReadBytes, "maxReadBytes", 0);
         this.maxStreamBytes = options.maxStreamBytes === undefined ? Infinity : validateLimit(options.maxStreamBytes, "maxStreamBytes", 0);
         this.maxListEntries = options.maxListEntries === undefined ? Infinity : validateLimit(options.maxListEntries, "maxListEntries", 1);
+        this.maxRequests = options.maxRequests === undefined ? Infinity : validateLimit(options.maxRequests, "maxRequests", 1);
         this.removalLimits = {
             maxRequests: validateLimit(options.removalLimits?.maxRequests ?? 32, "removalLimits.maxRequests", 1),
             maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? 32, "removalLimits.maxListEntries", 1),
@@ -167,7 +191,7 @@ export class S3FileSystem {
                 components.push(part);
         }
         const path = `/${components.join("/")}`;
-        if (Buffer.byteLength(this.key(path)) > 1024)
+        if (utf8ByteLength(this.key(path)) > 1024)
             fail("ENAMETOOLONG", "resolve", input);
         return path;
     }
@@ -176,7 +200,7 @@ export class S3FileSystem {
     }
     directoryKey(path) {
         const key = path === "/" ? this.prefix : `${this.key(path)}/`;
-        if (Buffer.byteLength(key) > 1024)
+        if (utf8ByteLength(key) > 1024)
             fail("ENAMETOOLONG", "resolve", path);
         return key;
     }
@@ -188,11 +212,17 @@ export class S3FileSystem {
         return options.signal === undefined ? {} : { abortSignal: options.signal };
     }
     async call(syscall, path, options, action, precondition) {
+        this.checkAbort(options, syscall, path);
+        chargeScopedTransportCall(options);
         this.checkAbort(options, syscall, path);
         const budget = this.removalBudgets.get(options);
         if (budget && ++budget.requests > this.removalLimits.maxRequests) {
             fail("EFBIG", "rm", path, "S3 removal request budget exceeded");
         }
+        if (this.requests >= this.maxRequests) {
+            fail("EFBIG", syscall, path, "S3 transport request budget exceeded");
+        }
+        this.requests++;
         let onAbort;
         try {
             const pending = action();
@@ -297,7 +327,7 @@ export class S3FileSystem {
         if (!key.startsWith(this.prefix))
             fail("EIO", "listObjectsV2", path, "key escapes the configured prefix");
         const relative = key.slice(this.prefix.length).replace(/\/$/, "");
-        if (!isWellFormed(key) || key.includes("\0") || Buffer.byteLength(key) > 1024
+        if (!isWellFormed(key) || key.includes("\0") || utf8ByteLength(key) > 1024
             || (relative !== "" && relative.split("/").some((part) => !part || part === "." || part === ".."))) {
             fail("ENOTSUP", "listObjectsV2", path, "object key cannot be represented as a canonical filesystem path");
         }
@@ -338,22 +368,22 @@ export class S3FileSystem {
             return { stat: this.makeStat("directory", marker), ...(marker ? { metadata: marker } : {}) };
         }
         const file = await this.head(this.key(path), path, options);
-        if (Buffer.byteLength(this.key(path)) === 1024) {
+        if (utf8ByteLength(this.key(path)) === 1024) {
             return file ? { stat: this.makeStat("file", file), metadata: file } : undefined;
         }
         const directoryKey = this.directoryKey(path);
-        const marker = await this.head(directoryKey, path, options);
-        if (marker && marker.ContentLength !== 0)
-            this.unsupported("nonempty directory markers", path);
-        let directory = marker !== undefined;
-        if (!directory) {
-            for await (const children of this.pages(directoryKey, path, options, undefined, 1)) {
-                if ((children.Contents?.length ?? 0) > 0) {
-                    directory = true;
-                    break;
-                }
+        let directory = false;
+        let hasMarker = false;
+        for await (const children of this.pages(directoryKey, path, options, undefined, 1)) {
+            if ((children.Contents?.length ?? 0) > 0) {
+                directory = true;
+                hasMarker = children.Contents.some(object => object.Key === directoryKey);
+                break;
             }
         }
+        const marker = hasMarker ? await this.head(directoryKey, path, options) : undefined;
+        if (marker && marker.ContentLength !== 0)
+            this.unsupported("nonempty directory markers", path);
         if (file && directory)
             this.unsupported("file/prefix collisions", path);
         if (file)
@@ -370,6 +400,8 @@ export class S3FileSystem {
                 break;
         }
         for (const parent of ancestors) {
+            if (parent === "/" && this.prefix === "")
+                continue;
             const ancestor = await this.inspect(parent, options);
             if (!ancestor)
                 fail("ENOENT", "stat", parent);
@@ -776,7 +808,7 @@ export class S3FileSystem {
             if (!conditionalCopy && object.Size > (streamFallback ? this.maxStreamBytes : this.maxReadBytes)) {
                 fail("EFBIG", "rename", source, "conditional PUT fallback exceeds its configured transfer or buffered read limit");
             }
-            if (Buffer.byteLength(this.key(destination) + object.Key.slice(this.key(source).length)) > 1024)
+            if (utf8ByteLength(this.key(destination) + object.Key.slice(this.key(source).length)) > 1024)
                 fail("ENAMETOOLONG", "rename", destination);
         }
         const copied = [];

package/dist/safe-fs/fs/s3/http/transport.js

@@ -4,6 +4,23 @@ import { abortable, collect, limitedBody, scopeFor, sendRequest } from "./reques
 import { canonicalQuery, headerValue, invalid, signRequest, uriEncode } from "./signature.js";
 import { children, integer, malformed, parseXml, text, timestamp } from "./xml.js";
 const empty = new Uint8Array();
+function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
 function limit(value, fallback, name, maximum = Number.MAX_SAFE_INTEGER) {
     if (value === undefined)
         return fallback;
@@ -23,7 +40,7 @@ function bucketName(bucket) {
         invalid("expected a standard S3 bucket name");
 }
 function objectKey(key) {
-    if (typeof key !== "string" || !key || Buffer.byteLength(key) > 1024)
+    if (typeof key !== "string" || !key || utf8ByteLength(key) > 1024)
         invalid("object keys must contain 1..1024 UTF-8 bytes");
     uriEncode(key);
 }
@@ -57,7 +74,7 @@ function metadataHeaders(metadata) {
         if (!/^[a-z0-9][a-z0-9_-]*$/.test(lower) || `x-amz-meta-${lower}` in headers)
             invalid("invalid or duplicate metadata key");
         const normalized = headerValue(value);
-        size += Buffer.byteLength(lower) + Buffer.byteLength(normalized);
+        size += utf8ByteLength(lower) + utf8ByteLength(normalized);
         if (size > 2048)
             invalid("metadata exceeds 2 KiB");
         headers[`x-amz-meta-${lower}`] = normalized;
@@ -413,7 +430,7 @@ export function createS3HttpTransport(options) {
             const query = [["list-type", "2"], ["encoding-type", "url"]];
             for (const [name, value] of [["prefix", input.Prefix], ["delimiter", input.Delimiter], ["continuation-token", input.ContinuationToken]]) {
                 if (value !== undefined) {
-                    if (typeof value !== "string" || Buffer.byteLength(value) > 8192)
+                    if (typeof value !== "string" || utf8ByteLength(value) > 8192)
                         invalid(`invalid ${name}`);
                     query.push([name, value]);
                 }

package/dist/safe-fs/fs/s3/mock.js

@@ -1,3 +1,20 @@
+function utf8ByteLength(value) {
+    let bytes = 0;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < value.length && value.charCodeAt(i + 1) >= 0xdc00 && value.charCodeAt(i + 1) <= 0xdfff) {
+            bytes += 4;
+            i++;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
 import { createHash } from "node:crypto";
 import { collectBytes } from "../../contracts/io.js";
 import { recordMockS3Head } from "./authority.js";
@@ -37,7 +54,7 @@ export class MockS3Client {
             throw new S3ServiceError("AbortError", 499);
         if (!this.buckets.has(input.Bucket))
             throw new S3ServiceError("NoSuchBucket", 404);
-        if ("Key" in input && (input.Key.length === 0 || Buffer.byteLength(input.Key) > 1024)) {
+        if ("Key" in input && (input.Key.length === 0 || utf8ByteLength(input.Key) > 1024)) {
             throw new S3ServiceError("InvalidArgument", 400);
         }
     }
@@ -62,7 +79,7 @@ export class MockS3Client {
         };
     }
     store(body, metadata = {}) {
-        const metadataBytes = Object.entries(metadata).reduce((total, [key, value]) => total + Buffer.byteLength(key) + Buffer.byteLength(value), 0);
+        const metadataBytes = Object.entries(metadata).reduce((total, [key, value]) => total + utf8ByteLength(key) + utf8ByteLength(value), 0);
         if (metadataBytes > 2048)
             throw new S3ServiceError("MetadataTooLarge", 400);
         return {

package/dist/safe-fs/fs/s3/namespace.js

@@ -250,7 +250,7 @@ export async function createS3NamespaceFileSystem(options) {
     const filesystem = {
         capabilities: Object.freeze({ read: true, write: true, append: true, stat: true, readdir: true, realpath: true, access: true,
             mkdir: true, recursiveMkdir: true, explicitDirectories: true, implicitDirectories: false, exclusiveCreate: true,
-            remove: true, removeDirectory: true, recursiveRemove: true, atomicTreeRemoval: true, atomicEntryRemoval: true,
+            remove: true, removeDirectory: true, recursiveRemove: true, atomicTreeRemoval: true, atomicEntryRemoval: true, atomicEntryRemovalReceipt: false,
             rename: true, atomicRename: true, atomicRenameNoReplace: true, copy: true, exclusiveCopy: true,
             readOnly: false, symlinks: false, hardlinks: false, permissions: false, timestamps: false }),
         stat: observe,
@@ -313,7 +313,13 @@ export async function createS3NamespaceFileSystem(options) {
         async unlink(input, forwarded = {}) { entryPath(input); await mutate(forwarded, value => remove(value, resolveName(value, input), false, 'file')); },
         async rmdir(input, forwarded = {}) { entryPath(input); await mutate(forwarded, value => remove(value, resolveName(value, input), false, 'directory')); },
         async removeTreeConditional(input, forwarded) { entryPath(input); return conditionalRemove(input, forwarded, true); },
-        async removeEntryConditional(input, forwarded) { entryPath(input); return conditionalRemove(input, forwarded, false); },
+        async removeEntryConditional(input, forwarded) {
+            forwarded.signal?.throwIfAborted();
+            if (forwarded.returnRemainingStat === true)
+                throw new FsError('ENOTSUP');
+            entryPath(input);
+            return conditionalRemove(input, forwarded, false);
+        },
         async rename(source, destination, forwarded = {}) {
             entryPath(source);
             entryPath(destination);

package/dist/safe-fs/fs/s3/registry.js

@@ -1,5 +1,6 @@
 import { FsError } from "../../contracts/errors.js";
 import { assertCallbackAuthorityAllowed } from "../mount/comparison.js";
+import { enableS3TransportBudget } from "../../platform/transport-budget.js";
 const observedStats = new WeakMap();
 const entries = new WeakMap();
 const comparisons = new WeakMap();
@@ -8,6 +9,7 @@ export function recordS3Observation(filesystem, path, stat, entry) {
     observedStats.set(stat, { filesystem, path, entry });
 }
 export function registerS3EntryOwner(filesystem, normalize, intact, baseComparison, comparison) {
+    enableS3TransportBudget();
     comparisons.set(filesystem, baseComparison);
     if (comparison)
         configuredComparisons.set(filesystem, comparison);

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

@@ -2,6 +2,7 @@ import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
 export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, options?: {
     readonly preserveDescriptorWriteReceipt?: boolean;
     readonly creationMask?: number;
+    readonly maxPathComponents?: number;
 }): FileSystem;
 export interface RetainedFileSystemCleanupView {
     readonly removeFileConditional?: NonNullable<FileSystem["removeFileConditional"]>;