@poe-platform/safe-fs 0.1.728 → 0.1.729

package/dist/safe-fs/fs/memory/ledger.d.ts

@@ -3,17 +3,22 @@ export declare class MemoryLedger {
     readonly limits: Readonly<MemoryFileSystemLimits>;
     private retainedBytes;
     private metadataUnits;
+    readonly maxFileBytesSmi: number;
+    readonly maxRetainedBytesSmi: number;
+    readonly maxMetadataUnitsSmi: number;
+    readonly hasInfiniteRetained: boolean;
     constructor(limits: Readonly<MemoryFileSystemLimits>);
     get availableBytes(): number;
+    canPreallocate64(nameBytes: number): boolean;
     fileSize(length: number, syscall: string, path: string): void;
     check(bytes: number, units: number, syscall: string, path: string): void;
     reserve(bytes: number, units: number, syscall: string, path: string): void;
     release(bytes: number, units: number): void;
 }
 export declare class MemoryAllocation {
+    private references;
     readonly data: Uint8Array;
     private readonly ledger;
-    private references;
     constructor(data: Uint8Array, ledger: MemoryLedger);
     retain(): void;
     release(): void;

package/dist/safe-fs/fs/memory/ledger.js

@@ -1,21 +1,41 @@
 import { FsError } from "../../contracts/errors.js";
+const MAX_SMI = 1073741823;
 export class MemoryLedger {
     limits;
     retainedBytes = 0;
     metadataUnits = 0;
+    maxFileBytesSmi;
+    maxRetainedBytesSmi;
+    maxMetadataUnitsSmi;
+    hasInfiniteRetained;
     constructor(limits) {
         this.limits = limits;
+        this.maxFileBytesSmi = limits.maxFileBytes >= MAX_SMI ? MAX_SMI : (limits.maxFileBytes | 0);
+        this.maxRetainedBytesSmi = limits.maxRetainedBytes >= MAX_SMI ? MAX_SMI : (limits.maxRetainedBytes | 0);
+        this.maxMetadataUnitsSmi = limits.maxMetadataUnits >= MAX_SMI ? MAX_SMI : (limits.maxMetadataUnits | 0);
+        this.hasInfiniteRetained = limits.maxRetainedBytes === Infinity;
     }
     get availableBytes() {
         const max = this.limits.maxRetainedBytes;
         return max === Infinity ? Infinity : max - this.retainedBytes;
     }
+    canPreallocate64(nameBytes) {
+        return this.maxFileBytesSmi >= 64 && (this.hasInfiniteRetained || this.maxRetainedBytesSmi - this.retainedBytes > 65536 + nameBytes);
+    }
     fileSize(length, syscall, path) {
+        if ((length | 0) === length && length >= 0 && length <= this.maxFileBytesSmi)
+            return;
         if (!Number.isSafeInteger(length) || length < 0 || length > this.limits.maxFileBytes) {
             throw new FsError("EFBIG", { syscall, path });
         }
     }
     check(bytes, units, syscall, path) {
+        if ((bytes | 0) === bytes && bytes >= 0 &&
+            (units | 0) === units && units >= 0 &&
+            this.retainedBytes <= this.maxRetainedBytesSmi - bytes &&
+            this.metadataUnits <= this.maxMetadataUnitsSmi - units) {
+            return;
+        }
         const maxRetained = this.limits.maxRetainedBytes;
         const maxUnits = this.limits.maxMetadataUnits;
         if (!Number.isSafeInteger(bytes) || bytes < 0 ||
@@ -26,6 +46,14 @@ export class MemoryLedger {
         }
     }
     reserve(bytes, units, syscall, path) {
+        if ((bytes | 0) === bytes && bytes >= 0 &&
+            (units | 0) === units && units >= 0 &&
+            this.retainedBytes <= this.maxRetainedBytesSmi - bytes &&
+            this.metadataUnits <= this.maxMetadataUnitsSmi - units) {
+            this.retainedBytes = (this.retainedBytes + bytes) | 0;
+            this.metadataUnits = (this.metadataUnits + units) | 0;
+            return;
+        }
         this.check(bytes, units, syscall, path);
         this.retainedBytes += bytes;
         this.metadataUnits += units;
@@ -39,9 +67,6 @@ export class MemoryLedger {
     }
 }
 export class MemoryAllocation {
-    data;
-    ledger;
-    references = 1;
     constructor(data, ledger) {
         this.data = data;
         this.ledger = ledger;
@@ -63,3 +88,6 @@ export class MemoryAllocation {
         this.data.fill(0);
     }
 }
+Object.assign(MemoryAllocation.prototype, {
+    references: 1,
+});

package/dist/safe-fs/fs/overlay/index.js

@@ -36,7 +36,9 @@ function hasCode(error, code) {
 function fail(code, path, message) {
     throw new FsError(code, { syscall: "overlay", path, ...(message === undefined ? {} : { message }) });
 }
-function integer(value, path) {
+function integer(value, path, unlimited = false) {
+    if (unlimited && value === Infinity)
+        return;
     if (!Number.isSafeInteger(value) || value < 0)
         fail("EINVAL", path);
 }
@@ -86,7 +88,7 @@ export class OverlayFileSystem {
         }, false));
         this.maxBufferBytes = options.maxBufferBytes ?? Infinity;
         if (options.maxBufferBytes !== undefined)
-            integer(options.maxBufferBytes, "/");
+            integer(options.maxBufferBytes, "/", true);
         const writable = !this.#upper.capabilities.readOnly && this.#upper.capabilities.atomicRename === true;
         const readable = [this.#upper, this.#lower].map((backend) => retainedReadCapabilities(backend).retainedRead);
         const streamingRead = readable.every((capability) => capability === true) ? true
@@ -520,7 +522,7 @@ export class OverlayFileSystem {
             fail("EISDIR", entry.path);
         this.permission(entry, 4);
         if (options.maxBytes !== undefined)
-            integer(options.maxBytes, entry.path);
+            integer(options.maxBytes, entry.path, true);
         const limit = Math.min(options.maxBytes ?? this.maxBufferBytes, this.maxBufferBytes);
         if (entry.stat.size > limit)
             fail("EFBIG", entry.path);

package/dist/safe-fs/fs/quota/index.js

@@ -153,15 +153,15 @@ async function existingBytes(fs, path, options) {
     }
 }
 export function withFileSystemQuota(fs, options) {
-    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0)
-        throw new RangeError("maxBytes must be a nonnegative safe integer");
+    if (options.maxBytes !== Infinity && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 0))
+        throw new RangeError("maxBytes must be a nonnegative safe integer or Infinity");
     const scanLimits = {
         maxScanEntries: options.maxScanEntries ?? Infinity,
         maxScanDepth: options.maxScanDepth ?? Infinity,
     };
     for (const [name, value] of Object.entries({ maxScanEntries: options.maxScanEntries, maxScanDepth: options.maxScanDepth })) {
-        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
-            throw new RangeError(`${name} must be a nonnegative safe integer`);
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value < 0))
+            throw new RangeError(`${name} must be a nonnegative safe integer or Infinity`);
     }
     let queue = Promise.resolve();
     let reservedBytes = 0;

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

@@ -59,7 +59,7 @@ function fail(code, syscall, path, message) {
     throw new FsError(code, { syscall, path, ...(message === undefined ? {} : { message }) });
 }
 function validateLimit(value, name, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    if ((value !== Infinity || maximum !== Infinity) && (!Number.isSafeInteger(value) || value < minimum || value > maximum)) {
         throw new FsError("EINVAL", { message: `${name} must be an integer from ${minimum} to ${maximum}` });
     }
     return value;
@@ -130,14 +130,14 @@ export class S3FileSystem {
         this.bucket = options.bucket;
         this.allowRename = options.allowNonAtomicRename ?? true;
         this.pageSize = validateLimit(options.pageSize ?? 1000, "pageSize", 1, 1000);
-        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.maxReadBytes = options.maxReadBytes === undefined ? Infinity : validateLimit(options.maxReadBytes, "maxReadBytes", 0, Infinity);
+        this.maxStreamBytes = options.maxStreamBytes === undefined ? Infinity : validateLimit(options.maxStreamBytes, "maxStreamBytes", 0, Infinity);
+        this.maxListEntries = options.maxListEntries === undefined ? Infinity : validateLimit(options.maxListEntries, "maxListEntries", 1, Infinity);
+        this.maxRequests = options.maxRequests === undefined ? Infinity : validateLimit(options.maxRequests, "maxRequests", 1, Infinity);
         this.removalLimits = {
-            maxRequests: validateLimit(options.removalLimits?.maxRequests ?? 32, "removalLimits.maxRequests", 1),
-            maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? 32, "removalLimits.maxListEntries", 1),
-            maxDeleteObjects: validateLimit(options.removalLimits?.maxDeleteObjects ?? 16, "removalLimits.maxDeleteObjects", 1),
+            maxRequests: validateLimit(options.removalLimits?.maxRequests ?? Infinity, "removalLimits.maxRequests", 1, Infinity),
+            maxListEntries: validateLimit(options.removalLimits?.maxListEntries ?? Infinity, "removalLimits.maxListEntries", 1, Infinity),
+            maxDeleteObjects: validateLimit(options.removalLimits?.maxDeleteObjects ?? Infinity, "removalLimits.maxDeleteObjects", 1, Infinity),
         };
         this.capabilities = Object.freeze({
             open: false,
@@ -427,7 +427,7 @@ export class S3FileSystem {
         return this.stat(path, options);
     }
     async body(output, path, options) {
-        const limit = Math.min(this.maxReadBytes, options.maxBytes === undefined ? this.maxReadBytes : validateLimit(options.maxBytes, "maxBytes", 0));
+        const limit = Math.min(this.maxReadBytes, options.maxBytes === undefined ? this.maxReadBytes : validateLimit(options.maxBytes, "maxBytes", 0, Infinity));
         let iterator;
         return this.call("readFile", path, options, async () => {
             if (output.Body && Symbol.asyncIterator in output.Body)
@@ -473,7 +473,7 @@ export class S3FileSystem {
     async readFile(input, options = {}) {
         const path = this.path(input);
         if (options.maxBytes !== undefined)
-            validateLimit(options.maxBytes, "maxBytes", 0);
+            validateLimit(options.maxBytes, "maxBytes", 0, Infinity);
         const info = await this.stat(input, options);
         if (info.type === "directory")
             fail("EISDIR", "readFile", path);

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

@@ -86,7 +86,9 @@ const resourceIdBody = '<?xml version="1.0" encoding="utf-8"?>'
 function fail(code, syscall, path, message) {
     throw new FsError(code, { syscall, path, ...(message === undefined ? {} : { message }) });
 }
-function positive(value, name, zero = false) {
+function positive(value, name, zero = false, unlimited = false) {
+    if (unlimited && value === Infinity)
+        return value;
     if (!Number.isSafeInteger(value) || value < (zero ? 0 : 1)) {
         throw new FsError("EINVAL", { message: `${name} must be a ${zero ? "nonnegative" : "positive"} safe integer` });
     }
@@ -286,9 +288,9 @@ export class WebDavFileSystem {
             removeDirectory: this.atomicEmptyDirectory !== undefined,
             streamingAppend: this.requestStreamSupport !== false,
         });
-        this.maxResponseBytes = options.maxResponseBytes === undefined ? 16 * 1024 * 1024 : positive(options.maxResponseBytes, "maxResponseBytes");
-        this.maxXmlBytes = options.maxXmlBytes === undefined ? 1024 * 1024 : positive(options.maxXmlBytes, "maxXmlBytes");
-        this.maxEntries = options.maxEntries === undefined ? Infinity : positive(options.maxEntries, "maxEntries");
+        this.maxResponseBytes = options.maxResponseBytes === undefined ? 16 * 1024 * 1024 : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+        this.maxXmlBytes = options.maxXmlBytes === undefined ? 1024 * 1024 : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
+        this.maxEntries = options.maxEntries === undefined ? Infinity : positive(options.maxEntries, "maxEntries", false, true);
         this.timeoutMs = options.timeoutMs === undefined ? undefined : positive(options.timeoutMs, "timeoutMs");
         this.overwritePolicy = options.overwritePolicy ?? "lock";
         this.configuredComparison = options.compareEntry !== undefined;
@@ -867,7 +869,7 @@ export class WebDavFileSystem {
     }
     async readFile(path, options = {}) {
         const normalized = normalize(path);
-        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true));
+        const limit = Math.min(this.maxResponseBytes, options.maxBytes === undefined ? this.maxResponseBytes : positive(options.maxBytes, "maxBytes", true, true));
         if ((await this.stat(path, options)).type === "directory")
             fail("EISDIR", "readFile", path);
         return this.request("GET", normalized, options, { headers: { "Accept-Encoding": "identity" } }, async (response, signal) => {

package/package.json

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