@openclaw/fs-safe 0.17.0 → 0.18.1

package/dist/create-file-async.d.ts

@@ -1,7 +0,0 @@
-import { type FileHandle } from "node:fs/promises";
-import { type CreationPath } from "./creation-path.js";
-export declare function createPrivateWindowsFileHandle(selected: CreationPath, options: {
-    mode: number;
-    assertBeforeMutation?: () => void;
-}): Promise<FileHandle>;
-//# sourceMappingURL=create-file-async.d.ts.map

package/dist/create-file-async.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-file-async.d.ts","sourceRoot":"","sources":["../src/create-file-async.ts"],"names":[],"mappings":"AAEA,OAAW,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAevD,OAAO,EAAmD,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAKxG,wBAAsB,8BAA8B,CAClD,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAA;CAAE,GAC3D,OAAO,CAAC,UAAU,CAAC,CA0FrB"}

package/dist/create-file-async.js

@@ -1,121 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fsSync, {} from "node:fs";
-import fs, {} from "node:fs/promises";
-import path from "node:path";
-import { createDirectoryWithReceipt } from "./create-directory.js";
-import { assertDirectoryIdentitySync } from "./directory-guard.js";
-import { FsSafeError } from "./errors.js";
-import { assertSynchronousCallbackResult } from "./mutation-authority.js";
-import { assertCreationFile, creationPublicationAfterFailure, privateFileSettlementFailure, rethrowPrivateStageCreationFailure, removeRecordedCreationFile, } from "./creation-file-state.js";
-import { inspectCreationDirectory, protectCreatedFile, verifyCreatedFile } from "./creation-permissions.js";
-import { creationCollision, removeCreationDirectoryAsync } from "./creation-path.js";
-import { handoffCreatedFile } from "./private-producer-handoff.js";
-import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { hasUnsettledWindowsSecurityCommand } from "./windows-security-command.js";
-export async function createPrivateWindowsFileHandle(selected, options) {
-    const assertion = options.assertBeforeMutation;
-    const existing = await fs.lstat(selected.target).catch((error) => {
-        if (error.code !== "ENOENT")
-            throw error;
-        return undefined;
-    });
-    selected.assertParent();
-    if (existing)
-        throw new FsSafeError("already-exists", "creation target already exists");
-    const parentIdentity = await inspectCreationDirectory(selected.parent.dir, false);
-    selected.assertParent();
-    const stageDirectory = path.join(selected.parent.dir, `.fs-safe-create-${randomUUID()}`);
-    let stage;
-    try {
-        stage = await createDirectoryWithReceipt(stageDirectory, { private: true, assertBeforeMutation: assertion }, {
-            expectedParentIdentity: selected.parent.stat,
-        });
-    }
-    catch (error) {
-        rethrowPrivateStageCreationFailure(error, selected.target, stageDirectory);
-    }
-    const stageIdentity = stage.windowsIdentity;
-    const stagePath = path.join(stageDirectory, "file");
-    const assertStage = () => {
-        selected.assertParent();
-        assertDirectoryIdentitySync(stageDirectory, stage.stat);
-    };
-    let file;
-    let identity;
-    let publication = "not-published";
-    try {
-        if (await inspectCreationDirectory(stageDirectory, true) !== stageIdentity) {
-            throw new FsSafeError("path-mismatch", "private staging directory changed before file creation");
-        }
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        assertStage();
-        file = await fs.open(stagePath, fsSync.constants.O_RDWR | fsSync.constants.O_CREAT |
-            fsSync.constants.O_EXCL | resolveReadOpenFlags(), 0o600);
-        assertStage();
-        identity = assertCreationFile(file.fd, stagePath);
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        assertStage();
-        assertCreationFile(file.fd, stagePath, identity);
-        const windowsIdentity = await protectCreatedFile(file.fd, stagePath, stageIdentity);
-        assertStage();
-        assertCreationFile(file.fd, stagePath, identity);
-        const source = file;
-        file = undefined;
-        // The handoff consumes the source pin on both success and failure.
-        file = await handoffCreatedFile({
-            source, sourcePath: stagePath, targetPath: selected.target, identity,
-            assertSourceParent: assertStage, assertTargetParent: selected.assertParent,
-            assertBeforeMutation: assertion,
-            verifyDescriptor: (fd, pathname, links) => verifyCreatedFile(fd, pathname, windowsIdentity, pathname === stagePath ? stageIdentity : parentIdentity, links),
-            onPublished: () => { publication = "published"; },
-        });
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        selected.assertParent();
-        assertCreationFile(file.fd, selected.target, identity);
-        await verifyCreatedFile(file.fd, selected.target, windowsIdentity, parentIdentity);
-        selected.assertParent();
-        assertCreationFile(file.fd, selected.target, identity);
-        await file.chmod(options.mode);
-        await verifyCreatedFile(file.fd, selected.target, windowsIdentity, parentIdentity);
-        selected.assertParent();
-        assertCreationFile(file.fd, selected.target, identity);
-        await removeCreationDirectoryAsync(stageDirectory, stage.stat, selected.assertParent);
-        selected.assertParent();
-        assertCreationFile(file.fd, selected.target, identity);
-        return file;
-    }
-    catch (primary) {
-        publication = creationPublicationAfterFailure(primary, publication);
-        const preserved = publication === "indeterminate" || hasUnsettledWindowsSecurityCommand(primary);
-        const cleanup = [];
-        if (file) {
-            const owned = file;
-            file = undefined;
-            try {
-                await owned.close();
-            }
-            catch (error) {
-                cleanup.push(error);
-            }
-        }
-        if (!preserved) {
-            if (identity) {
-                try {
-                    await removeRecordedCreationFile(stagePath, identity, assertStage);
-                }
-                catch (error) {
-                    cleanup.push(error);
-                }
-            }
-            try {
-                await removeCreationDirectoryAsync(stageDirectory, stage.stat, selected.assertParent);
-            }
-            catch (error) {
-                cleanup.push(error);
-            }
-        }
-        if (publication === "not-published" && cleanup.length === 0 && !preserved)
-            throw creationCollision(primary);
-        throw privateFileSettlementFailure({ primary, cleanup, publication, path: selected.target, stageDirectory, preserved });
-    }
-}

package/dist/create-file.d.ts

@@ -1,8 +0,0 @@
-import { type FileHandle } from "node:fs/promises";
-import { type CreateDirectoryOptions, type CreationAdmission } from "./create-directory.js";
-import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
-export type CreateFileOptions = CreateDirectoryOptions;
-export declare function createFileSync(targetPath: string, options?: CreateFileOptions): OwnedFileDescriptorSync;
-/** Internal async writer; Windows preparation uses the nonblocking stage owner. */
-export declare function createFileHandle(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): Promise<FileHandle>;
-//# sourceMappingURL=create-file.d.ts.map

package/dist/create-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-file.d.ts","sourceRoot":"","sources":["../src/create-file.ts"],"names":[],"mappings":"AAEA,OAAgB,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,EAAkC,KAAK,sBAAsB,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC5H,OAAO,EAAyB,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AA2B7F,MAAM,MAAM,iBAAiB,GAAG,sBAAsB,CAAC;AA8GvD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,uBAAuB,CAE3G;AAED,mFAAmF;AACnF,wBAAsB,gBAAgB,CACpC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,iBAAsB,EAC/B,SAAS,GAAE,iBAAsB,GAChC,OAAO,CAAC,UAAU,CAAC,CA+BrB"}

package/dist/create-file.js

@@ -1,190 +0,0 @@
-import { randomUUID } from "node:crypto";
-import fs, {} from "node:fs";
-import fsAsync, {} from "node:fs/promises";
-import path from "node:path";
-import { createDirectoryWithReceiptSync } from "./create-directory.js";
-import { ownFileDescriptorSync } from "./create-owned-file.js";
-import { assertDirectoryIdentitySync } from "./directory-guard.js";
-import { FsSafeError } from "./errors.js";
-import { assertSynchronousCallbackResult } from "./mutation-authority.js";
-import { assertPrivateFileCreationAvailable, inspectCreationDirectorySync, protectCreatedFileSync, resolveCreationPermissions, verifyCreatedFileSync, } from "./creation-permissions.js";
-import { creationCollision, prepareCreationPath, removeCreationDirectory } from "./creation-path.js";
-import { handoffCreatedFileSync } from "./private-producer-handoff-sync.js";
-import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { assertCreationFile, assertPrivateCreationFile, creationPublicationAfterFailure, privateFileSettlementFailure, rethrowPrivateStageCreationFailure, removeRecordedCreationFileSync, } from "./creation-file-state.js";
-import { createPrivateWindowsFileHandle } from "./create-file-async.js";
-import { assertDarwinCreationDirectoryAcl } from "./creation-darwin.js";
-function createPrivateWindowsFile(selected, options, mode) {
-    const assertion = options.assertBeforeMutation;
-    if (fs.lstatSync(selected.target, { throwIfNoEntry: false })) {
-        throw new FsSafeError("already-exists", "creation target already exists");
-    }
-    const parentIdentity = inspectCreationDirectorySync(selected.parent.dir, false);
-    selected.assertParent();
-    const stageDirectory = path.join(selected.parent.dir, `.fs-safe-create-${randomUUID()}`);
-    let stage;
-    try {
-        stage = createDirectoryWithReceiptSync(stageDirectory, { private: true, assertBeforeMutation: assertion }, {
-            expectedParentIdentity: selected.parent.stat,
-        });
-    }
-    catch (error) {
-        rethrowPrivateStageCreationFailure(error, selected.target, stageDirectory);
-    }
-    const stageIdentity = stage.windowsIdentity;
-    const stagePath = path.join(stageDirectory, "file");
-    const assertStage = () => {
-        selected.assertParent();
-        assertDirectoryIdentitySync(stageDirectory, stage.stat);
-    };
-    let file;
-    let identity;
-    let windowsIdentity;
-    let publication = "not-published";
-    try {
-        if (inspectCreationDirectorySync(stageDirectory, true) !== stageIdentity) {
-            throw new FsSafeError("path-mismatch", "private staging directory changed before file creation");
-        }
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        assertStage();
-        file = ownFileDescriptorSync(fs.openSync(stagePath, fs.constants.O_RDWR | fs.constants.O_CREAT |
-            fs.constants.O_EXCL | resolveReadOpenFlags(), 0o600));
-        identity = assertCreationFile(file.fd, stagePath);
-        // The inherited ACL must already be restrictive. This freezes that policy;
-        // the bridge refuses to repair broad access on an exposed file.
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        assertStage();
-        assertCreationFile(file.fd, stagePath, identity);
-        windowsIdentity = protectCreatedFileSync(file.fd, stagePath, stageIdentity);
-        assertStage();
-        file = handoffCreatedFileSync({
-            source: file, sourcePath: stagePath, targetPath: selected.target, identity,
-            assertSourceParent: assertStage, assertTargetParent: selected.assertParent,
-            assertBeforeMutation: assertion,
-            verifyDescriptor: (fd, pathname, links) => verifyCreatedFileSync(fd, pathname, windowsIdentity, pathname === stagePath ? stageIdentity : parentIdentity, links),
-            onPublished: () => { publication = "published"; },
-        });
-        // Windows may clear the read-only attribute while retiring the stage name.
-        // Finalize it only after the published-name descriptor owns the file.
-        fs.fchmodSync(file.fd, mode);
-        selected.assertParent();
-        identity = assertCreationFile(file.fd, selected.target, identity);
-        verifyCreatedFileSync(file.fd, selected.target, windowsIdentity, parentIdentity);
-        removeCreationDirectory(stageDirectory, stage.stat, selected.assertParent);
-        return file;
-    }
-    catch (primary) {
-        publication = creationPublicationAfterFailure(primary, publication);
-        const cleanup = [];
-        if (file) {
-            try {
-                file.close();
-            }
-            catch (error) {
-                cleanup.push(error);
-            }
-        }
-        if (publication !== "indeterminate") {
-            if (identity) {
-                try {
-                    removeRecordedCreationFileSync(stagePath, identity, assertStage);
-                }
-                catch (error) {
-                    cleanup.push(error);
-                }
-            }
-            try {
-                removeCreationDirectory(stageDirectory, stage.stat, selected.assertParent);
-            }
-            catch (error) {
-                cleanup.push(error);
-            }
-        }
-        if (publication === "not-published" && cleanup.length === 0)
-            throw creationCollision(primary);
-        throw privateFileSettlementFailure({ primary, cleanup, publication, path: selected.target, stageDirectory });
-    }
-}
-function createFileCore(targetPath, options, admission) {
-    const permissions = resolveCreationPermissions(options, false);
-    const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
-    if (permissions.private && process.platform === "win32") {
-        assertPrivateFileCreationAvailable();
-        return createPrivateWindowsFile(selected, { ...permissions, assertBeforeMutation: assertion }, permissions.mode);
-    }
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "file");
-    assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-    selected.assertParent();
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "file");
-    let file;
-    try {
-        file = ownFileDescriptorSync(fs.openSync(selected.target, fs.constants.O_RDWR | fs.constants.O_CREAT |
-            fs.constants.O_EXCL | resolveReadOpenFlags(), permissions.mode ?? 0o666));
-    }
-    catch (error) {
-        throw creationCollision(error);
-    }
-    try {
-        const identity = assertCreationFile(file.fd, selected.target);
-        selected.assertParent();
-        if (permissions.private)
-            assertPrivateCreationFile(identity, file.fd);
-        return file;
-    }
-    catch (primary) {
-        let failure = primary;
-        try {
-            file.close();
-        }
-        catch (closeError) {
-            failure = new AggregateError([primary, closeError], "created file admission and close failed");
-        }
-        throw new FsSafeError("helper-failed", "created file admission failed", {
-            cause: failure, details: { publication: { status: "published" }, path: selected.target, cleanup: "preserved" },
-        });
-    }
-}
-export function createFileSync(targetPath, options = {}) {
-    return createFileCore(targetPath, options, {});
-}
-/** Internal async writer; Windows preparation uses the nonblocking stage owner. */
-export async function createFileHandle(targetPath, options = {}, admission = {}) {
-    const permissions = resolveCreationPermissions(options, false);
-    const assertion = options.assertBeforeMutation;
-    if (process.platform !== "win32" || !permissions.private) {
-        const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
-        if (permissions.private)
-            assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "file");
-        assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-        selected.assertParent();
-        if (permissions.private)
-            assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "file");
-        const handle = await fsAsync.open(selected.target, fs.constants.O_RDWR | fs.constants.O_CREAT |
-            fs.constants.O_EXCL | resolveReadOpenFlags(), permissions.mode ?? 0o666)
-            .catch(error => { throw creationCollision(error); });
-        try {
-            const identity = assertCreationFile(handle.fd, selected.target);
-            selected.assertParent();
-            if (permissions.private)
-                assertPrivateCreationFile(identity, handle.fd);
-            return handle;
-        }
-        catch (primary) {
-            let failure = primary;
-            try {
-                await handle.close();
-            }
-            catch (closeError) {
-                failure = new AggregateError([primary, closeError], "created file admission and close failed");
-            }
-            throw new FsSafeError("helper-failed", "created file handle admission failed", {
-                cause: failure, details: { publication: { status: "published" }, path: selected.target, cleanup: "preserved" },
-            });
-        }
-    }
-    assertPrivateFileCreationAvailable();
-    return await createPrivateWindowsFileHandle(prepareCreationPath(targetPath, admission.expectedParentIdentity), { mode: permissions.mode, assertBeforeMutation: assertion });
-}

package/dist/create-owned-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-owned-file.d.ts","sourceRoot":"","sources":["../src/create-owned-file.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,KAAK,IAAI,IAAI,CAAC;IACd,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC;CAC1B,CAAC;AAEF,6EAA6E;AAC7E,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAmB,GAC3C,uBAAuB,CAYzB"}

package/dist/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../src/create.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAAE,mBAAmB,EACpC,4BAA4B,EAAE,gCAAgC,EAC9D,KAAK,sBAAsB,EAAE,KAAK,iBAAiB,GACpD,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC5F,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/creation-darwin.d.ts

@@ -1,6 +0,0 @@
-import { type BigIntStats } from "node:fs";
-export declare function assertDarwinPrivateCreationAvailable(): void;
-export declare function assertDarwinPrivateDirectoryMode(mode: number): void;
-export declare function assertDarwinCreationAcl(fd: number, inheritanceTarget?: "file" | "directory"): void;
-export declare function assertDarwinCreationDirectoryAcl(pathname: string, expected: BigIntStats, inheritanceTarget?: "file" | "directory"): void;
-//# sourceMappingURL=creation-darwin.d.ts.map

package/dist/creation-darwin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"creation-darwin.d.ts","sourceRoot":"","sources":["../src/creation-darwin.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAe/C,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAInE;AAED,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAYlG;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAChF,IAAI,CAqBN"}

package/dist/creation-darwin.js

@@ -1,70 +0,0 @@
-import fs, {} from "node:fs";
-import { inspectDirectoryIdentitySync } from "./directory-guard.js";
-import { nodeDarwinDirectoryMetadataFlags, nodeDirectorySearchOnlyFlags } from "./directory-mode-node.js";
-import { FsSafeError } from "./errors.js";
-import { getNativeBinding } from "./native.js";
-import { inspectFileIdentitySync } from "./strict-file-identity.js";
-function inspector() {
-    const native = getNativeBinding();
-    if (typeof native?.inspectDarwinAcl !== "function") {
-        throw new FsSafeError("helper-unavailable", "private Darwin creation requires native descriptor ACL inspection");
-    }
-    return native.inspectDarwinAcl.bind(native);
-}
-export function assertDarwinPrivateCreationAvailable() {
-    if (process.platform === "darwin")
-        inspector();
-}
-export function assertDarwinPrivateDirectoryMode(mode) {
-    if (process.platform === "darwin" && ((mode & ~process.umask()) & 0o500) === 0) {
-        throw new FsSafeError("helper-unavailable", "private Darwin directory ACL inspection requires owner read or search permission");
-    }
-}
-export function assertDarwinCreationAcl(fd, inheritanceTarget) {
-    if (process.platform !== "darwin")
-        return;
-    const inspect = inspector();
-    const state = inspect(fd, inheritanceTarget)?.state;
-    if (state === "present") {
-        throw new FsSafeError("insecure-permissions", inheritanceTarget
-            ? "private creation parent has inheritable Darwin ACL entries"
-            : "private creation object has Darwin ACL entries");
-    }
-    if (state !== "absent" && state !== "empty") {
-        throw new FsSafeError("helper-unavailable", "native Darwin ACL inspection returned incomplete facts");
-    }
-}
-export function assertDarwinCreationDirectoryAcl(pathname, expected, inheritanceTarget) {
-    if (process.platform !== "darwin")
-        return;
-    assertDarwinPrivateCreationAvailable();
-    let fd;
-    try {
-        fd = fs.openSync(pathname, nodeDarwinDirectoryMetadataFlags());
-    }
-    catch (error) {
-        if (error.code !== "EACCES")
-            throw error;
-        const search = nodeDirectorySearchOnlyFlags();
-        if (!search)
-            throw error;
-        try {
-            fd = fs.openSync(pathname, search.flags | fs.constants.O_DIRECTORY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
-        }
-        catch (cause) {
-            if (cause.code !== "EACCES")
-                throw cause;
-            throw new FsSafeError("helper-unavailable", "private Darwin directory ACL inspection requires owner read or search permission", { cause });
-        }
-    }
-    try {
-        const opened = inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }), expected);
-        if (!opened.isDirectory())
-            throw new FsSafeError("path-mismatch", "ACL target is not the admitted directory");
-        assertDarwinCreationAcl(fd, inheritanceTarget);
-        inspectDirectoryIdentitySync(pathname, expected);
-    }
-    finally {
-        fs.closeSync(fd);
-    }
-}

package/dist/creation-file-state.d.ts

@@ -1,19 +0,0 @@
-import { type BigIntStats } from "node:fs";
-import { FsSafeError } from "./errors.js";
-export type CreationPublicationStatus = "not-published" | "published" | "indeterminate";
-export declare function assertCreationFile(fd: number, pathname: string, expected?: BigIntStats): BigIntStats;
-export declare function assertPrivateCreationFile(stat: BigIntStats, fd: number): void;
-export declare function removeRecordedCreationFileSync(pathname: string, identity: BigIntStats, assertParent: () => void): void;
-export declare function removeRecordedCreationFile(pathname: string, identity: BigIntStats, assertParent: () => void): Promise<void>;
-export declare function creationPublicationAfterFailure(error: unknown, recorded: CreationPublicationStatus): CreationPublicationStatus;
-export declare function hasPreservedCreationArtifacts(error: unknown): boolean;
-export declare function rethrowPrivateStageCreationFailure(error: unknown, path: string, stageDirectory: string): never;
-export declare function privateFileSettlementFailure(params: {
-    primary: unknown;
-    cleanup: readonly unknown[];
-    publication: CreationPublicationStatus;
-    path: string;
-    stageDirectory: string;
-    preserved?: boolean;
-}): FsSafeError;
-//# sourceMappingURL=creation-file-state.d.ts.map

package/dist/creation-file-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"creation-file-state.d.ts","sourceRoot":"","sources":["../src/creation-file-state.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM1C,MAAM,MAAM,yBAAyB,GAAG,eAAe,GAAG,WAAW,GAAG,eAAe,CAAC;AAExF,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,WAAW,CAOpG;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAS7E;AAQD,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAAG,IAAI,CAUtH;AAED,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAChE,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,yBAAyB,GAClD,yBAAyB,CAO3B;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMrE;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,KAAK,CAuB9G;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACnD,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,WAAW,EAAE,yBAAyB,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,WAAW,CAUd"}

package/dist/creation-file-state.js

@@ -1,118 +0,0 @@
-import fs, {} from "node:fs";
-import fsAsync from "node:fs/promises";
-import { FsSafeError } from "./errors.js";
-import { sameFileIdentityForCleanup } from "./file-identity.js";
-import { inspectFileIdentitySync } from "./strict-file-identity.js";
-import { hasUnsettledWindowsSecurityCommand } from "./windows-security-command.js";
-import { assertDarwinCreationAcl } from "./creation-darwin.js";
-export function assertCreationFile(fd, pathname, expected) {
-    const opened = inspectFileIdentitySync(() => fs.fstatSync(fd, { bigint: true }), expected);
-    const named = inspectFileIdentitySync(() => fs.lstatSync(pathname, { bigint: true }), opened);
-    if (!opened.isFile() || !named.isFile() || named.isSymbolicLink() || opened.nlink !== 1n || named.nlink !== 1n) {
-        throw new FsSafeError("path-mismatch", "created file is not the expected single-linked regular file");
-    }
-    return opened;
-}
-export function assertPrivateCreationFile(stat, fd) {
-    if (process.platform === "win32")
-        return;
-    if (typeof process.getuid !== "function" || stat.uid !== BigInt(process.getuid())) {
-        throw new FsSafeError("not-owned", "created private file must belong to the current user");
-    }
-    if ((stat.mode & 3647n) !== 0n) {
-        throw new FsSafeError("insecure-permissions", "created private file is not owner-only");
-    }
-    assertDarwinCreationAcl(fd);
-}
-function assertRecordedFile(current, identity) {
-    if (!current.isFile() || current.isSymbolicLink() || !sameFileIdentityForCleanup(current, identity)) {
-        throw new FsSafeError("path-mismatch", "created file cleanup preserved a replacement");
-    }
-}
-export function removeRecordedCreationFileSync(pathname, identity, assertParent) {
-    assertParent();
-    let current;
-    try {
-        current = fs.lstatSync(pathname, { bigint: true });
-    }
-    catch (error) {
-        if (error?.code === "ENOENT")
-            return;
-        throw error;
-    }
-    assertRecordedFile(current, identity);
-    fs.unlinkSync(pathname);
-}
-export async function removeRecordedCreationFile(pathname, identity, assertParent) {
-    assertParent();
-    let current;
-    try {
-        current = await fsAsync.lstat(pathname, { bigint: true });
-    }
-    catch (error) {
-        if (error?.code === "ENOENT")
-            return;
-        throw error;
-    }
-    assertParent();
-    assertRecordedFile(current, identity);
-    // Recheck after the awaited observation before dispatching the unlink.
-    assertRecordedFile(fs.lstatSync(pathname, { bigint: true }), identity);
-    await fsAsync.unlink(pathname);
-}
-export function creationPublicationAfterFailure(error, recorded) {
-    if (error instanceof FsSafeError) {
-        const publication = error.details?.publication;
-        if (publication && typeof publication === "object" && "status" in publication &&
-            publication.status === "indeterminate")
-            return "indeterminate";
-    }
-    return recorded;
-}
-export function hasPreservedCreationArtifacts(error) {
-    if (!(error instanceof FsSafeError))
-        return false;
-    if (error.details?.cleanup === "preserved" || error.details?.cleanup === "failed")
-        return true;
-    const publication = error.details?.publication;
-    return publication !== null && typeof publication === "object" && "status" in publication &&
-        (publication.status === "published" || publication.status === "indeterminate");
-}
-export function rethrowPrivateStageCreationFailure(error, path, stageDirectory) {
-    if (error instanceof FsSafeError && error.code === "already-exists") {
-        throw new FsSafeError("helper-failed", "private file staging path already exists", {
-            cause: error, details: { publication: { status: "not-published" }, path, stageDirectory },
-        });
-    }
-    const publication = error instanceof FsSafeError ? error.details?.publication : undefined;
-    const created = error instanceof FsSafeError && error.details?.path === stageDirectory &&
-        publication !== null && typeof publication === "object" && "status" in publication &&
-        publication.status === "published";
-    let unconfirmed = hasUnsettledWindowsSecurityCommand(error);
-    if (error !== null && (typeof error === "object" || typeof error === "function")) {
-        try {
-            const outcome = Object.getOwnPropertyDescriptor(error, "creationOutcome");
-            unconfirmed ||= Boolean(outcome && "value" in outcome && outcome.value === "unconfirmed");
-        }
-        catch {
-            unconfirmed = true;
-        }
-    }
-    if (created || unconfirmed) {
-        throw privateFileSettlementFailure({
-            primary: error, cleanup: [], publication: "not-published", path, stageDirectory, preserved: true,
-        });
-    }
-    throw error;
-}
-export function privateFileSettlementFailure(params) {
-    return new FsSafeError("helper-failed", "file creation or staging settlement failed", {
-        cause: params.cleanup.length
-            ? new AggregateError([params.primary, ...params.cleanup], "file creation and cleanup failed")
-            : params.primary,
-        details: {
-            publication: { status: params.publication }, path: params.path, stageDirectory: params.stageDirectory,
-            cleanup: params.preserved || params.publication === "indeterminate" ? "preserved" : params.cleanup.length ? "failed" : "removed",
-        },
-    });
-}

package/dist/creation-path.d.ts

@@ -1,21 +0,0 @@
-import { type BigIntStats } from "node:fs";
-import { type AsyncDirectoryGuard, type AnyAsyncDirectoryGuard } from "./directory-guard.js";
-export type CreationParentIdentity = Readonly<{
-    dev: bigint;
-    ino: bigint;
-    realPath?: string;
-}>;
-export type CreationPath = {
-    target: string;
-    parent: AsyncDirectoryGuard<BigIntStats>;
-    assertParent(): void;
-};
-export declare function creationAdmissionFromParent(parent: AnyAsyncDirectoryGuard): {
-    expectedParentIdentity: CreationParentIdentity;
-};
-export declare function prepareCreationPath(input: string, expectedParent?: CreationParentIdentity): CreationPath;
-export declare function creationCollision(error: unknown): unknown;
-/** Remove only the recorded empty stage; never traverse a replaced directory. */
-export declare function removeCreationDirectory(directory: string, identity: BigIntStats, assertParent: () => void): void;
-export declare function removeCreationDirectoryAsync(directory: string, identity: BigIntStats, assertParent: () => void): Promise<void>;
-//# sourceMappingURL=creation-path.d.ts.map

package/dist/creation-path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"creation-path.d.ts","sourceRoot":"","sources":["../src/creation-path.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAM9B,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACzC,YAAY,IAAI,IAAI,CAAC;CACtB,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,sBAAsB,GAAG;IAAE,sBAAsB,EAAE,sBAAsB,CAAA;CAAE,CAO9H;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,sBAAsB,GAAG,YAAY,CAuBxG;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKzD;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GAAG,IAAI,CAQhH;AAED,wBAAsB,4BAA4B,CAChD,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,IAAI,GACjE,OAAO,CAAC,IAAI,CAAC,CAQf"}