@poe-platform/safe-fs 0.1.630 → 0.1.632

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

@@ -1,24 +1,29 @@
 import { ACCESS_MODES } from "../../contracts/filesystem.js";
 import { FsError } from "../../contracts/errors.js";
 import { readBytes } from "../../contracts/io.js";
+import { finishCleanup } from "../../contracts/cleanup.js";
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
 import { openRetainedReadFile, readOnlyCapabilities, retainedReadCapabilities } from "../capabilities.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
+import { forwardFileDescriptor, openFileDescriptor } from "../descriptor.js";
 import { pathNamespace, readOnlyPathNamespace } from "../path-namespace.js";
 function readOnly(syscall, path, dest) {
     throw new FsError("EROFS", { syscall, path, ...(dest === undefined ? {} : { dest }) });
 }
 function snapshotStat(stat) {
-    const { type, size, allocatedBytes, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, ino, dev, nlink, uid, gid } = stat;
+    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
     return {
         type, size, mode, mtimeMs, atimeMs, ctimeMs,
         ...(revision === undefined ? {} : { revision }),
         ...(allocatedBytes === undefined ? {} : { allocatedBytes }),
+        ...(ioBlockSize === undefined ? {} : { ioBlockSize }),
         ...(preferredIoBlockSize === undefined ? {} : { preferredIoBlockSize }),
         ...(birthtimeMs === undefined ? {} : { birthtimeMs }),
         ...(identityScope === undefined ? {} : { identityScope }),
         ...(ino === undefined ? {} : { ino }),
         ...(dev === undefined ? {} : { dev }),
+        ...(rdevMajor === undefined ? {} : { rdevMajor }),
+        ...(rdevMinor === undefined ? {} : { rdevMinor }),
         ...(nlink === undefined ? {} : { nlink }),
         ...(uid === undefined ? {} : { uid }),
         ...(gid === undefined ? {} : { gid }),
@@ -37,6 +42,7 @@ export class ReadOnlyFileSystem {
         const streamingRead = typeof filesystem.readStream === "function" ? filesystem.capabilities.streamingRead : false;
         this.#capabilities = readOnlyCapabilities({
             ...retainedReadCapabilities(filesystem),
+            ...(typeof filesystem.open === "function" ? {} : { open: false }),
             readOnly: true,
             append: false,
             symlinks: filesystem.capabilities.symlinks === true && typeof filesystem.readlink === "function",
@@ -56,7 +62,34 @@ export class ReadOnlyFileSystem {
         if (options?.create !== undefined)
             readOnly("capabilitiesFor", path);
         const capabilities = await this.#filesystem.capabilitiesFor?.(path, options) ?? this.#filesystem.capabilities;
-        return readOnlyCapabilities(retainedReadCapabilities(this.#filesystem, capabilities));
+        return readOnlyCapabilities({ ...retainedReadCapabilities(this.#filesystem, capabilities), ...(typeof this.#filesystem.open === "function" ? {} : { open: false }) });
+    }
+    async open(path, options) {
+        options?.signal?.throwIfAborted();
+        if (options && (options.access === "write" || options.access === "readwrite" || options.truncate === true || options.append === true
+            || options.creation === "ifMissing" || options.creation === "exclusive"))
+            readOnly("open", path);
+        return openFileDescriptor(path, options, {
+            positionedRead: true, positionedWrite: false, truncate: false, synchronization: "none",
+        }, async (admitted) => {
+            const capabilities = await this.#filesystem.capabilitiesFor?.(path, admitted) ?? this.#filesystem.capabilities;
+            if (!this.#filesystem.open || capabilities.open === false)
+                throw new FsError("ENOTSUP", { syscall: "open", path });
+            admitted.signal?.throwIfAborted();
+            const descriptor = await this.#filesystem.open(path, admitted);
+            try {
+                return forwardFileDescriptor(descriptor, async (_syscall, forwarded, action) => {
+                    forwarded.signal?.throwIfAborted();
+                    return action();
+                }, { ...descriptor.capabilities,
+                    ...(descriptor.capabilities.openTruncate === undefined ? {} : { openTruncate: false }),
+                    positionedWrite: false, truncate: false, synchronization: "none" }, snapshotStat);
+            }
+            catch (error) {
+                await finishCleanup(() => descriptor.close(), true);
+                throw error;
+            }
+        });
     }
     openReadFile(path, options = {}) {
         return openRetainedReadFile(this.#filesystem, path, options);

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

@@ -1,3 +1,4 @@
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 import type { AppendFileOptions, ByteSource, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileStat, FileSystem, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, OpenReadFileOptions, OpenResizeFileOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/index.js";
 export interface RealFileSystemOptions {
     /** An existing, absolute host directory. It is never created implicitly. */
@@ -49,6 +50,7 @@ export declare class RealFileSystem implements FileSystem {
     private path;
     private operation;
     private protectRoot;
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
     private protectTerminal;
     readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
     writeFile(path: string, data: Uint8Array, options?: WriteFileOptions): Promise<void>;
@@ -59,6 +61,7 @@ export declare class RealFileSystem implements FileSystem {
     mkdir(path: string, options?: MkdirOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
+    unlink(path: string, options?: FsOptions): Promise<void>;
     rename(source: string, destination: string, options?: RenameOptions): Promise<void>;
     copyFile(source: string, destination: string, options?: CopyFileOptions): Promise<void>;
     realpath(path: string, options?: FsOptions): Promise<string>;

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

@@ -2,6 +2,7 @@ import { constants } from "node:fs";
 import * as native from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { nativeAllocatedBytes } from "./allocation.js";
+import { openFileDescriptor } from "../descriptor.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { callNativeSeekEnd, loadNativeSeekBinding } from "../../node/native-seek.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
@@ -21,6 +22,7 @@ function fileStat(stats) {
     return {
         type: fileType(stats), size: stats.size, mode: stats.mode,
         ...(allocatedBytes === undefined ? {} : { allocatedBytes }),
+        ...(Number.isSafeInteger(stats.blksize) && stats.blksize > 0 ? { ioBlockSize: stats.blksize } : {}),
         ...(Number.isSafeInteger(preferredIoBlockSize) && preferredIoBlockSize > 0 ? { preferredIoBlockSize } : {}),
         atimeMs: stats.atimeMs, mtimeMs: stats.mtimeMs, ctimeMs: stats.ctimeMs,
         birthtimeMs: stats.birthtimeMs, ino: stats.ino, dev: stats.dev,
@@ -84,7 +86,7 @@ function nativeError(error) {
  */
 export class RealFileSystem {
     capabilities = Object.freeze({
-        read: true, stat: true, readdir: true, realpath: true, access: true,
+        read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
         write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
         mkdir: true, recursiveMkdir: true, remove: true, removeDirectory: true, recursiveRemove: true,
         rename: true, atomicRenameNoReplace: false, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
@@ -251,6 +253,62 @@ export class RealFileSystem {
         if (resolve(path) === root)
             throw new FsError("EBUSY", { message: "the filesystem root cannot be removed or replaced" });
     }
+    open(path, options) {
+        return openFileDescriptor(path, options, {
+            positionedRead: true, positionedWrite: true, truncate: true, synchronization: "storage",
+        }, async (admitted) => {
+            let handle;
+            try {
+                const target = await this.path(path, {
+                    ...admitted, followFinal: admitted.creation !== "exclusive",
+                    ...(admitted.creation === "never" ? {} : { missing: "final" }),
+                });
+                let flags = (admitted.access === "read" ? constants.O_RDONLY : admitted.access === "write" ? constants.O_WRONLY : constants.O_RDWR)
+                    | constants.O_NOFOLLOW | constants.O_NONBLOCK;
+                if (admitted.creation !== "never")
+                    flags |= constants.O_CREAT;
+                if (admitted.creation === "exclusive")
+                    flags |= constants.O_EXCL;
+                if (admitted.append)
+                    flags |= constants.O_APPEND;
+                handle = await native.open(target, flags, admitted.mode);
+                admitted.signal?.throwIfAborted();
+                const stat = await handle.stat();
+                if (stat.isDirectory())
+                    throw new FsError("EISDIR");
+                if (!stat.isFile())
+                    throw new FsError("ENOTSUP");
+                admitted.signal?.throwIfAborted();
+                if (admitted.truncate)
+                    await handle.truncate(0);
+                const resource = { handle };
+                handle = undefined;
+                return {
+                    resource,
+                    stat: (retained, forwarded) => this.operation("fstat", path, forwarded, async () => fileStat(await retained.handle.stat())),
+                    read: (retained, buffer, position, forwarded) => this.operation("read", path, forwarded, async () => (await retained.handle.read(buffer, 0, buffer.byteLength, position)).bytesRead),
+                    write: (retained, buffer, position, forwarded) => this.operation("write", path, forwarded, async () => (await retained.handle.write(buffer, 0, buffer.byteLength, position)).bytesWritten),
+                    truncate: (retained, length, forwarded) => this.operation("ftruncate", path, forwarded, () => retained.handle.truncate(length)),
+                    sync: (retained, dataOnly, forwarded) => this.operation(dataOnly ? "fdatasync" : "fsync", path, forwarded, () => dataOnly ? retained.handle.datasync() : retained.handle.sync()),
+                    close: async (retained) => {
+                        try {
+                            await this.operation("close", path, {}, () => retained.handle.close());
+                        }
+                        finally {
+                            retained.handle = undefined;
+                        }
+                    },
+                };
+            }
+            catch (error) {
+                if (handle)
+                    await finishCleanup(() => handle.close(), true);
+                handle = undefined;
+                admitted.signal?.throwIfAborted();
+                throw new FsError(nativeError(error).code, { syscall: "open", path });
+            }
+        });
+    }
     protectTerminal(path) {
         const terminal = path.split("/").filter(Boolean).at(-1);
         if (terminal === "." || terminal === "..")
@@ -358,6 +416,15 @@ export class RealFileSystem {
             await native.rm(target, { recursive: options.recursive ?? false, force: options.force ?? false });
         });
     }
+    async unlink(path, options = {}) {
+        return this.operation("unlink", path, options, async () => {
+            const target = await this.path(path, { ...options, followFinal: false });
+            this.protectTerminal(path);
+            this.protectRoot(target, await this.root(options));
+            options.signal?.throwIfAborted();
+            await native.unlink(target);
+        });
+    }
     async rename(source, destination, options = {}) {
         return this.operation("rename", source, options, async () => {
             if (options.noReplace)
@@ -465,11 +532,14 @@ export class RealFileSystem {
     }
     async utimes(path, atimeMs, mtimeMs, options = {}) {
         return this.operation("utimes", path, options, async () => {
-            if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs))
+            if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs)
+                || Math.abs(atimeMs) > 8.64e15 || Math.abs(mtimeMs) > 8.64e15)
                 throw new FsError("EINVAL");
             const target = await this.path(path, options);
             options.signal?.throwIfAborted();
-            await native.utimes(target, new Date(atimeMs), new Date(mtimeMs));
+            const atimeSeconds = atimeMs / 1000;
+            const mtimeSeconds = mtimeMs / 1000;
+            await native.utimes(target, atimeSeconds < 0 ? String(atimeSeconds) : atimeSeconds, mtimeSeconds < 0 ? String(mtimeSeconds) : mtimeSeconds);
         });
     }
     async truncate(path, length = 0, options = {}) {

package/dist/safe-fs/fs/s3/filesystem.d.ts

@@ -1,6 +1,7 @@
 import { FsError } from "../../contracts/errors.js";
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 import type { S3Transport } from "./transport.js";
 export interface S3FileSystemOptions {
     readonly transport: S3Transport;
@@ -21,7 +22,9 @@ export declare class S3RenameError extends FsError {
     constructor(source: string, destination: string, phase: "copy" | "delete", copied: string[], deleted: string[], cause: FsError);
 }
 export declare class S3FileSystem implements FileSystem {
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
     readonly capabilities: Readonly<{
+        open: false;
         read: true;
         stat: true;
         readdir: true;

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

@@ -67,6 +67,10 @@ function isWellFormed(value) {
     return !/[\uD800-\uDFFF]/u.test(value);
 }
 export class S3FileSystem {
+    async open(path, options) {
+        options.signal?.throwIfAborted();
+        throw new FsError("ENOTSUP", { syscall: "open", path });
+    }
     capabilities;
     readStream;
     writeStream;
@@ -105,6 +109,7 @@ export class S3FileSystem {
         this.maxStreamBytes = validateLimit(options.maxStreamBytes ?? 5_000_000_000, "maxStreamBytes", 0, 5_000_000_000);
         this.maxListEntries = validateLimit(options.maxListEntries ?? 100_000, "maxListEntries", 1);
         this.capabilities = Object.freeze({
+            open: false,
             read: true, stat: true, readdir: true, realpath: true, access: true,
             write: true, explicitDirectories: true, implicitDirectories: true, mkdir: true, recursiveMkdir: true,
             remove: true, removeDirectory: true, recursiveRemove: true, copy: true, readlink: false,

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

@@ -4,10 +4,10 @@ import { registerEntryView } from "./mount/comparison.js";
 import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabilities, requireOwnedMutation } from "./capabilities.js";
 const originals = new WeakMap();
 const operations = new Set([
-    "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
+    "removeEntryConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
     "access", "appendFile", "canonicalizeMissingTarget", "capabilitiesFor", "chmod", "compareEntry",
     "copyFile", "link", "lstat", "mkdir", "openReadFile", "openResizeFile", "readFile", "readStream", "readdir",
-    "readlink", "realpath", "rename", "resizeFile", "rm", "rmdir", "stat", "symlink", "truncate", "utimes",
+    "readlink", "realpath", "rename", "resizeFile", "rm", "rmdir", "unlink", "stat", "symlink", "truncate", "utimes",
     "writeFile", "writeStream",
 ]);
 export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge) {
@@ -113,6 +113,40 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
             close: () => closing ??= Promise.resolve().then(() => handle.close()),
         };
     };
+    const wrapDescriptor = (descriptor) => {
+        let closing;
+        const invoke = async (options, action) => {
+            assertOpen(options);
+            if (closing)
+                throw new FsError("EBADF");
+            admit(options);
+            assertOpen(options);
+            if (closing)
+                throw new FsError("EBADF");
+            try {
+                const result = await action(resizeOptions(options));
+                assertOpen(options);
+                return result;
+            }
+            catch (error) {
+                assertOpen(options);
+                throw error;
+            }
+        };
+        const getPosition = descriptor.getPosition;
+        const probeRead = descriptor.probeRead;
+        return {
+            capabilities: Object.freeze({ ...descriptor.capabilities }),
+            ...(getPosition === undefined ? {} : { getPosition: (options = {}) => invoke(options, scoped => getPosition.call(descriptor, scoped)) }),
+            ...(probeRead === undefined ? {} : { probeRead: (options = {}) => invoke(options, scoped => probeRead.call(descriptor, scoped)) }),
+            stat: (options = {}) => invoke(options, scoped => descriptor.stat(scoped)),
+            read: (buffer, position, options = {}) => invoke(options, scoped => descriptor.read(buffer, position, scoped)),
+            write: (buffer, position, options = {}) => invoke(options, scoped => descriptor.write(buffer, position, scoped)),
+            truncate: (length, options = {}) => invoke(options, scoped => descriptor.truncate(length, scoped)),
+            sync: (dataOnly, options = {}) => invoke(options, scoped => descriptor.sync(dataOnly, scoped)),
+            close: () => closing ??= Promise.resolve().then(() => descriptor.close()),
+        };
+    };
     const wrapStream = (source, options) => ({
         [Symbol.asyncIterator]() {
             assertOpen(options);
@@ -164,12 +198,12 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     const options = args.at(-1);
                     admit(options && typeof options === "object" && "signal" in options ? options : undefined);
                 }
-                if (["writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
+                if (["removeEntryConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
                     return (async () => {
                         const path = typeof args[0] === "string" ? args[0] : args[0].directory.path;
                         const options = args[property === "createStagedFile" ? 3 : property === "publishStagedFile" || property === "writeFileConditional" ? 2 : 1];
                         const create = property === "createStagedFile" || (property === "writeFileConditional" || property === "prepareDirectory") && options !== undefined && "expected" in options && options.expected === null;
-                        await requireOwnedMutation(original, path, property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
+                        await requireOwnedMutation(original, path, property === "removeEntryConditional" ? "atomicEntryRemoval" : property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
                         assertOpen(options);
                         return Reflect.apply(method, original, args);
                     })();
@@ -190,21 +224,38 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     })();
                 return Reflect.apply(method, original, args);
             };
-            const scoped = property === "openResizeFile"
-                ? async (path, options = {}) => {
+            const scoped = property === "open"
+                ? async (path, options) => {
                     admit(options);
-                    assertOpen(options);
-                    return wrapResizeHandle(await openRetainedResizeFile(original, path, resizeOptions(options)));
+                    const selected = resizeOptions(options);
+                    let descriptor;
+                    try {
+                        descriptor = await Reflect.apply(method, original, [path, selected]);
+                        assertOpen(options);
+                        return wrapDescriptor(descriptor);
+                    }
+                    catch (error) {
+                        if (descriptor)
+                            await finishCleanup(() => descriptor.close(), true);
+                        assertOpen(options);
+                        throw error;
+                    }
                 }
-                : property === "capabilitiesFor"
-                    ? async (...args) => ownedMutationCapabilities(original, retainedResizeCapabilities(original, await dispatch(...args)))
-                    : property === "openReadFile"
-                        ? async (...args) => wrapHandle(await dispatch(...args))
-                        : property === "readStream"
-                            ? (...args) => wrapStream(dispatch(...args), args[1])
-                            : operations.has(property) && property !== "canonicalizeMissingTarget"
-                                ? async (...args) => dispatch(...args)
-                                : dispatch;
+                : property === "openResizeFile"
+                    ? async (path, options = {}) => {
+                        admit(options);
+                        assertOpen(options);
+                        return wrapResizeHandle(await openRetainedResizeFile(original, path, resizeOptions(options)));
+                    }
+                    : property === "capabilitiesFor"
+                        ? async (...args) => ownedMutationCapabilities(original, retainedResizeCapabilities(original, await dispatch(...args)))
+                        : property === "openReadFile"
+                            ? async (...args) => wrapHandle(await dispatch(...args))
+                            : property === "readStream"
+                                ? (...args) => wrapStream(dispatch(...args), args[1])
+                                : operations.has(property) && property !== "canonicalizeMissingTarget"
+                                    ? async (...args) => dispatch(...args)
+                                    : dispatch;
             methods.set(property, { original: method, scoped });
             return scoped;
         },

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

@@ -1,6 +1,7 @@
 import type { PlatformComparisonCallback } from "#safe-fs-platform";
 import type { ByteSource } from "../../contracts/io.js";
 import type { AppendFileOptions, CopyFileOptions, DirectoryEntry, EntryComparison, FileStat, FileSystem, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions } from "../../contracts/filesystem.js";
+import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
 export type WebDavFetch = (url: string, init: RequestInit) => Promise<Response>;
 export interface WebDavAtomicEmptyDirectoryRequest {
     readonly operation: "atomic-empty-rmdir/v1";
@@ -33,7 +34,9 @@ export interface WebDavFileSystemOptions {
     readonly compareEntry?: PlatformComparisonCallback<(this: FileSystem, ...args: Parameters<NonNullable<FileSystem["compareEntry"]>>) => ReturnType<NonNullable<FileSystem["compareEntry"]>>>;
 }
 export declare class WebDavFileSystem implements FileSystem {
+    open(path: string, options: OpenFileOptions): Promise<FileDescriptor>;
     readonly capabilities: Readonly<{
+        open: false;
         read: true;
         stat: true;
         readdir: true;

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

@@ -140,7 +140,12 @@ function statusCode(element) {
     return Number(text.split(" ")[1]);
 }
 export class WebDavFileSystem {
+    async open(path, options) {
+        options.signal?.throwIfAborted();
+        throw new FsError("ENOTSUP", { syscall: "open", path });
+    }
     capabilities = Object.freeze({
+        open: false,
         read: true, stat: true, readdir: true, realpath: true, access: true,
         write: true, append: true, exclusiveCreate: true, explicitDirectories: true, implicitDirectories: false,
         mkdir: true, recursiveMkdir: true, remove: true, recursiveRemove: true, rename: true, atomicRenameNoReplace: false, copy: true,

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

@@ -1,4 +1,7 @@
 export * from "./contracts/index.js";
+export * from "./python/index.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export type { DescriptorBackend, DescriptorOpenOptions } from "./fs/descriptor.js";
 export * from "./fs/memory/index.js";
 export * from "./fs/devices/index.js";
 export * from "./fs/real/index.js";

package/dist/safe-fs/index.js

@@ -1,4 +1,6 @@
 export * from "./contracts/index.js";
+export * from "./python/index.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
 export * from "./fs/memory/index.js";
 export * from "./fs/devices/index.js";
 export * from "./fs/real/index.js";

package/dist/safe-fs/python/emscripten.d.ts

@@ -0,0 +1,14 @@
+export interface PythonMountOptions {
+    request: (operation: string, ...args: any[]) => any;
+    cwd: string;
+    runtimeMount: string;
+    maxTransferBytes: number;
+    errno: Record<string, number>;
+    synchronizationFlags: number;
+    runtimeModule: any;
+}
+export declare function mountPythonFileSystem(FS: any, options: PythonMountOptions): void;
+/** Encode the pinned wasm32 musl stat layout without truncating canonical values. */
+export declare function writePythonStat(heap: Uint8Array, pointer: number, stat: Record<string, any>): number;
+/** Runtime storage and application storage occupy disjoint guest device ranges. */
+export declare function createPythonRuntimeStatMapper(maxDevices?: number): (stat: Record<string | symbol, any>) => Record<string | symbol, any>;