@poe-platform/safe-fs 0.1.727 → 0.1.729

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

@@ -3,18 +3,25 @@ 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;
+    isReleased64(): boolean;
+    reuse(): void;
 }

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

@@ -1,26 +1,59 @@
 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() {
-        return this.limits.maxRetainedBytes - this.retainedBytes;
+        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 (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.availableBytes ||
-            !Number.isSafeInteger(units) || units < 0 || units > this.limits.maxMetadataUnits - this.metadataUnits) {
+        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 ||
+            (maxRetained !== Infinity && bytes > maxRetained - this.retainedBytes) ||
+            !Number.isSafeInteger(units) || units < 0 ||
+            (maxUnits !== Infinity && units > maxUnits - this.metadataUnits)) {
             throw new FsError("ENOSPC", { syscall, path });
         }
     }
     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;
@@ -34,9 +67,6 @@ export class MemoryLedger {
     }
 }
 export class MemoryAllocation {
-    data;
-    ledger;
-    references = 1;
     constructor(data, ledger) {
         this.data = data;
         this.ledger = ledger;
@@ -50,4 +80,14 @@ export class MemoryAllocation {
         if (--this.references === 0)
             this.ledger.release(this.data.byteLength, 0);
     }
+    isReleased64() {
+        return this.references === 0 && this.data.byteLength === 64;
+    }
+    reuse() {
+        this.references = 1;
+        this.data.fill(0);
+    }
 }
+Object.assign(MemoryAllocation.prototype, {
+    references: 1,
+});

package/dist/safe-fs/fs/memory/missing-target.js

@@ -1,4 +1,24 @@
 import { FsError } from "../../contracts/errors.js";
+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 components(path, signal) {
     const result = [];
     let start = 0;
@@ -56,7 +76,7 @@ export function resolveMissingTarget(root, path, signal) {
                 first = false;
                 continue;
             }
-            if (new TextEncoder().encode(name).byteLength > 255)
+            if (exceedsComponentByteLimit(name))
                 return fail("ENAMETOOLONG");
             const node = current.entries.get(name);
             if (!node) {

package/dist/safe-fs/fs/mount/index.d.ts

@@ -1,4 +1,4 @@
-import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, CreateStagedFileOptions, FileStaging, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
+import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, ChmodOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, ConditionalRemoveEntryReceiptOptions, CreateStagedFileOptions, FileStaging, FileStagingEntry, FileStagingResolution, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 export interface MountFileSystemOptions {
@@ -14,6 +14,11 @@ export declare class MountFileSystem implements FileSystem {
     constructor(options: MountFileSystemOptions);
     private select;
     capabilitiesFor(path: string, options?: CapabilityQueryOptions): Promise<FileSystemCapabilities>;
+    private supportsStagingAncestry;
+    private supportsDirectoryValidation;
+    prepareDirectoryAncestry(ancestors: readonly FileStagingEntry[], options?: FsOptions): Promise<() => true>;
+    prepareStagingResolution(path: string, options?: FsOptions): Promise<FileStagingResolution>;
+    private prepareAncestry;
     private protected;
     openReadFile(path: string, options?: OpenReadFileOptions): Promise<FileReadHandle>;
     resizeFile(path: string, operation: FileResizeOperation, options?: FileResizeOptions): Promise<void>;
@@ -41,7 +46,10 @@ export declare class MountFileSystem implements FileSystem {
     private localStaging;
     publishFileConditional(path: string, source: ByteSource, options: ConditionalFilePublicationOptions): Promise<FileStat>;
     writeFileConditional(path: string, data: Uint8Array, options: ConditionalWriteFileOptions): Promise<FileStat>;
-    removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryOptions & {
+        readonly returnRemainingStat?: false | undefined;
+    }): Promise<void>;
+    removeEntryConditional(path: string, options: ConditionalRemoveEntryReceiptOptions): Promise<void | FileStat>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;
     removeTreeConditional(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;
     createStagedFile(path: string, name: string, content: StagedFileContent, options: CreateStagedFileOptions): Promise<FileStaging>;
@@ -56,7 +64,7 @@ export declare class MountFileSystem implements FileSystem {
     readlink(path: string, options?: FsOptions): Promise<string>;
     symlink(target: string, path: string, options?: FsOptions): Promise<void>;
     link(existingPath: string, newPath: string, options?: FsOptions): Promise<void>;
-    chmod(path: string, mode: number, options?: FsOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: ChmodOptions): Promise<void>;
     utimes(path: string, atimeMs: number, mtimeMs: number, options?: FsOptions): Promise<void>;
     truncate(path: string, length?: number, options?: FsOptions): Promise<void>;
     readStream(path: string, options?: ReadStreamOptions): ByteSource;