@openclaw/fs-safe 0.13.0 → 0.14.0

package/dist/native-pinned-write.js

@@ -57,6 +57,8 @@ import { FsSafeError } from "./errors.js";
 import { runPinnedWriteWindows } from "./native-pinned-write-windows.js";
 import { openNativeParentAdmission, openNativeRootAdmission } from "./native-parent-admission.js";
 import { assertNativeStaging, writeNativeStage } from "./native-staged-file.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { NativePolicyDirectoryMismatch } from "./native-policy-directory-observation.js";
 import { assertPolicyStagedDirectoryCurrent, assertStagedDirectoryCurrent, describePolicyStagedDirectory, describeStagedDirectory, refreshPolicyStagedDirectoryObservation, } from "./staged-directory.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { realpathSync } from "./realpath.js";
@@ -117,8 +119,8 @@ async function describePosixParent(parentFd, pathname) {
         observation: checkedMutationDirectory(parentPath, directory.realPath, parentPathStat),
     };
 }
-function describePolicyPosixParent(parentFd, pathname) {
-    const policyDirectory = describePolicyStagedDirectory(parentFd, pathname);
+function describePolicyPosixParent(binding, parentFd, pathname) {
+    const policyDirectory = describePolicyStagedDirectory(parentFd, pathname, binding);
     return {
         parentFd,
         parentPath: policyDirectory.directory.realPath,
@@ -130,11 +132,12 @@ function describePolicyPosixParent(parentFd, pathname) {
 }
 function policyParentCaptureDeopt(error) {
     return error instanceof FsSafeError &&
+        !(error instanceof NativePolicyDirectoryMismatch) &&
         (error.code === "path-mismatch" || error.code === "not-file");
 }
-function tryDescribePolicyPosixParent(parentFd, pathname) {
+function tryDescribePolicyPosixParent(binding, parentFd, pathname) {
     try {
-        return describePolicyPosixParent(parentFd, pathname);
+        return describePolicyPosixParent(binding, parentFd, pathname);
     }
     catch (error) {
         if (!policyParentCaptureDeopt(error))
@@ -148,183 +151,217 @@ function assertPosixParentCurrent(parent) {
         : assertStagedDirectoryCurrent(parent.directory);
 }
 async function capturePolicyAwarePosixParent(binding, params, rootFd, directoryFlags) {
-    const segments = relativeParentSegments(params.relativeParentPath);
-    const parentSpelling = segments.length
-        ? path.join(params.rootPath, ...segments)
-        : params.rootPath;
-    const segmentRoute = createPathSegmentRoute(segments);
-    const initialTarget = prospectiveTargetPath(params.rootPath, segmentRoute, 0, params.basename);
-    let retainedTargetPath = params.mutationAdmission?.beginParentWalk?.();
-    if (retainedTargetPath && !sameAbsolutePath(retainedTargetPath, initialTarget)) {
-        retainedTargetPath = undefined;
-    }
-    // Preserve the one-open hot path when the complete parent still exists.
-    // Policy is attached only after the opened descriptor is associated with its
-    // current canonical pathname, so a contained redirect cannot retain the old
-    // preflight authorization.
-    let completeParentFd;
+    const env_1 = { stack: [], error: void 0, hasError: false };
     try {
-        completeParentFd = binding.openBeneath(rootFd, params.relativeParentPath, directoryFlags).fd;
-    }
-    catch (error) {
-        if (error?.code !== "ENOENT" || !params.mkdir)
-            throw error;
-    }
-    if (completeParentFd !== undefined) {
-        const parentFd = completeParentFd;
+        const closeFd = captureNativeFdClose(binding);
+        const observationDisposers = new Map();
+        const disposeObservation = (fd) => {
+            const dispose = observationDisposers.get(fd);
+            observationDisposers.delete(fd);
+            dispose?.();
+        };
+        const observationScope = __addDisposableResource(env_1, {
+            [Symbol.dispose]() { for (const dispose of observationDisposers.values())
+                dispose(); },
+        }, false);
+        const capturePolicyParent = (fd, pathname) => {
+            const captured = tryDescribePolicyPosixParent(binding, fd, pathname);
+            const dispose = captured?.policyDirectory?.disposeObservation;
+            if (dispose)
+                observationDisposers.set(fd, dispose);
+            return captured;
+        };
+        const segments = relativeParentSegments(params.relativeParentPath);
+        const parentSpelling = segments.length
+            ? path.join(params.rootPath, ...segments)
+            : params.rootPath;
+        const segmentRoute = createPathSegmentRoute(segments);
+        const initialTarget = prospectiveTargetPath(params.rootPath, segmentRoute, 0, params.basename);
+        let retainedTargetPath = params.mutationAdmission?.beginParentWalk?.();
+        if (retainedTargetPath && !sameAbsolutePath(retainedTargetPath, initialTarget)) {
+            retainedTargetPath = undefined;
+        }
+        // Preserve the one-open hot path when the complete parent still exists.
+        // Policy is attached only after the opened descriptor is associated with its
+        // current canonical pathname, so a contained redirect cannot retain the old
+        // preflight authorization.
+        let completeParentFd;
         try {
-            let admitted = retainedTargetPath
-                ? tryDescribePolicyPosixParent(parentFd, parentSpelling)
-                : undefined;
-            if (!admitted) {
-                retainedTargetPath = undefined;
-                admitted = await describePosixParent(parentFd, parentSpelling);
-            }
-            const targetPath = path.join(admitted.parentPath, params.basename);
-            await authorizePinnedMutation(params, {
-                targetPath,
-                mutationPath: targetPath,
-                phase: "parent",
-            });
-            assertPosixParentCurrent(admitted);
-            return admitted;
+            completeParentFd = binding.openBeneath(rootFd, params.relativeParentPath, directoryFlags).fd;
         }
         catch (error) {
-            fsSync.closeSync(parentFd);
-            throw error;
+            if (error?.code !== "ENOENT" || !params.mkdir)
+                throw error;
         }
-    }
-    // The canonical preflight spelling has no intentional symlinks in its
-    // existing prefix. Walk missing-parent cases one direct child at a time so
-    // every existing/opened object is authorized and every mkdir is authorized
-    // before dispatch. O_NOFOLLOW makes a concurrently introduced link fail
-    // before the next component can be created through it.
-    const secureDirectoryFlags = directoryFlags | (fsSync.constants.O_NOFOLLOW ?? 0);
-    let currentFd = rootFd;
-    let currentOwnedFd;
-    let currentPath = params.rootPath;
-    let current = retainedTargetPath
-        ? tryDescribePolicyPosixParent(rootFd, currentPath)
-        : undefined;
-    if (!current) {
-        retainedTargetPath = undefined;
-        current = await describePosixParent(rootFd, currentPath);
-    }
-    try {
-        await authorizePinnedMutation(params, {
-            targetPath: retainedTargetPath ?? initialTarget,
-            mutationPath: retainedTargetPath ?? initialTarget,
-            phase: "parent",
-        });
-        assertPosixParentCurrent(current);
-        for (let index = 0; index < segments.length; index += 1) {
-            const segment = segments[index];
-            const childPath = path.join(currentPath, segment);
-            let childFd;
-            let createdByMkdir = false;
-            let createReceipt;
+        if (completeParentFd !== undefined) {
+            const parentFd = completeParentFd;
             try {
-                childFd = binding.openBeneath(currentFd, segment, secureDirectoryFlags).fd;
-            }
-            catch (openError) {
-                if (!isNotFoundPathError(openError)) {
-                    throw normalizePolicyParentOpenError(openError, params);
+                let admitted = retainedTargetPath
+                    ? capturePolicyParent(parentFd, parentSpelling)
+                    : undefined;
+                if (!admitted) {
+                    retainedTargetPath = undefined;
+                    admitted = await describePosixParent(parentFd, parentSpelling);
                 }
-                const targetPath = retainedTargetPath ?? prospectiveTargetPath(currentPath, segmentRoute, index, params.basename);
-                const request = Object.freeze({
+                const targetPath = path.join(admitted.parentPath, params.basename);
+                await authorizePinnedMutation(params, {
                     targetPath,
-                    mutationPath: childPath,
-                    phase: "parent-create",
+                    mutationPath: targetPath,
+                    phase: "parent",
                 });
-                createReceipt = params.mutationAdmission?.tryAuthorizeAtParent?.(request, current.observation);
-                if (!createReceipt) {
-                    createReceipt = await authorizePinnedMutation(params, request);
-                    assertPosixParentCurrent(current);
-                }
-                params.assertBeforeMutation?.();
-                // Do not carry pathname freshness across the live authority callback.
-                assertPosixParentCurrent(current);
-                createdByMkdir = mkdirPolicyChild(binding, currentFd, segment, 0o777);
+                assertPosixParentCurrent(admitted);
+                return admitted;
+            }
+            catch (error) {
+                disposeObservation(parentFd);
+                closeFd(parentFd);
+                throw error;
+            }
+        }
+        // The canonical preflight spelling has no intentional symlinks in its
+        // existing prefix. Walk missing-parent cases one direct child at a time so
+        // every existing/opened object is authorized and every mkdir is authorized
+        // before dispatch. O_NOFOLLOW makes a concurrently introduced link fail
+        // before the next component can be created through it.
+        const secureDirectoryFlags = directoryFlags | (fsSync.constants.O_NOFOLLOW ?? 0);
+        let currentFd = rootFd;
+        let currentOwnedFd;
+        let currentPath = params.rootPath;
+        let current = retainedTargetPath
+            ? capturePolicyParent(rootFd, currentPath)
+            : undefined;
+        if (!current) {
+            retainedTargetPath = undefined;
+            current = await describePosixParent(rootFd, currentPath);
+        }
+        try {
+            await authorizePinnedMutation(params, {
+                targetPath: retainedTargetPath ?? initialTarget,
+                mutationPath: retainedTargetPath ?? initialTarget,
+                phase: "parent",
+            });
+            assertPosixParentCurrent(current);
+            for (let index = 0; index < segments.length; index += 1) {
+                const segment = segments[index];
+                const childPath = path.join(currentPath, segment);
+                let childFd;
+                let createdByMkdir = false;
+                let createReceipt;
                 try {
                     childFd = binding.openBeneath(currentFd, segment, secureDirectoryFlags).fd;
                 }
-                catch (createdOpenError) {
-                    throw normalizePolicyParentOpenError(createdOpenError, params);
-                }
-            }
-            let child;
-            try {
-                const acceleratedChild = retainedTargetPath
-                    ? tryDescribePolicyPosixParent(childFd, childPath)
-                    : undefined;
-                if (acceleratedChild) {
-                    child = acceleratedChild;
-                }
-                else {
-                    retainedTargetPath = undefined;
-                    child = await describePosixParent(childFd, childPath);
-                }
-                if (!sameAbsolutePath(child.parentPath, childPath))
-                    retainedTargetPath = undefined;
-                let childAuthorization;
-                if (createdByMkdir && createReceipt && params.mutationAdmission?.advanceCreatedDirectory) {
-                    let evidence;
+                catch (openError) {
+                    if (!isNotFoundPathError(openError)) {
+                        throw normalizePolicyParentOpenError(openError, params);
+                    }
+                    const targetPath = retainedTargetPath ?? prospectiveTargetPath(currentPath, segmentRoute, index, params.basename);
+                    const request = Object.freeze({
+                        targetPath,
+                        mutationPath: childPath,
+                        phase: "parent-create",
+                    });
+                    createReceipt = params.mutationAdmission?.tryAuthorizeAtParent?.(request, current.observation);
+                    if (!createReceipt) {
+                        createReceipt = await authorizePinnedMutation(params, request);
+                        assertPosixParentCurrent(current);
+                    }
+                    params.assertBeforeMutation?.();
+                    // Do not carry pathname freshness across the live authority callback.
+                    assertPosixParentCurrent(current);
+                    createdByMkdir = mkdirPolicyChild(binding, currentFd, segment, 0o777);
                     try {
-                        const parent = current.policyDirectory
-                            ? refreshPolicyStagedDirectoryObservation(current.policyDirectory)
-                            : checkedMutationDirectory(currentPath, current.directory.realPath, assertStagedDirectoryCurrent(current.directory));
-                        evidence = Object.freeze({
-                            admission: createReceipt,
-                            parent,
-                            child: child.observation,
-                        });
+                        childFd = binding.openBeneath(currentFd, segment, secureDirectoryFlags).fd;
                     }
-                    catch {
-                        // Leave failed evidence to the full ordered admission below.
+                    catch (createdOpenError) {
+                        throw normalizePolicyParentOpenError(createdOpenError, params);
                     }
-                    if (evidence) {
-                        childAuthorization = params.mutationAdmission.advanceCreatedDirectory(evidence);
+                }
+                let child;
+                try {
+                    const acceleratedChild = retainedTargetPath
+                        ? capturePolicyParent(childFd, childPath)
+                        : undefined;
+                    if (acceleratedChild) {
+                        child = acceleratedChild;
+                    }
+                    else {
+                        retainedTargetPath = undefined;
+                        child = await describePosixParent(childFd, childPath);
+                    }
+                    if (!sameAbsolutePath(child.parentPath, childPath))
+                        retainedTargetPath = undefined;
+                    let childAuthorization;
+                    if (createdByMkdir && createReceipt && params.mutationAdmission?.advanceCreatedDirectory) {
+                        let evidence;
+                        try {
+                            const parent = current.policyDirectory
+                                ? refreshPolicyStagedDirectoryObservation(current.policyDirectory)
+                                : checkedMutationDirectory(currentPath, current.directory.realPath, assertStagedDirectoryCurrent(current.directory));
+                            evidence = Object.freeze({
+                                admission: createReceipt,
+                                parent,
+                                child: child.observation,
+                            });
+                        }
+                        catch {
+                            // Leave failed evidence to the full ordered admission below.
+                        }
+                        if (evidence) {
+                            childAuthorization = params.mutationAdmission.advanceCreatedDirectory(evidence);
+                        }
+                    }
+                    const targetPath = retainedTargetPath ?? prospectiveTargetPath(child.parentPath, segmentRoute, index + 1, params.basename);
+                    const request = Object.freeze({
+                        targetPath,
+                        mutationPath: targetPath,
+                        phase: "parent",
+                    });
+                    childAuthorization ??= params.mutationAdmission?.tryAuthorizeAtParent?.(request, child.observation);
+                    if (!childAuthorization) {
+                        await authorizePinnedMutation(params, request);
+                        assertPosixParentCurrent(child);
                     }
                 }
-                const targetPath = retainedTargetPath ?? prospectiveTargetPath(child.parentPath, segmentRoute, index + 1, params.basename);
-                const request = Object.freeze({
-                    targetPath,
-                    mutationPath: targetPath,
-                    phase: "parent",
-                });
-                childAuthorization ??= params.mutationAdmission?.tryAuthorizeAtParent?.(request, child.observation);
-                if (!childAuthorization) {
-                    await authorizePinnedMutation(params, request);
-                    assertPosixParentCurrent(child);
+                catch (error) {
+                    disposeObservation(childFd);
+                    closeFd(childFd);
+                    throw error;
+                }
+                const previousOwnedFd = currentOwnedFd;
+                disposeObservation(current.parentFd);
+                currentOwnedFd = child.parentFd;
+                currentFd = child.parentFd;
+                currentPath = child.parentPath;
+                current = child;
+                if (previousOwnedFd !== undefined)
+                    closeFd(previousOwnedFd);
+                if (index === segments.length - 1) {
+                    currentOwnedFd = undefined;
+                    return child;
                 }
             }
-            catch (error) {
-                fsSync.closeSync(childFd);
-                throw error;
-            }
-            const previousOwnedFd = currentOwnedFd;
-            currentOwnedFd = child.parentFd;
-            currentFd = child.parentFd;
-            currentPath = child.parentPath;
-            current = child;
-            if (previousOwnedFd !== undefined)
-                fsSync.closeSync(previousOwnedFd);
-            if (index === segments.length - 1) {
-                currentOwnedFd = undefined;
-                return child;
+            // Empty relative parents are handled by the complete-parent fast path.
+            throw new FsSafeError("path-mismatch", "native write parent admission did not complete");
+        }
+        finally {
+            if (currentOwnedFd !== undefined) {
+                disposeObservation(currentOwnedFd);
+                closeFd(currentOwnedFd);
             }
         }
-        // Empty relative parents are handled by the complete-parent fast path.
-        throw new FsSafeError("path-mismatch", "native write parent admission did not complete");
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
     }
     finally {
-        if (currentOwnedFd !== undefined)
-            fsSync.closeSync(currentOwnedFd);
+        __disposeResources(env_1);
     }
 }
 export async function runPinnedWriteNative(binding, params) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        const closeFd = captureNativeFdClose(binding);
         const windows = process.platform === "win32";
         if (!windows) {
             assertNativeStaging(binding);
@@ -336,15 +373,15 @@ export async function runPinnedWriteNative(binding, params) {
             operation: "native write",
         });
         const root = rootAdmission.root;
-        const posixRoot = __addDisposableResource(env_1, windows ? undefined : root, true);
+        const posixRoot = __addDisposableResource(env_2, windows ? undefined : root, true);
         let parentFd;
         let windowsOwnsDirectories = false;
         // Until stage construction takes ownership, even admission failures must close
         // the raw POSIX parent. Disposal preserves both admission and close failures.
-        const parentGuard = __addDisposableResource(env_1, {
+        const parentGuard = __addDisposableResource(env_2, {
             [Symbol.dispose]() {
                 if (!windows && parentFd !== undefined) {
-                    fsSync.closeSync(parentFd);
+                    closeFd(parentFd);
                 }
             },
         }, false);
@@ -400,7 +437,7 @@ export async function runPinnedWriteNative(binding, params) {
             }
             const ownedParent = parentFd;
             parentFd = undefined;
-            return await writeNativeStage(binding, ownedParent, directory, params, verificationGuard);
+            return await writeNativeStage(binding, ownedParent, closeFd, directory, params, verificationGuard);
         }
         finally {
             if (windows && !windowsOwnsDirectories) {
@@ -410,7 +447,7 @@ export async function runPinnedWriteNative(binding, params) {
                     // a close attempt. In particular, a parent close failure must not skip
                     // the root FileHandle close.
                     try {
-                        fsSync.closeSync(parentFd);
+                        closeFd(parentFd);
                     }
                     catch {
                         // Best effort while propagating the operation failure.
@@ -420,12 +457,12 @@ export async function runPinnedWriteNative(binding, params) {
             }
         }
     }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
     }
     finally {
-        const result_1 = __disposeResources(env_1);
+        const result_1 = __disposeResources(env_2);
         if (result_1)
             await result_1;
     }

package/dist/native-policy-directory-observation.d.ts

@@ -0,0 +1,12 @@
+import { FsSafeError } from "./errors.js";
+import type { NativeBinding } from "./native-binding.js";
+import type { MutationDirectoryObserver } from "./pinned-mutation-observation.js";
+export declare class NativePolicyDirectoryMismatch extends FsSafeError {
+    constructor(cause?: Error);
+}
+export type NativePolicyDirectoryObserver = MutationDirectoryObserver & {
+    dispose(): void;
+};
+/** Fresh name/metadata/canonical facts from a caller-owned POSIX descriptor. */
+export declare function nativePolicyDirectoryObserver(binding: NativeBinding | undefined, fd: number, pathname: string): NativePolicyDirectoryObserver | undefined;
+//# sourceMappingURL=native-policy-directory-observation.d.ts.map

package/dist/native-policy-directory-observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-policy-directory-observation.d.ts","sourceRoot":"","sources":["../src/native-policy-directory-observation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAElF,qBAAa,6BAA8B,SAAQ,WAAW;IAC5D,YAAY,KAAK,CAAC,EAAE,KAAK,EAExB;CACF;AAED,MAAM,MAAM,6BAA6B,GAAG,yBAAyB,GAAG;IAAE,OAAO,IAAI,IAAI,CAAA;CAAE,CAAC;AAE5F,gFAAgF;AAChF,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACf,6BAA6B,GAAG,SAAS,CA2C3C"}

package/dist/native-policy-directory-observation.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+export class NativePolicyDirectoryMismatch extends FsSafeError {
+    constructor(cause) {
+        super("path-mismatch", "staging directory pathname changed", { cause });
+    }
+}
+/** Fresh name/metadata/canonical facts from a caller-owned POSIX descriptor. */
+export function nativePolicyDirectoryObserver(binding, fd, pathname) {
+    if (!binding || process.platform === "win32" || process.versions.bun)
+        return undefined;
+    const observe = binding.observeDirectoryFd;
+    if (typeof observe !== "function")
+        return undefined;
+    const mode = getFsSafeNativeConfig().mode;
+    let disposed = false;
+    const inspect = () => {
+        if (disposed)
+            throw new NativePolicyDirectoryMismatch();
+        if (getFsSafeNativeConfig().mode !== mode)
+            return undefined;
+        let observed;
+        try {
+            observed = observe.call(binding, fd, pathname);
+        }
+        catch (error) {
+            if (error?.code === "OBSERVATION_UNAVAILABLE")
+                return undefined;
+            if (error?.code === "OBSERVATION_REDIRECTED") {
+                // A contained redirect requires ordinary selected-object admission;
+                // it has not yet supplied inconsistent descriptor/name evidence.
+                throw new FsSafeError("path-mismatch", "staging directory pathname redirected");
+            }
+            if (error?.code === "path-mismatch") {
+                throw new NativePolicyDirectoryMismatch(error instanceof Error ? error : undefined);
+            }
+            throw error;
+        }
+        if (getFsSafeNativeConfig().mode !== mode)
+            return undefined;
+        if (!observed || typeof observed.dev !== "bigint" || observed.dev < 0n || observed.dev > 0xffffffffffffffffn ||
+            typeof observed.ino !== "bigint" || observed.ino < 0n || observed.ino > 0xffffffffffffffffn ||
+            typeof observed.mode !== "bigint" || observed.mode < 0n || observed.mode > 0xffffffffn ||
+            typeof observed.nlink !== "bigint" || observed.nlink < 0n || observed.nlink > 0xffffffffffffffffn ||
+            typeof observed.realPath !== "string" || observed.realPath.includes("\0") ||
+            !path.isAbsolute(observed.realPath))
+            return undefined;
+        if ((observed.mode & 61440n) !== 16384n || observed.nlink === 0n ||
+            observed.realPath !== pathname) {
+            throw new NativePolicyDirectoryMismatch();
+        }
+        return Object.freeze({
+            canonicalPath: observed.realPath,
+            identity: Object.freeze({
+                dev: observed.dev, ino: observed.ino, mode: observed.mode, nlink: observed.nlink,
+            }),
+        });
+    };
+    return Object.assign(inspect, { dispose() { disposed = true; } });
+}

package/dist/native-staged-file.d.ts

@@ -1,16 +1,16 @@
 import type { DirectoryReceipt } from "./directory-durability.js";
 import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
 import type { FileIdentityStat } from "./file-identity.js";
-import type { NativeBinding } from "./native-binding.js";
+import { type NativeBinding } from "./native-binding.js";
 import type { PinnedWriteInput, PinnedWriteParams } from "./pinned-write.js";
 import type { PublishedFileReceipt, StagedFile, StagedFileCleanupReceipt, StagedFileReceipt } from "./staged-file-types.js";
 export type NativeStagingBinding = NativeBinding & Required<Pick<NativeBinding, "createStagedFile" | "stagedFileMatches" | "removeStagedFile">>;
 export declare function assertNativeStaging(binding: NativeBinding): asserts binding is NativeStagingBinding;
 declare class NativeStagedFile implements StagedFile {
     #private;
-    constructor(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], portableNames: boolean, publishedMode: number, sync: boolean, assertBeforeMutation?: () => void);
-    static create(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], input: PinnedWriteInput, mode: number, maxBytes?: number, portableNames?: boolean, sync?: boolean, assertBeforeMutation?: () => void): Promise<NativeStagedFile>;
-    static write(binding: NativeStagingBinding, parentFd: number, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
+    constructor(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], portableNames: boolean, publishedMode: number, sync: boolean, assertBeforeMutation?: () => void);
+    static create(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], input: PinnedWriteInput, mode: number, maxBytes?: number, portableNames?: boolean, sync?: boolean, assertBeforeMutation?: () => void): Promise<NativeStagedFile>;
+    static write(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
     get receipt(): StagedFileReceipt;
     assertCurrent(): Promise<void>;
     publish(basename: string, options: {

package/dist/native-staged-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"native-staged-file.d.ts","sourceRoot":"","sources":["../src/native-staged-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAMlE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAGnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAG7E,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,wBAAwB,EAGxB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,QAAQ,CAAC,IAAI,CAC9D,aAAa,EACb,kBAAkB,GAAG,mBAAmB,GAAG,kBAAkB,CAC9D,CAAC,CAAC;AAEH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,IAAI,oBAAoB,CAUnG;AA6BD,cAAM,gBAAiB,YAAW,UAAU;;IAa1C,YACE,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,aAAa,EAAE,OAAO,EACtB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,OAAO,EACb,oBAAoB,CAAC,EAAE,MAAM,IAAI,EASlC;IAGD,OAAa,MAAM,CACjB,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,MAAM,EAEjB,aAAa,UAAO,EACpB,IAAI,UAAO,EACX,oBAAoB,CAAC,EAAE,MAAM,IAAI,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAc3B;IAED,OAAa,KAAK,CAChB,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,iBAAiB,CAAC,WAAW,CAAC,EACzC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAc3B;IAED,IAAI,OAAO,IAAI,iBAAiB,CAK/B;IA8FK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAEnC;IAEK,OAAO,CACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;QAAE,SAAS,EAAE,OAAO,CAAA;KAAE,EAC/B,WAAW,CAAC,EAAE,iBAAiB,CAAC,aAAa,CAAC,GAC7C,OAAO,CAAC,oBAAoB,CAAC,CAyD/B;IA6CK,OAAO,IAAI,OAAO,CAAC,wBAAwB,CAAC,CAMjD;IAEK,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAO3C;CACF;AAED,eAAO,MAAM,iBAAiB,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,UAAU,CAClF,CAAC;AAC1B,eAAO,MAAM,gBAAgB,+BAAyB,CAAC;AAEvD,YAAY,EACV,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,EAAE,wBAAwB,EACpF,qBAAqB,EAAE,iBAAiB,GACzC,MAAM,wBAAwB,CAAC;AAEhC,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAClD,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACrC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,UAAU,CAAC,CAUtB"}
+{"version":3,"file":"native-staged-file.d.ts","sourceRoot":"","sources":["../src/native-staged-file.ts"],"names":[],"mappings":"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"}