@poe-platform/safe-fs 0.1.673 → 0.1.674

package/README.md

@@ -64,12 +64,23 @@ cause. Preserve cancellation/control exceptions separately. Cross-family
 | Remove an empty directory | Optional `rmdir`; never a recursive-delete fallback |
 | Links and metadata | Optional `readlink`, `symlink`, `link`, `chmod`, `utimes`, `truncate` |
 | Stream bytes | Optional `readStream`, `writeStream`, using async iterables of byte chunks |
+| Publish immutable objects atomically | Optional `publishFileConditional` with opaque identity/version stats and authoritative compare-and-publish |
 | Compare backing entries | Optional `compareEntry`, returning `same`, `distinct`, or `unknown` |
 
 All required methods must exist, but a backend may reject an operation with `FsError`, such as `EROFS` for a write or `ENOTSUP` for unsupported semantics. Check optional methods and `capabilities` rather than assuming every backend behaves like a local disk. Errors expose `code` and may include `syscall`, `path`, `dest`, and `cause`.
 
 `createDeviceFileSystem(fs)` adds portable `/dev/null` whole-file, stream, and descriptor I/O. Descriptor reads return EOF and writes discard bytes; stat remains a zero-size character device and descriptor position remains zero. Truncating opens are accepted, exclusive creation fails with `EEXIST`, and descriptor resizing and synchronization are unsupported. Access modes, cancellation, and closed handles use the normal descriptor checks. With an authoritative object store, use `createDeviceFileSystem(withObjectFileDescriptors(fs, store))` so null-device I/O never acquires or publishes an object version; ordinary files retain conditional publication. The device wrapper must be outermost for this composition.
 
+Immutable flat stores can supply `identityScope`, `opaqueIdentity` and an ABA-safe
+`opaqueVersion` on file stats, then expose `atomicFilePublication: true` with
+`publishFileConditional(path, source, { expected, parent, maxBytes, signal })`.
+The host consumes bytes privately and atomically creates an absent binding
+(`expected: null`) or replaces the observed generation. Failed producers,
+uploads and stale writers leave the old file intact. This supports Safe Bash ZIP
+creation and updates without inode numbers, staging directories or permission
+APIs. Read the [conditional publication contract](src/contracts/conditional-publication.md)
+before implementing the host operation; ordinary writes do not provide it.
+
 | Backend or wrapper | Use it for |
 | --- | --- |
 | `createMemoryFileSystem()` | Isolated, nonpersistent storage with links, permissions, timestamps, and streams |

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

@@ -16,6 +16,10 @@ export interface FileStat {
     readonly birthtimeMs?: number;
     readonly revision?: number;
     readonly identityScope?: object | symbol;
+    /** Authoritative backing identity within identityScope; aliases share this key. */
+    readonly opaqueIdentity?: string;
+    /** ABA-safe namespace generation, changed by replacement and delete/recreate. */
+    readonly opaqueVersion?: string;
     readonly ino?: number;
     readonly dev?: number;
     readonly rdevMajor?: number;
@@ -61,6 +65,7 @@ export interface FileSystemCapabilities {
     readonly timestamps?: boolean;
     readonly atomicRename?: boolean;
     readonly atomicFileStaging?: boolean;
+    readonly atomicFilePublication?: boolean;
     readonly atomicFileMutation?: boolean;
     readonly atomicEntryRemoval?: boolean;
     readonly atomicTreeRemoval?: boolean;
@@ -199,7 +204,17 @@ export interface PrepareDirectoryOptions extends FsOptions {
     readonly atimeMs?: number;
     readonly mtimeMs?: number;
 }
+export interface ConditionalFilePublicationOptions extends FsOptions {
+    readonly expected: FileStat | null;
+    readonly parent: FileStat;
+    readonly maxBytes: number;
+    readonly mode?: number;
+    readonly mtimeMs?: number;
+}
 export interface FileSystem {
+    /** Consume the complete source privately, then atomically compare/publish.
+     * Failures before commit preserve the destination. No stat/write fallback. */
+    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>;
     removeTreeConditional?(path: string, options: ConditionalRemoveEntryOptions): Promise<void>;

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

@@ -7,4 +7,4 @@ export declare function openRetainedResizeFile(filesystem: FileSystem, path: str
 export declare function readOnlyCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
 export declare function quotaCapabilities(capabilities: FileSystemCapabilities): FileSystemCapabilities;
 export declare function ownedMutationCapabilities(filesystem: FileSystem, capabilities?: FileSystemCapabilities): FileSystemCapabilities;
-export declare function requireOwnedMutation(filesystem: FileSystem, path: string, capability: "atomicEntryRemoval" | "atomicTreeRemoval" | "atomicFileMutation" | "atomicFileStaging" | "atomicDirectoryMetadata", options: FsOptions, create?: boolean): Promise<void>;
+export declare function requireOwnedMutation(filesystem: FileSystem, path: string, capability: "atomicFilePublication" | "atomicEntryRemoval" | "atomicTreeRemoval" | "atomicFileMutation" | "atomicFileStaging" | "atomicDirectoryMetadata", options: FsOptions, create?: boolean): Promise<void>;

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

@@ -109,20 +109,22 @@ export function readOnlyCapabilities(capabilities) {
         rename: false, copy: false, exclusiveCopy: false, truncate: false, streamingAppend: false,
         randomAccessWrite: false, hardlinks: false, permissions: false, timestamps: false,
         descriptorWriteStream: false, atomicResize: false, retainedResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
-        atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
+        atomicFilePublication: false, atomicRename: false, atomicRenameNoReplace: false, streamingWrite: false,
     });
 }
 export function quotaCapabilities(capabilities) {
     const streamingWrite = requireCapabilities(capabilities.write, capabilities.append, !capabilities.readOnly);
     const streamingAppend = requireCapabilities(capabilities.append, !capabilities.readOnly);
     const { streamingWrite: ignoredWrite, streamingAppend: ignoredAppend, ...rest } = capabilities;
-    return Object.freeze({ ...rest, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+    return Object.freeze({ ...rest, atomicFilePublication: false, descriptorWriteStream: false, atomicResize: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
         ...(streamingWrite === undefined ? {} : { streamingWrite }),
         ...(streamingAppend === undefined ? {} : { streamingAppend }),
     });
 }
 export function ownedMutationCapabilities(filesystem, capabilities = filesystem.capabilities) {
     const unavailable = {};
+    if (capabilities.atomicFilePublication === true && (capabilities.readOnly === true || typeof filesystem.publishFileConditional !== "function"))
+        unavailable.atomicFilePublication = false;
     if (capabilities.atomicEntryRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeEntryConditional !== "function"))
         unavailable.atomicEntryRemoval = false;
     if (capabilities.atomicTreeRemoval === true && (capabilities.readOnly === true || typeof filesystem.removeTreeConditional !== "function"))

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

@@ -1,5 +1,5 @@
 import type { FileDescriptor, OpenFileOptions } from "../../contracts/descriptor.js";
-import type { AppendFileOptions, CapabilityQueryOptions, CopyFileOptions, DirectoryEntry, FileReadHandle, FileResizeHandle, FileResizeOperation, FileResizeOptions, FileStat, FileSystem, OpenReadFileOptions, OpenResizeFileOptions, FileSystemCapabilities, FsOptions, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, 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, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, CreateStagedFileOptions, FileStaging, PublishStagedFileOptions, PrepareDirectoryOptions, StagedFileContent } from "../../contracts/filesystem.js";
 import type { ByteSource } from "../../contracts/io.js";
 export declare class DeviceFileSystem implements FileSystem {
     #private;
@@ -25,6 +25,7 @@ export declare class DeviceFileSystem implements FileSystem {
     rm(path: string, options?: RemoveOptions): Promise<void>;
     unlink(path: string, options?: FsOptions): Promise<void>;
     rmdir(path: string, options?: FsOptions): Promise<void>;
+    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>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;

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

@@ -15,14 +15,14 @@ const deviceCapabilities = Object.freeze({
     remove: false, removeDirectory: false, recursiveRemove: false, rename: false,
     mkdir: false, recursiveMkdir: false, symlinks: false, hardlinks: false, readlink: false,
     permissions: false, timestamps: false, truncate: false, randomAccessWrite: false,
-    open: true, atomicFileMutation: false, atomicEntryRemoval: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+    open: true, atomicFilePublication: false, atomicFileMutation: false, atomicEntryRemoval: false, atomicTreeRemoval: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
     atomicRename: false, atomicRenameNoReplace: false, descriptorWriteStream: true, retainedResize: true, atomicResize: false,
 });
 function globalCapabilities(filesystem) {
     const capabilities = { readOnly: false };
     const optional = {
         open: ["open"],
-        atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
+        atomicFilePublication: ["publishFileConditional"], atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
         streamingRead: ["readStream"], streamingWrite: ["writeStream"], retainedRead: ["openReadFile"],
         streamingAppend: ["writeStream"], descriptorWriteStream: ["writeStream"], retainedResize: ["openResizeFile"], atomicResize: ["resizeFile"],
         symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"],
@@ -441,6 +441,13 @@ export class DeviceFileSystem {
             throw new FsError("ENOTSUP", { path });
         await this.#filesystem.rmdir(path, options);
     }
+    async publishFileConditional(path, source, options) {
+        await this.#mutable(path, options, false);
+        await requireOwnedMutation(this.#filesystem, path, "atomicFilePublication", options, options.expected === null);
+        if (!this.#filesystem.publishFileConditional)
+            throw new FsError("ENOTSUP", { path });
+        return this.#filesystem.publishFileConditional(path, source, options);
+    }
     async writeFileConditional(path, data, options) {
         await this.#mutable(path, options, false);
         await requireOwnedMutation(this.#filesystem, path, "atomicFileMutation", options, options.expected === null);

package/dist/safe-fs/fs/mount/identity.js

@@ -4,9 +4,18 @@ function complete(stat) {
         && typeof dev === "number" && Number.isSafeInteger(dev) && dev >= 0
         && typeof ino === "number" && Number.isSafeInteger(ino) && ino >= 0;
 }
+function opaqueComplete(stat) {
+    return ((typeof stat.identityScope === "object" && stat.identityScope !== null) || typeof stat.identityScope === "symbol")
+        && typeof stat.opaqueIdentity === "string" && stat.opaqueIdentity.length > 0 && stat.opaqueIdentity.length <= 4096;
+}
 export function compareIdentity(left, right) {
-    if (!left || !right || !complete(left) || !complete(right))
+    if (!left || !right)
         return "unknown";
-    return left.identityScope === right.identityScope && left.dev === right.dev && left.ino === right.ino
-        ? "same" : "distinct";
+    if (complete(left) && complete(right))
+        return left.identityScope === right.identityScope && left.dev === right.dev && left.ino === right.ino ? "same" : "distinct";
+    if (opaqueComplete(left) && opaqueComplete(right))
+        return left.identityScope === right.identityScope && left.opaqueIdentity === right.opaqueIdentity ? "same" : "distinct";
+    if ((complete(left) || opaqueComplete(left)) && (complete(right) || opaqueComplete(right)) && left.identityScope !== right.identityScope)
+        return "distinct";
+    return "unknown";
 }

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, 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, RenameOptions, MkdirOptions, ReadDirectoryOptions, ReadFileOptions, ReadStreamOptions, RemoveOptions, WriteFileOptions, ConditionalFilePublicationOptions, ConditionalWriteFileOptions, ConditionalRemoveFileOptions, ConditionalRemoveEntryOptions, CreateStagedFileOptions, FileStaging, 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 {
@@ -35,6 +35,7 @@ export declare class MountFileSystem implements FileSystem {
     unlink(path: string, options?: FsOptions): Promise<void>;
     rm(path: string, options?: RemoveOptions): Promise<void>;
     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>;
     removeFileConditional(path: string, options: ConditionalRemoveFileOptions): Promise<void>;

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

@@ -22,7 +22,7 @@ function fail(code) {
     throw new FsError(code);
 }
 function snapshotStat(stat) {
-    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
+    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, opaqueIdentity, opaqueVersion, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
     return {
         type, size, mode, mtimeMs, atimeMs, ctimeMs,
         ...(revision === undefined ? {} : { revision }),
@@ -31,6 +31,8 @@ function snapshotStat(stat) {
         ...(preferredIoBlockSize === undefined ? {} : { preferredIoBlockSize }),
         ...(birthtimeMs === undefined ? {} : { birthtimeMs }),
         ...(identityScope === undefined ? {} : { identityScope }),
+        ...(opaqueIdentity === undefined ? {} : { opaqueIdentity }),
+        ...(opaqueVersion === undefined ? {} : { opaqueVersion }),
         ...(ino === undefined ? {} : { ino }),
         ...(dev === undefined ? {} : { dev }),
         ...(rdevMajor === undefined ? {} : { rdevMajor }),
@@ -96,7 +98,7 @@ export class MountFileSystem {
         const common = (capability) => {
             const optional = {
                 open: ["open"],
-                atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
+                atomicFilePublication: ["publishFileConditional"], atomicEntryRemoval: ["removeEntryConditional"], atomicTreeRemoval: ["removeTreeConditional"], atomicFileMutation: ["writeFileConditional", "removeFileConditional"], atomicFileStaging: ["createStagedFile", "publishStagedFile", "removeStagedFile"], atomicDirectoryMetadata: ["prepareDirectory"],
                 symlinks: ["symlink", "readlink"], hardlinks: ["link"], permissions: ["chmod"], timestamps: ["utimes"], readlink: ["readlink"],
                 descriptorWriteStream: ["writeStream"], retainedResize: ["openResizeFile"], atomicResize: ["resizeFile"],
             };
@@ -114,7 +116,7 @@ export class MountFileSystem {
             return values.every(value => value === true) ? true : values.every(value => value === false) ? false : undefined;
         };
         const semantics = Object.fromEntries([
-            "atomicEntryRemoval", "atomicTreeRemoval", "atomicFileMutation", "atomicFileStaging", "atomicDirectoryMetadata", "read", "stat", "readdir", "realpath", "access", "open", "versionedDescriptors",
+            "atomicFilePublication", "atomicEntryRemoval", "atomicTreeRemoval", "atomicFileMutation", "atomicFileStaging", "atomicDirectoryMetadata", "read", "stat", "readdir", "realpath", "access", "open", "versionedDescriptors",
             "write", "append", "exclusiveCreate", "explicitDirectories", "implicitDirectories", "mkdir", "recursiveMkdir",
             "remove", "removeDirectory", "recursiveRemove", "rename", "atomicRenameNoReplace", "copy", "exclusiveCopy", "readlink", "truncate",
             "streamingAppend", "randomAccessWrite", "descriptorWriteStream", "retainedResize", "atomicResize", "symlinks", "hardlinks", "permissions", "timestamps",
@@ -581,6 +583,19 @@ export class MountFileSystem {
                 file: { path: file.local, stat: staging.file.stat },
             } };
     }
+    publishFileConditional(path, source, options) {
+        return this.operation("publishFileConditional", path, options, async () => {
+            const location = await this.resolve(path, options, { followFinal: false, entry: true, allowMissing: true });
+            if (this.protected(location.path))
+                fail("EBUSY");
+            this.mutable(location);
+            const backend = location.mount.backend;
+            await requireOwnedMutation(backend, location.local, "atomicFilePublication", options, options.expected === null);
+            if (!backend.publishFileConditional)
+                fail("ENOTSUP");
+            return snapshotStat(await backend.publishFileConditional(location.local, source, options));
+        }, undefined, true);
+    }
     writeFileConditional(path, data, options) {
         return this.operation("writeFileConditional", path, options, async () => {
             const location = await this.resolve(path, options, { followFinal: false, entry: true, allowMissing: true });

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

@@ -8,7 +8,7 @@ import { compareIdentity } from "../mount/identity.js";
 import { compareEntries, registerEntryView } from "../mount/comparison.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
 function snapshotStat(stat) {
-    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
+    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, opaqueIdentity, opaqueVersion, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
     return {
         type, size, mode, mtimeMs, atimeMs, ctimeMs,
         ...(allocatedBytes === undefined ? {} : { allocatedBytes }),
@@ -17,6 +17,8 @@ function snapshotStat(stat) {
         ...(birthtimeMs === undefined ? {} : { birthtimeMs }),
         ...(revision === undefined ? {} : { revision }),
         ...(identityScope === undefined ? {} : { identityScope }),
+        ...(opaqueIdentity === undefined ? {} : { opaqueIdentity }),
+        ...(opaqueVersion === undefined ? {} : { opaqueVersion }),
         ...(ino === undefined ? {} : { ino }),
         ...(dev === undefined ? {} : { dev }),
         ...(rdevMajor === undefined ? {} : { rdevMajor }),
@@ -118,7 +120,7 @@ export class OverlayFileSystem {
         this.capabilities = Object.freeze({
             ...semantics,
             open: false,
-            atomicFileMutation: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
+            atomicFilePublication: false, atomicFileMutation: false, atomicFileStaging: false, atomicDirectoryMetadata: false,
             implicitDirectories: false,
             readlink: upper.readlink === true && this.#lower.capabilities.readlink === true ? true
                 : upper.readlink === false && this.#lower.capabilities.readlink === false ? false : undefined,

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

@@ -439,7 +439,7 @@ export function withFileSystemQuota(fs, options) {
     // capabilities and methods without violating invariants on own properties.
     return new Proxy(Object.create(fs), {
         get(_target, property) {
-            if (property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
+            if (property === "publishFileConditional" || property === "removeEntryConditional" || property === "writeFileConditional" || property === "removeFileConditional" || property === "resizeFile" || property === "canonicalizeMissingTarget" || property === "createStagedFile" || property === "publishStagedFile" || property === "removeStagedFile" || property === "prepareDirectory")
                 return undefined;
             if (property === "capabilities")
                 return quotaCapabilities({ ...retainedResizeCapabilities(fs, retainedReadCapabilities(fs)), ...(typeof fs.open === "function" ? {} : { open: false }) });

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

@@ -11,7 +11,7 @@ function readOnly(syscall, path, dest) {
     throw new FsError("EROFS", { syscall, path, ...(dest === undefined ? {} : { dest }) });
 }
 function snapshotStat(stat) {
-    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
+    const { type, size, allocatedBytes, ioBlockSize, preferredIoBlockSize, mode, mtimeMs, atimeMs, ctimeMs, birthtimeMs, revision, identityScope, opaqueIdentity, opaqueVersion, ino, dev, rdevMajor, rdevMinor, nlink, uid, gid } = stat;
     return {
         type, size, mode, mtimeMs, atimeMs, ctimeMs,
         ...(revision === undefined ? {} : { revision }),
@@ -20,6 +20,8 @@ function snapshotStat(stat) {
         ...(preferredIoBlockSize === undefined ? {} : { preferredIoBlockSize }),
         ...(birthtimeMs === undefined ? {} : { birthtimeMs }),
         ...(identityScope === undefined ? {} : { identityScope }),
+        ...(opaqueIdentity === undefined ? {} : { opaqueIdentity }),
+        ...(opaqueVersion === undefined ? {} : { opaqueVersion }),
         ...(ino === undefined ? {} : { ino }),
         ...(dev === undefined ? {} : { dev }),
         ...(rdevMajor === undefined ? {} : { rdevMajor }),

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

@@ -4,7 +4,7 @@ import { registerEntryView } from "./mount/comparison.js";
 import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabilities, requireOwnedMutation } from "./capabilities.js";
 const originals = new WeakMap();
 const operations = new Set([
-    "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
+    "publishFileConditional", "removeEntryConditional", "removeTreeConditional", "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", "unlink", "stat", "symlink", "truncate", "utimes",
@@ -198,13 +198,17 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                     const options = args.at(-1);
                     admit(options && typeof options === "object" && "signal" in options ? options : undefined);
                 }
-                if (["removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory"].includes(String(property)))
+                if (["publishFileConditional", "removeEntryConditional", "removeTreeConditional", "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 === "removeEntryConditional" ? "atomicEntryRemoval" : property === "removeTreeConditional" ? "atomicTreeRemoval" : property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
+                        const options = args[property === "createStagedFile" ? 3 : property === "publishFileConditional" || property === "publishStagedFile" || property === "writeFileConditional" ? 2 : 1];
+                        const create = property === "createStagedFile" || (property === "publishFileConditional" || property === "writeFileConditional" || property === "prepareDirectory") && options !== undefined && "expected" in options && options.expected === null;
+                        await requireOwnedMutation(original, path, property === "publishFileConditional" ? "atomicFilePublication" : property === "removeEntryConditional" ? "atomicEntryRemoval" : property === "removeTreeConditional" ? "atomicTreeRemoval" : property === "prepareDirectory" ? "atomicDirectoryMetadata" : property === "writeFileConditional" || property === "removeFileConditional" ? "atomicFileMutation" : "atomicFileStaging", options ?? {}, create);
                         assertOpen(options);
+                        if (property === "publishFileConditional") {
+                            args[1] = wrapStream(args[1], options);
+                            args[2] = resizeOptions(options ?? {});
+                        }
                         return Reflect.apply(method, original, args);
                     })();
                 if (property === "compareEntry") {

package/package.json

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