@openclaw/fs-safe 0.18.0 → 0.18.2

package/dist/archive-policy.js

@@ -1,38 +0,0 @@
-import { ArchiveSecurityError } from "./archive-errors.js";
-import { formatErrorDetail } from "./error-detail.js";
-export function archiveEntryKindFromTarType(type) {
-    if (type === "Directory" || type === "GNUDumpDir")
-        return "directory";
-    if (type === "File" || type === "OldFile" || type === "ContiguousFile")
-        return "file";
-    if (type === "SymbolicLink" || type === "Link")
-        return "symlink";
-    return "other";
-}
-export function resolveArchiveEntryMode(params) {
-    const archivedMode = (params.archivedMode ?? 0) & 0o777;
-    if (params.policy === "preserve") {
-        return params.archivedMode == null ? (params.kind === "directory" ? 0o755 : 0o644) : archivedMode;
-    }
-    if (params.kind === "directory") {
-        return 0o755;
-    }
-    return archivedMode & 0o100 ? 0o755 : 0o644;
-}
-export function resolveArchiveFilteredEntryPolicy(value) {
-    if (value === undefined || value === "reject-archive")
-        return "reject-archive";
-    if (value === "skip-entry")
-        return "skip-entry";
-    throw new RangeError('archive onFiltered must be "reject-archive" or "skip-entry"');
-}
-export function shouldExtractArchiveEntry(params) {
-    const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
-    if (!params.filter || params.filter(params.entry) === "extract") {
-        return true;
-    }
-    if (onFiltered === "reject-archive") {
-        throw new ArchiveSecurityError("entry-filtered", `archive entry rejected by filter: ${formatErrorDetail(params.entry.path)}`);
-    }
-    return false;
-}

package/dist/archive-tar-inspect.d.ts

@@ -1,6 +0,0 @@
-import type { ExtractArchiveOptions } from "./archive-options.js";
-import { type ArchivePlanEntry } from "./archive-plan.js";
-export type InspectTarArchiveOptions = Pick<ExtractArchiveOptions, "archivePath" | "timeoutMs" | "limits" | "entryFilter" | "onFiltered">;
-export type InspectedTarEntry = Readonly<Pick<ArchivePlanEntry, "path" | "kind" | "size">>;
-/** Complete TAR/gzip admission and zero-strip extraction policy, without output writes. */
-export declare function inspectTarArchive(params: InspectTarArchiveOptions): Promise<readonly InspectedTarEntry[]>;

package/dist/archive-tar-inspect.js

@@ -1,62 +0,0 @@
-import { withExtractionDeadline } from "./archive-deadline.js";
-import { validateArchiveEntryPath } from "./archive-entry.js";
-import { stageArchiveFileForExtraction } from "./archive-input.js";
-import { resolveExtractLimits, resolveTarMeterLimits } from "./archive-limits.js";
-import { throwMappedNativeArchiveError } from "./archive-native.js";
-import { createArchiveEntryPlanner } from "./archive-plan.js";
-import { resolveArchiveFilteredEntryPolicy } from "./archive-policy.js";
-import { createTarEntryPlanner } from "./archive-tar.js";
-import { inspectTar } from "./archive-tar-stream.js";
-import { getNativeBinding } from "./native.js";
-import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
-/** Complete TAR/gzip admission and zero-strip extraction policy, without output writes. */
-export async function inspectTarArchive(params) {
-    const archivePath = params.archivePath;
-    const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
-    const limits = resolveExtractLimits(params.limits);
-    const tarLimits = resolveTarMeterLimits(limits);
-    const native = getNativeBinding();
-    assertNoWindowsPathAlias(archivePath, "filesystem", "archive source uses a Windows filesystem namespace alias");
-    return await withExtractionDeadline(params.timeoutMs, "inspect tar", async (deadline) => {
-        const staged = await stageArchiveFileForExtraction({ archivePath, limits, deadline });
-        try {
-            // Staging closes descriptors asynchronously; expiry there must not start a decoder.
-            deadline.check();
-            const entries = [];
-            const append = (entry) => {
-                if (entry)
-                    entries.push(Object.freeze({ path: entry.path, kind: entry.kind, size: entry.size }));
-            };
-            const policy = { limits, entryFilter: params.entryFilter, onFiltered };
-            if (native) {
-                const manifest = await native.inspectArchiveNative(staged.path, "tar", tarLimits, deadline.signal)
-                    .catch(throwMappedNativeArchiveError);
-                deadline.check();
-                // Match extraction's whole-manifest validation before caller policy runs.
-                for (const entry of manifest)
-                    validateArchiveEntryPath(entry.path);
-                const planEntry = createArchiveEntryPlanner(policy, "tar");
-                for (const entry of manifest) {
-                    deadline.check();
-                    append(planEntry(entry));
-                }
-            }
-            else {
-                const manifest = [];
-                await inspectTar({ archivePath: staged.path, limits: tarLimits, signal: deadline.signal,
-                    onMember: (entry) => { manifest.push(entry); } });
-                const planEntry = createTarEntryPlanner(policy);
-                for (const entry of manifest) {
-                    deadline.check();
-                    append(planEntry(entry));
-                }
-            }
-            deadline.check();
-            // This is bounded evidence about the staged bytes, not a reusable write plan.
-            return Object.freeze(entries);
-        }
-        finally {
-            await staged.cleanup();
-        }
-    });
-}

package/dist/archive-tar.d.ts

@@ -1,18 +0,0 @@
-import type { ArchiveExtractLimits } from "./archive-limits.js";
-import { type ArchivePlanEntry, type ArchivePlanOptions } from "./archive-plan.js";
-import { type ArchiveEntryFilter, type ArchiveFilteredEntryPolicy } from "./archive-policy.js";
-export type TarEntryInfo = {
-    path: string;
-    type: string;
-    size: number;
-    mode?: number;
-};
-export declare function createTarEntryPlanner(params: ArchivePlanOptions): (entry: TarEntryInfo) => ArchivePlanEntry | null;
-export declare function createTarEntryPreflightChecker(params: {
-    rootDir: string;
-    stripComponents?: number;
-    limits?: ArchiveExtractLimits;
-    escapeLabel?: string;
-    entryFilter?: ArchiveEntryFilter;
-    onFiltered?: ArchiveFilteredEntryPolicy;
-}): (entry: TarEntryInfo) => boolean;

package/dist/archive-tar.js

@@ -1,21 +0,0 @@
-import { createArchiveEntryPlanner, } from "./archive-plan.js";
-import { archiveEntryKindFromTarType, } from "./archive-policy.js";
-const BLOCKED_TAR_ENTRY_TYPES = new Set([
-    "BlockDevice",
-    "CharacterDevice",
-    "FIFO",
-    "Socket",
-]);
-export function createTarEntryPlanner(params) {
-    // Preserve inherited/getter-backed public options and per-entry policy reads.
-    const plan = createArchiveEntryPlanner(params, "tar");
-    return (entry) => {
-        const kind = BLOCKED_TAR_ENTRY_TYPES.has(entry.type) ? "blocked" : archiveEntryKindFromTarType(entry.type);
-        // The public checker accepts structural entry objects, including class getters.
-        return plan({ path: entry.path, kind, size: entry.size, mode: entry.mode });
-    };
-}
-export function createTarEntryPreflightChecker(params) {
-    const plan = createTarEntryPlanner(params);
-    return (entry) => plan(entry) !== null;
-}

package/dist/create-directory.d.ts

@@ -1,18 +0,0 @@
-import { type BigIntStats } from "node:fs";
-import { type CreationPermissions } from "./creation-permissions.js";
-import { type CreationParentIdentity } from "./creation-path.js";
-export type CreateDirectoryOptions = CreationPermissions & {
-    assertBeforeMutation?: () => void;
-};
-export type CreationAdmission = {
-    expectedParentIdentity?: CreationParentIdentity;
-};
-export type CreationDirectoryReceipt = {
-    stat: BigIntStats;
-    windowsIdentity?: string;
-};
-export declare function createDirectory(targetPath: string, options?: CreateDirectoryOptions): Promise<void>;
-export declare function createDirectoryWithAdmission(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): Promise<void>;
-export declare function createDirectoryWithReceipt(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): Promise<CreationDirectoryReceipt>;
-export declare function createDirectorySync(targetPath: string, options?: CreateDirectoryOptions): void;
-export declare function createDirectoryWithReceiptSync(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): CreationDirectoryReceipt;

package/dist/create-directory.js

@@ -1,111 +0,0 @@
-import fsSync, {} from "node:fs";
-import fs from "node:fs/promises";
-import { FsSafeError } from "./errors.js";
-import { getNativeBinding } from "./native.js";
-import { getFsSafeNativeConfig } from "./native-config.js";
-import { assertPrivateDirectory, assertPrivateDirectorySync, inspectCreationDirectory, inspectCreationDirectorySync, resolveCreationPermissions, } from "./creation-permissions.js";
-import { assertBeforeCreation, creationCollision, prepareCreationPath } from "./creation-path.js";
-import { createPrivateWindowsDirectoryCommand, createPrivateWindowsDirectoryCommandSync, } from "./windows-security-command.js";
-import { warnNativeFallback } from "./native-fallback-warning.js";
-import { inspectDirectoryIdentitySync } from "./directory-guard.js";
-function directoryAdoptionFailure(error, target, windowsIdentity) {
-    return new FsSafeError("helper-failed", "created directory admission failed", {
-        cause: error,
-        details: {
-            publication: { status: "published" }, path: target, cleanup: "preserved",
-            ...(windowsIdentity === undefined ? {} : { windowsIdentity }),
-        },
-    });
-}
-function privateDirectoryBackend() {
-    const binding = getNativeBinding();
-    if (typeof binding?.createPrivateDirectoryWithParentIdentity === "function") {
-        return binding.createPrivateDirectoryWithParentIdentity.bind(binding);
-    }
-    if (getFsSafeNativeConfig().mode === "require") {
-        throw new FsSafeError("helper-unavailable", "private directory creation requires an up-to-date native parent identity capability");
-    }
-    warnNativeFallback("windows-private-directory", "Private Windows directory creation uses a slower built-in system command.");
-    return undefined;
-}
-export async function createDirectory(targetPath, options = {}) {
-    await createDirectoryWithAdmission(targetPath, options, {});
-}
-export async function createDirectoryWithAdmission(targetPath, options = {}, admission = {}) {
-    await createDirectoryWithReceipt(targetPath, options, admission);
-}
-export async function createDirectoryWithReceipt(targetPath, options = {}, admission = {}) {
-    const permissions = resolveCreationPermissions(options, true);
-    const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
-    const backend = permissions.private && process.platform === "win32" ? privateDirectoryBackend() : undefined;
-    const parentIdentity = permissions.private && process.platform === "win32"
-        ? await inspectCreationDirectory(selected.parent.dir, false) : undefined;
-    assertBeforeCreation(selected, permissions, assertion, "directory");
-    let created = false;
-    let windowsIdentity;
-    try {
-        if (parentIdentity !== undefined) {
-            const receipt = backend
-                ? backend(selected.target, parentIdentity)
-                : await createPrivateWindowsDirectoryCommand(selected.target, parentIdentity);
-            created = true;
-            windowsIdentity = receipt.identity;
-            if ((await inspectCreationDirectory(selected.target, true)) !== receipt.identity) {
-                throw new FsSafeError("path-mismatch", "created private directory changed before adoption");
-            }
-        }
-        else {
-            await fs.mkdir(selected.target, { mode: permissions.mode });
-            created = true;
-            if (permissions.private)
-                await assertPrivateDirectory(selected.target);
-        }
-        selected.assertParent();
-        return { stat: inspectDirectoryIdentitySync(selected.target), windowsIdentity };
-    }
-    catch (error) {
-        if (created)
-            throw directoryAdoptionFailure(error, selected.target, windowsIdentity);
-        throw creationCollision(error);
-    }
-}
-export function createDirectorySync(targetPath, options = {}) {
-    createDirectoryWithReceiptSync(targetPath, options, {});
-}
-export function createDirectoryWithReceiptSync(targetPath, options = {}, admission = {}) {
-    const permissions = resolveCreationPermissions(options, true);
-    const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
-    const backend = permissions.private && process.platform === "win32" ? privateDirectoryBackend() : undefined;
-    const parentIdentity = permissions.private && process.platform === "win32"
-        ? inspectCreationDirectorySync(selected.parent.dir, false) : undefined;
-    assertBeforeCreation(selected, permissions, assertion, "directory");
-    let created = false;
-    let windowsIdentity;
-    try {
-        if (parentIdentity !== undefined) {
-            const receipt = backend
-                ? backend(selected.target, parentIdentity)
-                : createPrivateWindowsDirectoryCommandSync(selected.target, parentIdentity);
-            created = true;
-            windowsIdentity = receipt.identity;
-            if (inspectCreationDirectorySync(selected.target, true) !== receipt.identity) {
-                throw new FsSafeError("path-mismatch", "created private directory changed before adoption");
-            }
-        }
-        else {
-            fsSync.mkdirSync(selected.target, { mode: permissions.mode });
-            created = true;
-            if (permissions.private)
-                assertPrivateDirectorySync(selected.target);
-        }
-        selected.assertParent();
-        return { stat: inspectDirectoryIdentitySync(selected.target), windowsIdentity };
-    }
-    catch (error) {
-        if (created)
-            throw directoryAdoptionFailure(error, selected.target, windowsIdentity);
-        throw creationCollision(error);
-    }
-}

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

@@ -1,6 +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>;

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,7 +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>;

package/dist/create-file.js

@@ -1,179 +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 { assertBeforeCreation, 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";
-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);
-    }
-    assertBeforeCreation(selected, permissions, assertion, "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);
-        assertBeforeCreation(selected, permissions, assertion, "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/creation-darwin.d.ts

@@ -1,5 +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;