@openclaw/fs-safe 0.17.0 → 0.18.0

package/dist/archive.js

@@ -6,25 +6,23 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createArchiveOutputPathTracker, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
+import { createArchiveEntrySelector } from "./archive-plan.js";
 import { createPipelineTimeoutError, waitForDeadline, withExtractionDeadline, } from "./archive-deadline.js";
-import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
+import { assertArchiveEntryCountWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
 import { resolveArchiveKind } from "./archive-kind.js";
-import { prepareArchiveDestinationGuard, preparePrivateArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
-import { mergePlannedArchiveIntoDestination } from "./archive-merge.js";
+import { prepareArchiveDestinationGuard, preparePrivateArchiveOutputPath, } from "./archive-staging.js";
+import { withStagedArchivePublication } from "./archive-merge.js";
 import { loadZipArchiveWithPreflight } from "./archive-zip-preflight.js";
 import { admittedZipEntries } from "./archive-zip-loader.js";
 import { zipEntryKind, zipEntryDeclaredSize, zipEntryMode, } from "./archive-zip-entry.js";
 import { createZipIntegrityTransform, normalizeZipIntegrityError, } from "./archive-zip-integrity.js";
-import { FsSafeError } from "./errors.js";
 import { ArchiveSecurityError } from "./archive-errors.js";
 import { extractNativeArchive } from "./archive-native.js";
 import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { getNativeBinding } from "./native.js";
-import { resolveArchiveFilteredEntryPolicy, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { resolveArchiveFilteredEntryPolicy } from "./archive-policy.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
-import { realpathSync } from "./realpath.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
 export { readArchiveEntry } from "./archive-read.js";
@@ -48,26 +46,6 @@ async function readZipEntryStream(entry) {
     const buf = await entry.async("nodebuffer");
     return Readable.from(buf);
 }
-function resolveZipOutputPath(params) {
-    validateArchiveEntryPath(params.entryPath);
-    const canonicalPath = stripArchivePath(params.entryPath, 0);
-    if (!canonicalPath)
-        return null;
-    const relPath = params.strip === 0 ? canonicalPath : stripArchivePath(canonicalPath, params.strip);
-    if (!relPath) {
-        return null;
-    }
-    validateArchiveEntryPath(relPath);
-    return {
-        canonicalPath,
-        relPath,
-        outPath: resolveArchiveOutputPath({
-            rootDir: params.destinationDir,
-            relPath,
-            originalPath: params.entryPath,
-        }),
-    };
-}
 async function writeZipFileEntry(params) {
     params.deadline.check();
     params.budget.startEntry();
@@ -118,93 +96,48 @@ async function writeZipFileEntry(params) {
     }
 }
 async function extractZip(params) {
-    const limits = resolveExtractLimits(params.limits);
-    const stagedArchive = await stageArchiveFileForExtraction({
-        archivePath: params.archivePath,
-        limits,
-        deadline: params.deadline,
+    const { limits, deadline } = params;
+    const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+    deadline.check();
+    const buffer = await fs.readFile(params.archivePath, { signal: deadline.signal });
+    deadline.check();
+    const zip = await waitForDeadline(loadZipArchiveWithPreflight(buffer, limits), deadline);
+    deadline.check();
+    const entries = admittedZipEntries(zip);
+    assertArchiveEntryCountWithinLimit(entries.length, limits);
+    const budget = createByteBudgetTracker(limits);
+    await withStagedArchivePublication({ ...params, destinationGuard }, async (stagingDir) => {
+        const { select } = createArchiveEntrySelector({ ...params, rootDir: stagingDir });
+        const acceptedEntries = [];
+        for (const entry of entries) {
+            deadline.check();
+            const entryKind = zipEntryKind(entry);
+            const relPath = select({ path: entry.name, kind: entryKind, size: zipEntryDeclaredSize(entry) });
+            if (relPath === null)
+                continue;
+            if (entryKind === "symlink") {
+                throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
+            }
+            if (entryKind === "other")
+                continue;
+            const mode = zipEntryMode(entry, params.entryModes);
+            acceptedEntries.push({ path: relPath, kind: entry.dir ? "directory" : "file", mode });
+            const outPath = path.join(stagingDir, relPath);
+            await preparePrivateArchiveOutputPath({
+                destinationDir: stagingDir,
+                destinationRealDir: stagingDir,
+                relPath,
+                outPath,
+                originalPath: entry.name,
+                isDirectory: entry.dir,
+                deadline,
+            });
+            if (!entry.dir) {
+                await writeZipFileEntry({ entry, outPath, budget, deadline });
+            }
+        }
+        return acceptedEntries;
     });
-    try {
-        const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
-        const destinationRealDir = destinationGuard.realPath;
-        params.deadline.check();
-        const buffer = await fs.readFile(stagedArchive.path, { signal: params.deadline.signal });
-        params.deadline.check();
-        const zip = await waitForDeadline(loadZipArchiveWithPreflight(buffer, limits), params.deadline);
-        params.deadline.check();
-        const entries = admittedZipEntries(zip);
-        const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
-        assertArchiveEntryCountWithinLimit(entries.length, limits);
-        const budget = createByteBudgetTracker(limits);
-        const trackOutputPath = createArchiveOutputPathTracker();
-        await withStagedArchiveDestination({
-            destinationRealDir,
-            run: async (stagingDir) => {
-                const stagingRealDir = realpathSync.native(stagingDir);
-                const acceptedEntries = [];
-                for (const entry of entries) {
-                    params.deadline.check();
-                    const output = resolveZipOutputPath({
-                        entryPath: entry.name,
-                        strip,
-                        destinationDir: stagingRealDir,
-                    });
-                    if (!output) {
-                        continue;
-                    }
-                    assertArchiveEntryPathComponentsWithinLimit(output.relPath, limits);
-                    trackOutputPath(output.relPath, entry.name);
-                    const entryKind = zipEntryKind(entry);
-                    const entrySize = zipEntryDeclaredSize(entry);
-                    if (!shouldExtractArchiveEntry({
-                        filter: params.entryFilter,
-                        onFiltered: params.onFiltered,
-                        entry: { path: output.canonicalPath, kind: entryKind, size: entrySize },
-                    })) {
-                        continue;
-                    }
-                    if (entryKind === "symlink") {
-                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
-                    }
-                    if (entryKind === "other")
-                        continue;
-                    const mode = zipEntryMode(entry, params.entryModes);
-                    acceptedEntries.push({ path: output.relPath, kind: entry.dir ? "directory" : "file", mode });
-                    await preparePrivateArchiveOutputPath({
-                        destinationDir: stagingRealDir,
-                        destinationRealDir: stagingRealDir,
-                        relPath: output.relPath,
-                        outPath: output.outPath,
-                        originalPath: entry.name,
-                        isDirectory: entry.dir,
-                        deadline: params.deadline,
-                    });
-                    if (entry.dir) {
-                        continue;
-                    }
-                    await writeZipFileEntry({
-                        entry,
-                        outPath: output.outPath,
-                        budget,
-                        deadline: params.deadline,
-                    });
-                }
-                params.deadline.check();
-                await mergePlannedArchiveIntoDestination({
-                    entries: acceptedEntries,
-                    durable: params.durable,
-                    entryUmask: params.entryUmask,
-                    sourceDir: stagingRealDir,
-                    destinationGuard,
-                    deadline: params.deadline,
-                });
-                params.deadline.check();
-            },
-        });
-    }
-    finally {
-        await stagedArchive.cleanup();
-    }
 }
 export async function extractArchive(params) {
     const archivePath = params.archivePath;
@@ -232,62 +165,52 @@ export async function extractArchive(params) {
         stripComponents: params.stripComponents, limits,
         entryModes: params.entryModes, entryUmask, entryFilter: params.entryFilter, onFiltered,
     };
-    if (native) {
-        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractNativeArchive({ ...options, binding: native, kind, tarLimits, deadline }));
-        return;
-    }
-    if (kind !== "zip") {
-        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
-            const stagedArchive = await stageArchiveFileForExtraction({
-                archivePath: options.archivePath,
-                limits,
-                deadline,
-            });
-            try {
-                await extractWasmTar({ archivePath: stagedArchive.path, kind, options, limits, tarLimits, deadline });
-            }
-            finally {
-                await stagedArchive.cleanup();
-            }
-        });
-        return;
-    }
-    await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractZip({ ...options, deadline }));
+    await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
+        const stagedArchive = await stageArchiveFileForExtraction({ archivePath, limits, deadline });
+        try {
+            deadline.check();
+            const stagedOptions = { ...options, archivePath: stagedArchive.path, deadline };
+            if (native)
+                await extractNativeArchive({ ...stagedOptions, binding: native, kind, tarLimits });
+            else if (kind === "zip")
+                await extractZip(stagedOptions);
+            else
+                await extractWasmTar({ ...stagedOptions, kind, tarLimits });
+        }
+        finally {
+            await stagedArchive.cleanup();
+        }
+    });
 }
 async function extractWasmTar(params) {
-    const { options, deadline, tarLimits } = params;
+    const { deadline, tarLimits } = params;
     const manifest = [];
     await inspectTar({ archivePath: params.archivePath, kind: params.kind, limits: tarLimits, signal: deadline.signal,
         onMember: (entry) => { manifest.push(entry); } });
     deadline.check();
-    const destinationGuard = await prepareArchiveDestinationGuard(options.destDir);
-    const destinationRealDir = destinationGuard.realPath;
-    await withStagedArchiveDestination({ destinationRealDir, run: async (stagingPath) => {
-            const stagingDir = realpathSync.native(stagingPath);
-            const planEntry = createTarEntryPlanner({ ...options, rootDir: destinationRealDir, limits: params.limits });
-            const accepted = manifest.flatMap((entry) => {
-                deadline.check();
-                const planned = planEntry(entry);
-                return planned ? [{ ...entry, ...planned }] : [];
-            });
-            await replayTar({ archivePath: params.archivePath, kind: params.kind, limits: tarLimits, signal: deadline.signal, members: accepted,
-                async consume(member, payload) {
-                    deadline.check();
-                    await preparePrivateArchiveOutputPath({ destinationDir: stagingDir, destinationRealDir: stagingDir,
-                        relPath: member.path, outPath: path.join(stagingDir, member.path), originalPath: member.path,
-                        isDirectory: member.kind === "directory", deadline });
-                    if (member.kind === "file") {
-                        await runPinnedWriteHelper({ rootPath: stagingDir, relativeParentPath: path.posix.dirname(member.path),
-                            basename: path.posix.basename(member.path), mkdir: false, mode: 0o600, overwrite: false,
-                            sync: false,
-                            maxBytes: member.size, input: { kind: "stream", stream: Readable.from(payload) } });
-                    }
-                    deadline.check();
-                },
-            });
+    const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+    await withStagedArchivePublication({ ...params, destinationGuard }, async (stagingDir) => {
+        const planEntry = createTarEntryPlanner({ ...params, rootDir: destinationGuard.realPath });
+        const accepted = manifest.flatMap((entry) => {
             deadline.check();
-            await mergePlannedArchiveIntoDestination({ entries: accepted, sourceDir: stagingDir, destinationGuard,
-                deadline, durable: options.durable, entryUmask: options.entryUmask });
-            deadline.check();
-        } });
+            const planned = planEntry(entry);
+            return planned ? [{ ...entry, ...planned }] : [];
+        });
+        await replayTar({ archivePath: params.archivePath, kind: params.kind, limits: tarLimits, signal: deadline.signal, members: accepted,
+            async consume(member, payload) {
+                deadline.check();
+                await preparePrivateArchiveOutputPath({ destinationDir: stagingDir, destinationRealDir: stagingDir,
+                    relPath: member.path, outPath: path.join(stagingDir, member.path), originalPath: member.path,
+                    isDirectory: member.kind === "directory", deadline });
+                if (member.kind === "file") {
+                    await runPinnedWriteHelper({ rootPath: stagingDir, relativeParentPath: path.posix.dirname(member.path),
+                        basename: path.posix.basename(member.path), mkdir: false, mode: 0o600, overwrite: false,
+                        sync: false,
+                        maxBytes: member.size, input: { kind: "stream", stream: Readable.from(payload) } });
+                }
+                deadline.check();
+            },
+        });
+        return accepted;
+    });
 }

package/dist/async-lock.d.ts

@@ -1,2 +1 @@
 export declare function createAsyncLock(): <T>(fn: () => Promise<T>) => Promise<T>;
-//# sourceMappingURL=async-lock.d.ts.map

package/dist/atomic.d.ts

@@ -2,4 +2,3 @@ export { replaceFileAtomic, replaceFileAtomicSync, type RenameIdentityPolicy, ty
 export { writeTextAtomic, type WriteTextAtomicOptions } from "./text-atomic.js";
 export { replaceDirectoryAtomic, type ReplaceDirectoryAtomicOptions } from "./replace-directory.js";
 export { movePathWithCopyFallback, type MovePathPublicationReceipt, type MovePathWithCopyFallbackOptions, } from "./move-path.js";
-//# sourceMappingURL=atomic.d.ts.map

package/dist/bounded-read-stream.d.ts

@@ -1,3 +1,2 @@
 import { Transform } from "node:stream";
 export declare function createByteLimitTransform(maxBytes: number, overflowError: (bytes: number) => Error): Transform;
-//# sourceMappingURL=bounded-read-stream.d.ts.map

package/dist/bounded-read.d.ts

@@ -23,4 +23,3 @@ export declare function readBoundedSync(maxBytes: number, readChunk: (scratch: B
 /** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
 export declare function readFileDescriptorBoundedSync(fd: number, maxBytes: number): Buffer;
 export {};
-//# sourceMappingURL=bounded-read.d.ts.map

package/dist/byte-budget.d.ts

@@ -1,4 +1,3 @@
 export declare function normalizeMaxBytes(value: number | undefined, options?: {
     defaultValue?: number;
 }): number | undefined;
-//# sourceMappingURL=byte-budget.d.ts.map

package/dist/byte-view.d.ts

@@ -1,3 +1,2 @@
 /** Snapshot intrinsic view bounds without copying the borrowed payload. */
 export declare function snapshotByteView(bytes: Uint8Array): Uint8Array;
-//# sourceMappingURL=byte-view.d.ts.map

package/dist/clone-metadata.d.ts

@@ -17,4 +17,3 @@ export type CloneFileMetadata = {
  * These are point-in-time facts, not authorization or a guarantee against later edits.
  */
 export declare function readCloneFileMetadata(files: readonly string[]): Promise<(CloneFileMetadata | undefined)[]>;
-//# sourceMappingURL=clone-metadata.d.ts.map

package/dist/config.d.ts

@@ -1,3 +1,2 @@
 export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";
-//# sourceMappingURL=config.d.ts.map

package/dist/containment.d.ts

@@ -1,2 +1 @@
 export type ContainmentGuarantee = "kernel-atomic" | "best-effort";
-//# sourceMappingURL=containment.d.ts.map

package/dist/copy-file-input.d.ts

@@ -19,4 +19,3 @@ export declare function assertCopySourceCurrent(source: {
 export declare function writeCopyFileToFd(fd: number, input: CopyFileInput, maxBytes?: number, assertBeforeMutation?: () => void): Promise<void>;
 export declare function createNativeCopyFile(native: NativeBinding, input: CopyFileInput, parentFd: number, basename: string, maxBytes: number | undefined, sync: boolean): Promise<NativeFileCopyResult | undefined>;
 export declare function assertNativeCopyCompleted(input: CopyFileInput, copied?: NativeFileCopyResult): void;
-//# sourceMappingURL=copy-file-input.d.ts.map

package/dist/copy-policy.d.ts

@@ -1,3 +1,2 @@
 export type CopyCloneMode = "auto" | "always" | "never";
 export declare function resolveCopyCloneMode(mode: CopyCloneMode | undefined, defaultMode: CopyCloneMode): CopyCloneMode;
-//# sourceMappingURL=copy-policy.d.ts.map

package/dist/copy-publication.d.ts

@@ -18,4 +18,3 @@ export type CopyPublicationOptions = {
         verify(): void;
     };
 };
-//# sourceMappingURL=copy-publication.d.ts.map

package/dist/copy-tree-portable.d.ts

@@ -6,4 +6,3 @@ export declare function copyOwnedTree(source: ReturnType<typeof openStagedDirect
     concurrency: number;
     copyFileContents?: NativeBinding["copyFileContents"];
 }): Promise<void>;
-//# sourceMappingURL=copy-tree-portable.d.ts.map

package/dist/copy-tree-portable.js

@@ -11,7 +11,7 @@ function timestampSeconds(nanoseconds) {
 }
 /** Byte-copy adapter for the shared immutable-source, caller-owned namespace contract. */
 export async function copyOwnedTree(source, destination, options) {
-    options.signal?.throwIfAborted();
+    const callerSignal = options.signal ? AbortSignal.any([options.signal]) : undefined;
     const cancellation = new AbortController();
     const signal = cancellation.signal;
     setMaxListeners(options.concurrency, signal);
@@ -23,8 +23,8 @@ export async function copyOwnedTree(source, destination, options) {
         failure ??= { value };
         cancellation.abort(failure);
     }
-    const abort = () => recordFailure(options.signal?.reason);
-    options.signal?.addEventListener("abort", abort, { once: true });
+    if (callerSignal)
+        callerSignal.onabort = () => recordFailure(callerSignal.reason);
     async function schedule(operation, children) {
         signal.throwIfAborted();
         const task = operation()
@@ -51,8 +51,8 @@ export async function copyOwnedTree(source, destination, options) {
             }
             output = await fsp.open(to, "wx", 0o600);
             if (options.copyFileContents) {
-                // napi-rs owns onabort. Each admitted file gets a separate signal so
-                // concurrent native copies cannot replace one another's cancellation.
+                // napi-rs owns onabort. Each admitted file gets a separate signal; the
+                // shared failure signal is private, so callers cannot intercept its relay.
                 const fileCancellation = new AbortController();
                 const abortFile = () => fileCancellation.abort();
                 signal.addEventListener("abort", abortFile, { once: true });
@@ -62,6 +62,7 @@ export async function copyOwnedTree(source, destination, options) {
                 }
                 finally {
                     signal.removeEventListener("abort", abortFile);
+                    fileCancellation.signal.onabort = null;
                 }
             }
             else {
@@ -224,6 +225,7 @@ export async function copyOwnedTree(source, destination, options) {
         signal.throwIfAborted();
     }
     try {
+        callerSignal?.throwIfAborted();
         await copyDirectory(source.receipt.realPath, destination);
         await Promise.all(finishing);
         signal.throwIfAborted();
@@ -233,7 +235,8 @@ export async function copyOwnedTree(source, destination, options) {
     }
     finally {
         await Promise.all(finishing);
-        options.signal?.removeEventListener("abort", abort);
+        if (callerSignal)
+            callerSignal.onabort = null;
     }
     if (failure)
         throw failure.value;

package/dist/copy.d.ts

@@ -13,4 +13,3 @@ export declare function probeTreeClone(parentPath: string): TreeCloneBackend | u
 export declare function createCloneSource(destination: string, options?: Pick<CopyTreeOptions, "signal">): Promise<void>;
 /** Copy an immutable, caller-owned tree, preferring native cloning unless configured otherwise. */
 export declare function copyTree(source: string, destination: string, options?: CopyTreeOptions): Promise<void>;
-//# sourceMappingURL=copy.d.ts.map

package/dist/copy.js

@@ -94,12 +94,11 @@ async function materializeTree(source, destination, options, policy) {
         let cloned = false;
         // napi-rs uses the supplied signal's onabort property. Give it a private
         // signal so caller handlers and other admitted native operations stay intact.
-        const cancellation = options.signal && supported ? new AbortController() : undefined;
-        const abort = () => cancellation?.abort();
-        options.signal?.addEventListener("abort", abort, { once: true });
+        const nativeSignal = options.signal && supported ? AbortSignal.any([options.signal]) : undefined;
         try {
             if (native && supported) {
-                await native.cloneTree(original?.fd ?? null, parent.fd, name, concurrency, cancellation?.signal);
+                nativeSignal?.throwIfAborted();
+                await native.cloneTree(original?.fd ?? null, parent.fd, name, concurrency, nativeSignal);
                 cloned = true;
             }
         }
@@ -113,7 +112,8 @@ async function materializeTree(source, destination, options, policy) {
             }
         }
         finally {
-            options.signal?.removeEventListener("abort", abort);
+            if (nativeSignal)
+                nativeSignal.onabort = null;
         }
         options.signal?.throwIfAborted();
         assertStagedDirectoryCurrent(parent.receipt);

package/dist/create-directory.d.ts

@@ -15,6 +15,4 @@ export declare function createDirectory(targetPath: string, options?: CreateDire
 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 createDirectorySyncWithAdmission(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): void;
 export declare function createDirectoryWithReceiptSync(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): CreationDirectoryReceipt;
-//# sourceMappingURL=create-directory.d.ts.map

package/dist/create-directory.js

@@ -3,13 +3,11 @@ import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
 import { getFsSafeNativeConfig } from "./native-config.js";
-import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 import { assertPrivateDirectory, assertPrivateDirectorySync, inspectCreationDirectory, inspectCreationDirectorySync, resolveCreationPermissions, } from "./creation-permissions.js";
-import { creationCollision, prepareCreationPath } from "./creation-path.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";
-import { assertDarwinCreationDirectoryAcl, assertDarwinPrivateDirectoryMode } from "./creation-darwin.js";
 function directoryAdoptionFailure(error, target, windowsIdentity) {
     return new FsSafeError("helper-failed", "created directory admission failed", {
         cause: error,
@@ -43,14 +41,7 @@ export async function createDirectoryWithReceipt(targetPath, options = {}, admis
     const backend = permissions.private && process.platform === "win32" ? privateDirectoryBackend() : undefined;
     const parentIdentity = permissions.private && process.platform === "win32"
         ? await inspectCreationDirectory(selected.parent.dir, false) : undefined;
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "directory");
-    assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-    selected.assertParent();
-    if (permissions.private)
-        assertDarwinPrivateDirectoryMode(permissions.mode);
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "directory");
+    assertBeforeCreation(selected, permissions, assertion, "directory");
     let created = false;
     let windowsIdentity;
     try {
@@ -82,9 +73,6 @@ export async function createDirectoryWithReceipt(targetPath, options = {}, admis
 export function createDirectorySync(targetPath, options = {}) {
     createDirectoryWithReceiptSync(targetPath, options, {});
 }
-export function createDirectorySyncWithAdmission(targetPath, options = {}, admission = {}) {
-    createDirectoryWithReceiptSync(targetPath, options, admission);
-}
 export function createDirectoryWithReceiptSync(targetPath, options = {}, admission = {}) {
     const permissions = resolveCreationPermissions(options, true);
     const assertion = options.assertBeforeMutation;
@@ -92,14 +80,7 @@ export function createDirectoryWithReceiptSync(targetPath, options = {}, admissi
     const backend = permissions.private && process.platform === "win32" ? privateDirectoryBackend() : undefined;
     const parentIdentity = permissions.private && process.platform === "win32"
         ? inspectCreationDirectorySync(selected.parent.dir, false) : undefined;
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "directory");
-    assertSynchronousCallbackResult(assertion?.(), "assertBeforeMutation");
-    selected.assertParent();
-    if (permissions.private)
-        assertDarwinPrivateDirectoryMode(permissions.mode);
-    if (permissions.private)
-        assertDarwinCreationDirectoryAcl(selected.parent.dir, selected.parent.stat, "directory");
+    assertBeforeCreation(selected, permissions, assertion, "directory");
     let created = false;
     let windowsIdentity;
     try {

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

@@ -4,4 +4,3 @@ export declare function createPrivateWindowsFileHandle(selected: CreationPath, o
     mode: number;
     assertBeforeMutation?: () => void;
 }): Promise<FileHandle>;
-//# sourceMappingURL=create-file-async.d.ts.map

package/dist/create-file.d.ts

@@ -5,4 +5,3 @@ 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.js

@@ -8,12 +8,11 @@ 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 { 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";
-import { assertDarwinCreationDirectoryAcl } from "./creation-darwin.js";
 function createPrivateWindowsFile(selected, options, mode) {
     const assertion = options.assertBeforeMutation;
     if (fs.lstatSync(selected.target, { throwIfNoEntry: false })) {
@@ -113,12 +112,7 @@ function createFileCore(targetPath, options, admission) {
         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");
+    assertBeforeCreation(selected, permissions, assertion, "file");
     let file;
     try {
         file = ownFileDescriptorSync(fs.openSync(selected.target, fs.constants.O_RDWR | fs.constants.O_CREAT |
@@ -156,12 +150,7 @@ export async function createFileHandle(targetPath, options = {}, admission = {})
     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");
+        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); });

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

@@ -5,4 +5,3 @@ export type OwnedFileDescriptorSync = {
 };
 /** Capture the descriptor's creator-owned closer before it can be reused. */
 export declare function ownFileDescriptorSync(fd: number, closeFd?: (fd: number) => void): OwnedFileDescriptorSync;
-//# sourceMappingURL=create-owned-file.d.ts.map

package/dist/create.d.ts

@@ -1,4 +1,3 @@
-export { createDirectory, createDirectorySync, createDirectoryWithAdmission, createDirectorySyncWithAdmission, type CreateDirectoryOptions, type CreationAdmission, } from "./create-directory.js";
+export { createDirectory, createDirectorySync, createDirectoryWithAdmission, type CreateDirectoryOptions, type CreationAdmission, } from "./create-directory.js";
 export { createFileSync, createFileHandle, type CreateFileOptions } from "./create-file.js";
 export type { OwnedFileDescriptorSync } from "./create-owned-file.js";
-//# sourceMappingURL=create.d.ts.map

package/dist/create.js

@@ -1,2 +1,2 @@
-export { createDirectory, createDirectorySync, createDirectoryWithAdmission, createDirectorySyncWithAdmission, } from "./create-directory.js";
+export { createDirectory, createDirectorySync, createDirectoryWithAdmission, } from "./create-directory.js";
 export { createFileSync, createFileHandle } from "./create-file.js";

package/dist/creation-darwin.d.ts

@@ -3,4 +3,3 @@ 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-file-state.d.ts

@@ -16,4 +16,3 @@ export declare function privateFileSettlementFailure(params: {
     stageDirectory: string;
     preserved?: boolean;
 }): FsSafeError;
-//# sourceMappingURL=creation-file-state.d.ts.map

package/dist/creation-path.d.ts

@@ -1,5 +1,6 @@
 import { type BigIntStats } from "node:fs";
 import { type AsyncDirectoryGuard, type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { CreationPermissions } from "./creation-permissions.js";
 export type CreationParentIdentity = Readonly<{
     dev: bigint;
     ino: bigint;
@@ -10,6 +11,7 @@ export type CreationPath = {
     parent: AsyncDirectoryGuard<BigIntStats>;
     assertParent(): void;
 };
+export declare function assertBeforeCreation(selected: CreationPath, permissions: CreationPermissions, assertion: (() => void) | undefined, kind: "file" | "directory"): void;
 export declare function creationAdmissionFromParent(parent: AnyAsyncDirectoryGuard): {
     expectedParentIdentity: CreationParentIdentity;
 };
@@ -18,4 +20,3 @@ 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