@poe-platform/safe-fs 0.1.729 → 0.1.731

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

@@ -18,10 +18,11 @@ export declare class MemoryLedger {
 export declare class MemoryAllocation {
     private references;
     readonly data: Uint8Array;
-    private readonly ledger;
+    private ledger;
     constructor(data: Uint8Array, ledger: MemoryLedger);
     retain(): void;
     release(): void;
     isReleased64(): boolean;
-    reuse(): void;
+    detachLedger(dummyLedger: MemoryLedger): void;
+    reuse(ledger?: MemoryLedger): void;
 }

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

@@ -68,13 +68,18 @@ export class MemoryLedger {
 }
 export class MemoryAllocation {
     constructor(data, ledger) {
+        this.references = 1;
         this.data = data;
         this.ledger = ledger;
     }
     retain() {
+        if (this.data.byteLength === 0)
+            return;
         this.references++;
     }
     release() {
+        if (this.data.byteLength === 0)
+            return;
         if (this.references <= 0)
             throw new Error("Memory allocation already released");
         if (--this.references === 0)
@@ -83,8 +88,13 @@ export class MemoryAllocation {
     isReleased64() {
         return this.references === 0 && this.data.byteLength === 64;
     }
-    reuse() {
+    detachLedger(dummyLedger) {
+        this.ledger = dummyLedger;
+    }
+    reuse(ledger) {
         this.references = 1;
+        if (ledger !== undefined)
+            this.ledger = ledger;
         this.data.fill(0);
     }
 }

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

@@ -188,7 +188,7 @@ export class MountFileSystem {
                     && await this.supportsDirectoryValidation(location.path.slice(0, location.path.lastIndexOf("/")) || "/", options, true)
                 : this.capabilities.conditionalChmod;
             const { synchronousDirectoryValidation: ignoredValidation, synchronousStagingResolution: ignoredResolution, ...ordinary } = resize;
-            const withOpen = { ...ordinary, ...(conditionalChmod === undefined ? {} : { conditionalChmod }), ...(resolution === undefined ? {} : { synchronousStagingResolution: resolution }), ...(validation === undefined ? {} : { synchronousDirectoryValidation: validation }), atomicStagingAncestry: ancestry, ...(typeof location.mount.backend.open === "function" ? {} : { open: false }) };
+            const withOpen = { ...ordinary, retainedStagingWrite: false, ...(conditionalChmod === undefined ? {} : { conditionalChmod }), ...(resolution === undefined ? {} : { synchronousStagingResolution: resolution }), ...(validation === undefined ? {} : { synchronousDirectoryValidation: validation }), atomicStagingAncestry: ancestry, ...(typeof location.mount.backend.open === "function" ? {} : { open: false }) };
             const capabilities = location.synthetic ? { ...withOpen, open: false, retainedRead: false }
                 : retainedResizeCapabilities(location.mount.backend, retainedReadCapabilities(location.mount.backend, withOpen));
             if (location.synthetic)

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

@@ -1,3 +1,4 @@
+import { platform } from "#safe-fs-platform";
 import { snapshotStagingCreation } from "../staging-cleanup.js";
 import { snapshotConditionalChmod } from "../conditional-chmod.js";
 import { runStagingGuard, snapshotDirectoryAncestry } from "../staging-ancestry.js";
@@ -7,6 +8,7 @@ import * as native from "node:fs/promises";
 import { dirname, basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { nativeAllocatedBytes } from "./allocation.js";
 import { openFileDescriptor } from "../descriptor.js";
+import { compareIdentity } from "../mount/identity.js";
 import { finishCleanup } from "../../contracts/cleanup.js";
 import { callNativeSeekEnd, loadNativeSeekBinding } from "../../node/native-seek.js";
 import { admitDirectoryEntries, directoryEntryLimit } from "../directory-admission.js";
@@ -32,11 +34,11 @@ function fileStat(stats) {
         mtimeMs: "mtimeNs" in stats ? Number(stats.mtimeNs / 1000000n) + Number(stats.mtimeNs % 1000000n) / 1e6 : stats.mtimeMs,
         ctimeMs: "ctimeNs" in stats ? Number(stats.ctimeNs / 1000000n) + Number(stats.ctimeNs % 1000000n) / 1e6 : stats.ctimeMs,
         birthtimeMs: "birthtimeNs" in stats ? Number(stats.birthtimeNs / 1000000n) + Number(stats.birthtimeNs % 1000000n) / 1e6 : stats.birthtimeMs, ino, dev,
-        ...(Number.isSafeInteger(dev) && dev >= 0 && Number.isSafeInteger(ino) && ino >= 0
+        ...(Number.isSafeInteger(dev) && dev >= 0 && Number.isSafeInteger(ino) && ino > 0
             ? { identityScope: Symbol.for("virtual-bash.fs.native") } : {}),
         nlink: Number(stats.nlink), uid: Number(stats.uid), gid: Number(stats.gid),
     };
-    if ("ctimeNs" in stats && !stats.isDirectory())
+    if (snapshot.identityScope !== undefined && "ctimeNs" in stats && (stats.ctimeNs !== 0n || stats.mtimeNs !== 0n) && !stats.isDirectory())
         Object.defineProperty(snapshot, "opaqueVersion", { value: `${stats.ctimeNs}:${stats.mtimeNs}`, enumerable: true });
     return snapshot;
 }
@@ -98,14 +100,13 @@ function nativeError(error) {
  */
 export class RealFileSystem {
     capabilities = Object.freeze({
-        read: true, stat: true, readdir: true, realpath: true, access: true, open: true,
+        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, removeDirectory: true, recursiveRemove: true,
         rename: true, atomicRenameNoReplace: false, copy: true, exclusiveCopy: true, readlink: true, truncate: true,
         streamingAppend: true, randomAccessWrite: true,
-        readOnly: false, symlinks: true, hardlinks: true, permissions: true,
-        conditionalChmod: true,
-        timestamps: true, atomicRename: true, streamingRead: true, streamingWrite: true, retainedRead: true, retainedResize: true, trustedOwnedStaging: true,
+        readOnly: false, symlinks: true, hardlinks: true, streamingRead: true, streamingWrite: true, retainedRead: true, retainedResize: true,
+        ...platform.nativeFileSystem,
     });
     configuredRoot;
     renameNoReplace;
@@ -122,6 +123,8 @@ export class RealFileSystem {
         this.configuredRoot = root;
         this.renameNoReplace = typeof options === "string" ? undefined : options.renameNoReplace;
         if (this.renameNoReplace !== undefined) {
+            if (!platform.nativeFileSystem.atomicRename)
+                throw new FsError("ENOTSUP", { syscall: "root", message: "atomic rename is unavailable on this host" });
             if (typeof this.renameNoReplace !== "function")
                 throw new FsError("EINVAL", { syscall: "root", message: "renameNoReplace must be a function" });
             this.capabilities = Object.freeze({ ...this.capabilities, atomicRenameNoReplace: true });
@@ -291,10 +294,15 @@ export class RealFileSystem {
         }
     }
     expectStaging(path, expected, identityOnly = false) {
+        if (!platform.nativeFileSystem.trustedOwnedStaging)
+            throw new FsError("ENOTSUP");
         if (expected && (expected.identityScope !== Symbol.for("virtual-bash.fs.native")
             || expected.dev === undefined || expected.ino === undefined || !identityOnly && expected.opaqueVersion === undefined))
             throw new FsError("ENOTSUP");
         const current = this.stagingSnapshot(path);
+        if (expected && current && (current.identityScope !== Symbol.for("virtual-bash.fs.native")
+            || current.dev === undefined || current.ino === undefined || !identityOnly && current.opaqueVersion === undefined))
+            throw new FsError("ENOTSUP");
         if (expected === null ? current !== null : !current || current.dev !== expected.dev || current.ino !== expected.ino || current.type !== expected.type
             || !identityOnly && (current.opaqueVersion !== expected.opaqueVersion || current.size !== expected.size || current.mode !== expected.mode || current.nlink !== expected.nlink))
             throw new FsError("EAGAIN");
@@ -521,6 +529,8 @@ export class RealFileSystem {
         }
     }
     open(path, options) {
+        if (!platform.nativeFileSystem.open)
+            return this.operation("open", path, options, async () => { throw new FsError("ENOTSUP"); });
         return openFileDescriptor(path, options, {
             noFollow: true, positionedRead: true, positionedWrite: true, truncate: true, synchronization: "storage",
         }, async (admitted) => {
@@ -663,7 +673,7 @@ export class RealFileSystem {
         return this.operation("mkdir", path, options, async () => {
             if (options.mode !== undefined)
                 integer(options.mode);
-            if (options.exactMode && options.recursive)
+            if (options.exactMode && (!platform.nativeFileSystem.permissions || options.recursive))
                 throw new FsError("ENOTSUP");
             const target = await this.path(path, {
                 ...options,
@@ -746,8 +756,13 @@ export class RealFileSystem {
                 }
                 if (target && options.exclusive)
                     throw new FsError("EEXIST");
-                if (target && origin.isFile() && origin.dev === target.dev && origin.ino === target.ino)
-                    throw new FsError("EINVAL");
+                if (target && origin.isFile()) {
+                    const identity = compareIdentity(fileStat(origin), fileStat(target));
+                    if (identity === "same")
+                        throw new FsError("EINVAL");
+                    if (identity === "unknown")
+                        throw new FsError("ENOTSUP");
+                }
                 if (!target)
                     flags |= constants.COPYFILE_EXCL;
             }
@@ -813,6 +828,8 @@ export class RealFileSystem {
     }
     async chmod(path, mode, options = {}) {
         return this.operation("chmod", path, options, async () => {
+            if (!platform.nativeFileSystem.permissions)
+                throw new FsError("ENOTSUP");
             integer(mode);
             const conditional = snapshotConditionalChmod(path, options);
             if (conditional) {
@@ -846,6 +863,8 @@ export class RealFileSystem {
     }
     async utimes(path, atimeMs, mtimeMs, options = {}) {
         return this.operation("utimes", path, options, async () => {
+            if (!platform.nativeFileSystem.timestamps)
+                throw new FsError("ENOTSUP");
             if (!Number.isFinite(atimeMs) || !Number.isFinite(mtimeMs)
                 || Math.abs(atimeMs) > 8.64e15 || Math.abs(mtimeMs) > 8.64e15)
                 throw new FsError("EINVAL");

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

@@ -1,4 +1,5 @@
 import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+export declare function retargetScopedFileSystem(scoped: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, maxPathComponents?: number): boolean;
 export declare function scopeFileSystem(filesystem: FileSystem, charge: () => void, signal: AbortSignal, cleanupCharge?: () => void, options?: {
     readonly preserveDescriptorWriteReceipt?: boolean;
     readonly creationMask?: number;

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

@@ -8,6 +8,14 @@ import { openRetainedResizeFile, retainedResizeCapabilities, ownedMutationCapabi
 import { createStagingCleanup, snapshotStagingCreation } from "./staging-cleanup.js";
 import { inspectStagingBindings, runStagingGuard, snapshotDirectoryAncestry, snapshotStagingResolution } from "./staging-ancestry.js";
 const originals = new WeakMap();
+const retargeters = new WeakMap();
+export function retargetScopedFileSystem(scoped, charge, signal, cleanupCharge = charge, maxPathComponents) {
+    const fn = retargeters.get(scoped);
+    if (!fn)
+        return false;
+    fn(charge, signal, cleanupCharge, maxPathComponents);
+    return true;
+}
 const operations = new Set([
     "prepareDirectoryAncestry", "prepareStagingResolution",
     "publishFileConditional", "removeEntryConditional", "removeTreeConditional", "writeFileConditional", "removeFileConditional", "createStagedFile", "publishStagedFile", "removeStagedFile", "prepareDirectory",
@@ -19,7 +27,7 @@ const operations = new Set([
 export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = charge, options = {}) {
     const original = originals.get(filesystem)?.filesystem ?? filesystem;
     const creationMask = options.creationMask ?? originals.get(filesystem)?.creationMask;
-    const maxPathComponents = options.maxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
+    let maxPathComponents = options.maxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
     if (creationMask !== undefined && (!Number.isInteger(creationMask) || creationMask < 0 || creationMask > 0o777))
         throw new RangeError("creationMask must be a permission mask between 0 and 0777");
     const creationOptions = (settings, directory = false) => {
@@ -343,7 +351,20 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
                                 controls.signal?.throwIfAborted();
                                 return backendCleanup.remove(controls);
                             }, () => backendCleanup.close());
-                            return Object.freeze({ ...staging, cleanup });
+                            const backendWriter = staging.writer;
+                            const writer = backendWriter && Object.freeze({
+                                write: async (bytes, settings = {}) => {
+                                    const controls = resizeOptions(settings);
+                                    admit(controls);
+                                    await backendWriter.write(bytes, controls);
+                                },
+                                finish: async (settings = {}) => {
+                                    const controls = resizeOptions(settings);
+                                    admit(controls);
+                                    return backendWriter.finish(controls);
+                                },
+                            });
+                            return Object.freeze({ ...staging, cleanup, ...(writer ? { writer } : {}) });
                         }
                         catch (error) {
                             await finishCleanup(() => backendCleanup.close(), true);
@@ -471,7 +492,17 @@ export function scopeFileSystem(filesystem, charge, signal, cleanupCharge = char
             return scoped;
         },
     });
-    originals.set(view, { filesystem: original, signal, cleanupCharge, creationMask, maxPathComponents });
+    const originalRecord = { filesystem: original, signal, cleanupCharge, creationMask, maxPathComponents };
+    originals.set(view, originalRecord);
+    retargeters.set(view, (nextCharge, nextSignal, nextCleanupCharge, nextMaxPathComponents) => {
+        charge = nextCharge;
+        signal = nextSignal;
+        cleanupCharge = nextCleanupCharge;
+        maxPathComponents = nextMaxPathComponents ?? originals.get(filesystem)?.maxPathComponents;
+        originalRecord.signal = nextSignal;
+        originalRecord.cleanupCharge = nextCleanupCharge;
+        originalRecord.maxPathComponents = maxPathComponents;
+    });
     registerEntryView(view, async (path, options) => {
         assertOpen(options);
         return { filesystem: original, path };

package/dist/safe-fs/node/native-seek-unavailable.d.ts

@@ -0,0 +1 @@
+export declare function loadBinding(): Promise<never>;

package/dist/safe-fs/node/native-seek-unavailable.js

@@ -0,0 +1,5 @@
+import { FsError } from "../contracts/errors.js";
+// Workers support native file reads, but cannot load the optional Node addon.
+export async function loadBinding() {
+    throw new FsError("ENOTSUP", { message: "Native seek is unavailable in Workers" });
+}

package/dist/safe-fs/platform/browser.d.ts

@@ -3,6 +3,14 @@ import type { ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number | undefined;
 export type PlatformComparisonCallback<Callback> = Callback & never;
 export declare const platform: Readonly<{
+    nativeFileSystem: Readonly<{
+        open: false;
+        permissions: false;
+        timestamps: false;
+        conditionalChmod: false;
+        trustedOwnedStaging: false;
+        atomicRename: false;
+    }>;
     maxCollectionBytes: number;
     errno(_code: string): PlatformErrno;
     callbackAuthorities: false;

package/dist/safe-fs/platform/browser.js

@@ -1,5 +1,6 @@
 import { FsError } from "../contracts/errors.js";
 export const platform = Object.freeze({
+    nativeFileSystem: Object.freeze({ open: false, permissions: false, timestamps: false, conditionalChmod: false, trustedOwnedStaging: false, atomicRename: false }),
     maxCollectionBytes: 32 * 1024 * 1024,
     errno(_code) {
         return undefined;

package/dist/safe-fs/platform/node.d.ts

@@ -4,6 +4,14 @@ import { type ScopedTransportBudgetFrame } from "./transport-budget.js";
 export type PlatformErrno = number;
 export type PlatformComparisonCallback<Callback> = Callback;
 export declare const platform: Readonly<{
+    nativeFileSystem: Readonly<{
+        open: true;
+        permissions: true;
+        timestamps: true;
+        conditionalChmod: true;
+        trustedOwnedStaging: true;
+        atomicRename: true;
+    }>;
     maxCollectionBytes: number;
     errno(code: string): PlatformErrno;
     callbackAuthorities: true;

package/dist/safe-fs/platform/node.js

@@ -16,6 +16,7 @@ const systemErrnos = (() => {
 })();
 const negotiating = new AsyncLocalStorage();
 export const platform = Object.freeze({
+    nativeFileSystem: Object.freeze({ open: true, permissions: true, timestamps: true, conditionalChmod: true, trustedOwnedStaging: true, atomicRename: true }),
     maxCollectionBytes: Infinity,
     errno(code) {
         const errno = systemErrnos.get(code === "EOPNOTSUPP" ? "ENOTSUP" : code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.729",
+  "version": "0.1.731",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -69,9 +69,11 @@
     },
     "./fs/real": {
       "types": {
+        "workerd": "./dist/safe-fs/fs/real/index.d.ts",
         "browser": "./dist/safe-fs/node-unavailable.d.ts",
         "default": "./dist/safe-fs/fs/real/index.d.ts"
       },
+      "workerd": "./dist/safe-fs/fs/real/index.js",
       "browser": null,
       "import": "./dist/safe-fs/fs/real/index.js"
     },
@@ -134,15 +136,17 @@
   "imports": {
     "#safe-fs-platform": {
       "types": {
+        "workerd": "./dist/safe-fs/platform/browser.d.ts",
         "browser": "./dist/safe-fs/platform/browser.d.ts",
         "default": "./dist/safe-fs/platform/node.d.ts"
       },
+      "workerd": "./dist/safe-fs/platform/browser.js",
       "browser": "./dist/safe-fs/platform/browser.js",
       "default": "./dist/safe-fs/platform/node.js"
     },
     "#safe-fs-native-seek": {
       "types": "./dist/safe-fs/native/fs-seek/loader.d.ts",
-      "workerd": null,
+      "workerd": "./dist/safe-fs/node/native-seek-unavailable.js",
       "browser": null,
       "default": "./dist/safe-fs/native/fs-seek/loader.mjs"
     }