@openclaw/fs-safe 0.1.0

package/dist/private-temp-workspace.js

@@ -0,0 +1,185 @@
+import { randomUUID } from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileStore, fileStoreSync, } from "./file-store.js";
+import { registerTempPathForExit } from "./temp-cleanup.js";
+function sanitizeTempPrefix(prefix) {
+    const sanitized = prefix.trim().replace(/[^a-zA-Z0-9._-]/g, "-");
+    if (!sanitized || sanitized === "." || sanitized === "..") {
+        return "fs-safe-";
+    }
+    return sanitized.endsWith("-") ? sanitized : `${sanitized}-`;
+}
+function resolveWorkspaceLeaf(dir, fileName) {
+    const raw = fileName.trim();
+    if (!raw ||
+        raw === "." ||
+        raw === ".." ||
+        raw.includes("\0") ||
+        raw.includes("/") ||
+        raw.includes("\\") ||
+        path.basename(raw) !== raw) {
+        throw new Error(`Invalid temp workspace file name: ${JSON.stringify(fileName)}`);
+    }
+    return path.join(dir, raw);
+}
+function assertWorkspaceFileName(fileName) {
+    resolveWorkspaceLeaf(".", fileName);
+    return fileName.trim();
+}
+async function ensurePrivateDirectory(dir, mode) {
+    await fs.mkdir(dir, { recursive: true, mode });
+    const stat = await fs.stat(dir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Temp root must be a directory: ${dir}`);
+    }
+    await fs.chmod(dir, mode).catch(() => undefined);
+}
+function ensurePrivateDirectorySync(dir, mode) {
+    fsSync.mkdirSync(dir, { recursive: true, mode });
+    const stat = fsSync.statSync(dir);
+    if (!stat.isDirectory()) {
+        throw new Error(`Temp root must be a directory: ${dir}`);
+    }
+    try {
+        fsSync.chmodSync(dir, mode);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+}
+async function createTempWorkspace(options) {
+    const dirMode = options.dirMode ?? 0o700;
+    const mode = options.mode ?? 0o600;
+    const requestedRoot = path.resolve(options.rootDir);
+    const root = await fs.realpath(requestedRoot).catch(() => requestedRoot);
+    await ensurePrivateDirectory(root, dirMode);
+    const dir = await fs.mkdtemp(path.join(root, sanitizeTempPrefix(options.prefix)));
+    const unregisterTempDir = registerTempPathForExit(dir, { recursive: true });
+    await fs.chmod(dir, dirMode).catch(() => undefined);
+    const stat = await fs.lstat(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`Temp workspace must be a directory: ${dir}`);
+    }
+    const store = fileStore({ rootDir: dir, private: true, dirMode, mode });
+    return {
+        dir,
+        store,
+        path: (fileName) => resolveWorkspaceLeaf(dir, fileName),
+        write: async (fileName, data) => await store.write(assertWorkspaceFileName(fileName), data, { mode }),
+        writeText: async (fileName, data) => await store.writeText(assertWorkspaceFileName(fileName), data, { mode }),
+        writeJson: async (fileName, data, writeOptions) => await store.writeJson(assertWorkspaceFileName(fileName), data, {
+            mode,
+            trailingNewline: writeOptions?.trailingNewline,
+        }),
+        copyIn: async (fileName, sourcePath) => await store.copyIn(assertWorkspaceFileName(fileName), sourcePath, { mode }),
+        read: async (fileName) => await store.readBytes(assertWorkspaceFileName(fileName)),
+        cleanup: async () => {
+            try {
+                await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+            }
+            finally {
+                unregisterTempDir();
+            }
+        },
+        [Symbol.asyncDispose]: async () => {
+            try {
+                await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+            }
+            finally {
+                unregisterTempDir();
+            }
+        },
+    };
+}
+export async function tempWorkspace(options) {
+    return await createTempWorkspace(options);
+}
+export async function withTempWorkspace(options, run) {
+    const workspace = await createTempWorkspace({
+        ...options,
+        prefix: `${sanitizeTempPrefix(options.prefix)}${randomUUID()}-`,
+    });
+    try {
+        return await run(workspace);
+    }
+    finally {
+        await workspace.cleanup();
+    }
+}
+export function tempWorkspaceSync(options) {
+    const dirMode = options.dirMode ?? 0o700;
+    const mode = options.mode ?? 0o600;
+    const requestedRoot = path.resolve(options.rootDir);
+    let root = requestedRoot;
+    try {
+        root = fsSync.realpathSync.native(requestedRoot);
+    }
+    catch {
+        root = requestedRoot;
+    }
+    ensurePrivateDirectorySync(root, dirMode);
+    const dir = fsSync.mkdtempSync(path.join(root, sanitizeTempPrefix(options.prefix)));
+    const unregisterTempDir = registerTempPathForExit(dir, { recursive: true });
+    try {
+        fsSync.chmodSync(dir, dirMode);
+    }
+    catch {
+        // Best-effort on platforms that do not enforce POSIX modes.
+    }
+    const stat = fsSync.lstatSync(dir);
+    if (stat.isSymbolicLink() || !stat.isDirectory()) {
+        throw new Error(`Temp workspace must be a directory: ${dir}`);
+    }
+    const store = fileStoreSync({ rootDir: dir, private: true, dirMode, mode });
+    return {
+        dir,
+        store,
+        path: (fileName) => resolveWorkspaceLeaf(dir, fileName),
+        write: (fileName, data) => store.write(assertWorkspaceFileName(fileName), data, { mode }),
+        writeText: (fileName, data) => store.writeText(assertWorkspaceFileName(fileName), data, { mode }),
+        writeJson: (fileName, data, writeOptions) => store.writeJson(assertWorkspaceFileName(fileName), data, {
+            mode,
+            trailingNewline: writeOptions?.trailingNewline,
+        }),
+        read: (fileName) => {
+            const filePath = store.path(assertWorkspaceFileName(fileName));
+            return fsSync.readFileSync(filePath);
+        },
+        cleanup: () => {
+            try {
+                fsSync.rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // Best-effort cleanup.
+            }
+            finally {
+                unregisterTempDir();
+            }
+        },
+        [Symbol.dispose]: () => {
+            try {
+                fsSync.rmSync(dir, { recursive: true, force: true });
+            }
+            catch {
+                // Best-effort cleanup.
+            }
+            finally {
+                unregisterTempDir();
+            }
+        },
+    };
+}
+export function withTempWorkspaceSync(options, run) {
+    const workspace = tempWorkspaceSync({
+        ...options,
+        prefix: `${sanitizeTempPrefix(options.prefix)}${randomUUID()}-`,
+    });
+    try {
+        return run(workspace);
+    }
+    finally {
+        workspace.cleanup();
+    }
+}

package/dist/regular-file.d.ts

@@ -0,0 +1,38 @@
+import type { Stats } from "node:fs";
+import fsSync from "node:fs";
+export type RegularFileStatResult = {
+    missing: true;
+} | {
+    missing: false;
+    stat: Stats;
+};
+type RegularFileAppendFlagConstants = Pick<typeof fsSync.constants, "O_APPEND" | "O_CREAT" | "O_WRONLY"> & Partial<Pick<typeof fsSync.constants, "O_NOFOLLOW">>;
+export type AppendRegularFileOptions = {
+    filePath: string;
+    content: string | Uint8Array;
+    encoding?: BufferEncoding;
+    maxFileBytes?: number;
+    mode?: number;
+    rejectSymlinkParents?: boolean;
+};
+export declare function resolveRegularFileAppendFlags(constants?: RegularFileAppendFlagConstants): number;
+export declare function statRegularFile(filePath: string): Promise<RegularFileStatResult>;
+export declare function statRegularFileSync(filePath: string): RegularFileStatResult;
+export declare function readRegularFile(params: {
+    filePath: string;
+    maxBytes?: number;
+}): Promise<{
+    buffer: Buffer;
+    stat: Stats;
+}>;
+export declare function readRegularFileSync(params: {
+    filePath: string;
+    maxBytes?: number;
+}): {
+    buffer: Buffer;
+    stat: Stats;
+};
+export declare function appendRegularFile(options: AppendRegularFileOptions): Promise<void>;
+export declare function appendRegularFileSync(options: AppendRegularFileOptions): void;
+export {};
+//# sourceMappingURL=regular-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regular-file.d.ts","sourceRoot":"","sources":["../src/regular-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,MAAM,MAAM,SAAS,CAAC;AAO7B,MAAM,MAAM,qBAAqB,GAAG;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAExF,KAAK,8BAA8B,GAAG,IAAI,CACxC,OAAO,MAAM,CAAC,SAAS,EACvB,UAAU,GAAG,SAAS,GAAG,UAAU,CACpC,GACC,OAAO,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;AAEvD,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,8BAAiD,GAC3D,MAAM,CAQR;AAWD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CActF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CAc3E;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CA6B3C;AA0CD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,CAAC;CACb,CAoBA;AAmBD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuDxF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CA2D7E"}

package/dist/regular-file.js

@@ -0,0 +1,239 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { sameFileIdentity } from "./file-identity.js";
+import { isNotFoundPathError } from "./path.js";
+import { assertNoSymlinkParents, assertNoSymlinkParentsSync } from "./symlink-parents.js";
+export function resolveRegularFileAppendFlags(constants = fsSync.constants) {
+    const noFollow = constants.O_NOFOLLOW;
+    return (constants.O_CREAT |
+        constants.O_APPEND |
+        constants.O_WRONLY |
+        (typeof noFollow === "number" ? noFollow : 0));
+}
+function resolveRegularFileReadFlags() {
+    return (fsSync.constants.O_RDONLY |
+        (typeof fsSync.constants.O_NOFOLLOW === "number" && process.platform !== "win32"
+            ? fsSync.constants.O_NOFOLLOW
+            : 0));
+}
+export async function statRegularFile(filePath) {
+    let stat;
+    try {
+        stat = await fs.lstat(filePath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return { missing: true };
+        }
+        throw err;
+    }
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new Error("path must be a regular file");
+    }
+    return { missing: false, stat };
+}
+export function statRegularFileSync(filePath) {
+    let stat;
+    try {
+        stat = fsSync.lstatSync(filePath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return { missing: true };
+        }
+        throw err;
+    }
+    if (stat.isSymbolicLink() || !stat.isFile()) {
+        throw new Error("path must be a regular file");
+    }
+    return { missing: false, stat };
+}
+export async function readRegularFile(params) {
+    const result = await statRegularFile(params.filePath);
+    if (result.missing) {
+        throw Object.assign(new Error(`File not found: ${params.filePath}`), { code: "ENOENT" });
+    }
+    if (params.maxBytes !== undefined && result.stat.size > params.maxBytes) {
+        throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+    }
+    const handle = await fs.open(params.filePath, resolveRegularFileReadFlags());
+    try {
+        const stat = await handle.stat();
+        verifyStableReadTarget({
+            filePath: params.filePath,
+            pathStat: await fs.lstat(params.filePath),
+            postOpenStat: stat,
+            preOpenStat: result.stat,
+        });
+        if (params.maxBytes !== undefined && stat.size > params.maxBytes) {
+            throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+        }
+        const buffer = await handle.readFile();
+        if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
+            throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+        }
+        return { buffer, stat };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function verifyStableReadTarget(params) {
+    if (!params.postOpenStat.isFile() || params.pathStat.isSymbolicLink() || !params.pathStat.isFile()) {
+        throw new Error(`File is not a regular file: ${params.filePath}`);
+    }
+    if (!sameFileIdentity(params.preOpenStat, params.postOpenStat) ||
+        !sameFileIdentity(params.pathStat, params.postOpenStat)) {
+        throw new Error(`File changed during read: ${params.filePath}`);
+    }
+}
+function readOpenedRegularFileSync(params) {
+    const stat = fsSync.fstatSync(params.fd);
+    verifyStableReadTarget({
+        filePath: params.filePath,
+        pathStat: fsSync.lstatSync(params.filePath),
+        postOpenStat: stat,
+        preOpenStat: params.preOpenStat,
+    });
+    if (params.maxBytes !== undefined && stat.size > params.maxBytes) {
+        throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+    }
+    const buffer = fsSync.readFileSync(params.fd);
+    if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
+        throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+    }
+    return { buffer, stat };
+}
+export function readRegularFileSync(params) {
+    const result = statRegularFileSync(params.filePath);
+    if (result.missing) {
+        throw Object.assign(new Error(`File not found: ${params.filePath}`), { code: "ENOENT" });
+    }
+    if (params.maxBytes !== undefined && result.stat.size > params.maxBytes) {
+        throw new Error(`File exceeds ${params.maxBytes} bytes: ${params.filePath}`);
+    }
+    const fd = fsSync.openSync(params.filePath, resolveRegularFileReadFlags());
+    try {
+        return readOpenedRegularFileSync({
+            fd,
+            filePath: params.filePath,
+            preOpenStat: result.stat,
+            maxBytes: params.maxBytes,
+        });
+    }
+    finally {
+        fsSync.closeSync(fd);
+    }
+}
+function verifyStableAppendTarget(params) {
+    if (!params.postOpenStat.isFile()) {
+        throw new Error(`Refusing to append to non-file: ${params.filePath}`);
+    }
+    if (params.postOpenStat.nlink > 1) {
+        throw new Error(`Refusing to append to hardlinked file: ${params.filePath}`);
+    }
+    const pre = params.preOpenStat;
+    if (pre && (pre.dev !== params.postOpenStat.dev || pre.ino !== params.postOpenStat.ino)) {
+        throw new Error(`Refusing to append after file changed: ${params.filePath}`);
+    }
+}
+export async function appendRegularFile(options) {
+    if (options.rejectSymlinkParents === true) {
+        const resolvedDir = path.resolve(path.dirname(options.filePath));
+        await assertNoSymlinkParents({
+            rootDir: path.parse(resolvedDir).root,
+            targetPath: resolvedDir,
+            allowMissing: false,
+            allowRootChildSymlink: true,
+            requireDirectories: true,
+            messagePrefix: "Refusing to append under",
+        });
+    }
+    let preOpenStat;
+    try {
+        const stat = await fs.lstat(options.filePath);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Refusing to append through symlink: ${options.filePath}`);
+        }
+        if (!stat.isFile()) {
+            throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+        }
+        preOpenStat = stat;
+    }
+    catch (err) {
+        if (!isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const contentBytes = Buffer.isBuffer(options.content)
+        ? options.content.byteLength
+        : Buffer.byteLength(options.content, options.encoding ?? "utf8");
+    if (options.maxFileBytes !== undefined &&
+        (preOpenStat?.size ?? 0) + contentBytes > options.maxFileBytes) {
+        return;
+    }
+    const handle = await fs.open(options.filePath, resolveRegularFileAppendFlags(), options.mode ?? 0o600);
+    try {
+        const stat = await handle.stat();
+        verifyStableAppendTarget({ preOpenStat, postOpenStat: stat, filePath: options.filePath });
+        if (options.maxFileBytes !== undefined && stat.size + contentBytes > options.maxFileBytes) {
+            return;
+        }
+        await handle.chmod(options.mode ?? 0o600);
+        await handle.appendFile(options.content, options.encoding ?? "utf8");
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function appendRegularFileSync(options) {
+    if (options.rejectSymlinkParents === true) {
+        const resolvedDir = path.resolve(path.dirname(options.filePath));
+        assertNoSymlinkParentsSync({
+            rootDir: path.parse(resolvedDir).root,
+            targetPath: resolvedDir,
+            allowMissing: false,
+            allowRootChildSymlink: true,
+            requireDirectories: true,
+            messagePrefix: "Refusing to append under",
+        });
+    }
+    let preOpenStat;
+    try {
+        const stat = fsSync.lstatSync(options.filePath);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Refusing to append through symlink: ${options.filePath}`);
+        }
+        if (!stat.isFile()) {
+            throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+        }
+        preOpenStat = stat;
+    }
+    catch (err) {
+        if (!isNotFoundPathError(err)) {
+            throw err;
+        }
+    }
+    const contentBuffer = typeof options.content === "string"
+        ? Buffer.from(options.content, options.encoding ?? "utf8")
+        : Buffer.from(options.content);
+    if (options.maxFileBytes !== undefined &&
+        (preOpenStat?.size ?? 0) + contentBuffer.byteLength > options.maxFileBytes) {
+        return;
+    }
+    const fd = fsSync.openSync(options.filePath, resolveRegularFileAppendFlags(), options.mode ?? 0o600);
+    try {
+        const stat = fsSync.fstatSync(fd);
+        verifyStableAppendTarget({ preOpenStat, postOpenStat: stat, filePath: options.filePath });
+        if (options.maxFileBytes !== undefined &&
+            stat.size + contentBuffer.byteLength > options.maxFileBytes) {
+            return;
+        }
+        fsSync.fchmodSync(fd, options.mode ?? 0o600);
+        fsSync.writeSync(fd, contentBuffer, 0, contentBuffer.byteLength);
+    }
+    finally {
+        fsSync.closeSync(fd);
+    }
+}

package/dist/replace-directory.d.ts

@@ -0,0 +1,7 @@
+export type ReplaceDirectoryAtomicOptions = {
+    stagedDir: string;
+    targetDir: string;
+    backupPrefix?: string;
+};
+export declare function replaceDirectoryAtomic(options: ReplaceDirectoryAtomicOptions): Promise<void>;
+//# sourceMappingURL=replace-directory.d.ts.map

package/dist/replace-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-directory.d.ts","sourceRoot":"","sources":["../src/replace-directory.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/replace-directory.js

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function replaceDirectoryAtomic(options) {
+    const targetDir = path.resolve(options.targetDir);
+    const stagedDir = path.resolve(options.stagedDir);
+    const parentDir = path.dirname(targetDir);
+    const backupDir = path.join(parentDir, `${options.backupPrefix ?? ".fs-safe-dir-backup-"}${process.pid}-${Date.now()}`);
+    let backupCreated = false;
+    await fs.mkdir(parentDir, { recursive: true });
+    try {
+        await fs.rename(targetDir, backupDir);
+        backupCreated = true;
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    try {
+        await fs.rename(stagedDir, targetDir);
+    }
+    catch (err) {
+        if (backupCreated) {
+            await fs.rename(backupDir, targetDir).catch(() => undefined);
+            backupCreated = false;
+        }
+        throw err;
+    }
+    if (backupCreated) {
+        await fs.rm(backupDir, { recursive: true, force: true });
+    }
+}

package/dist/replace-file.d.ts

@@ -0,0 +1,41 @@
+import syncFs from "node:fs";
+import fs from "node:fs/promises";
+export type ReplaceFileAtomicFileSystem = {
+    promises: Pick<typeof fs, "mkdir" | "chmod" | "writeFile" | "rename" | "copyFile" | "unlink" | "rm" | "open" | "stat" | "lstat">;
+};
+export type ReplaceFileAtomicSyncFileSystem = Pick<typeof syncFs, "mkdirSync" | "chmodSync" | "writeFileSync" | "renameSync" | "copyFileSync" | "unlinkSync" | "rmSync" | "openSync" | "fsyncSync" | "closeSync" | "statSync" | "lstatSync">;
+type ReplaceFileAtomicBaseOptions = {
+    filePath: string;
+    content: string | Uint8Array;
+    dirMode?: number;
+    mode?: number;
+    preserveExistingMode?: boolean;
+    tempPrefix?: string;
+    renameMaxRetries?: number;
+    renameRetryBaseDelayMs?: number;
+    copyFallbackOnPermissionError?: boolean;
+    syncTempFile?: boolean;
+    syncParentDir?: boolean;
+    throwOnCleanupError?: boolean;
+};
+export type ReplaceFileAtomicOptions = ReplaceFileAtomicBaseOptions & {
+    fileSystem?: ReplaceFileAtomicFileSystem;
+    beforeRename?: (params: {
+        filePath: string;
+        tempPath: string;
+    }) => Promise<void>;
+};
+export type ReplaceFileAtomicSyncOptions = ReplaceFileAtomicBaseOptions & {
+    fileSystem?: ReplaceFileAtomicSyncFileSystem;
+    beforeRename?: (params: {
+        filePath: string;
+        tempPath: string;
+    }) => void;
+};
+export type ReplaceFileAtomicResult = {
+    method: "rename" | "copy-fallback";
+};
+export declare function replaceFileAtomic(options: ReplaceFileAtomicOptions): Promise<ReplaceFileAtomicResult>;
+export declare function replaceFileAtomicSync(options: ReplaceFileAtomicSyncOptions): ReplaceFileAtomicResult;
+export {};
+//# sourceMappingURL=replace-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replace-file.d.ts","sourceRoot":"","sources":["../src/replace-file.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAKlC,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,EAAE,IAAI,CACZ,OAAO,EAAE,EACP,OAAO,GACP,OAAO,GACP,WAAW,GACX,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,IAAI,GACJ,MAAM,GACN,MAAM,GACN,OAAO,CACV,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,IAAI,CAChD,OAAO,MAAM,EACX,WAAW,GACX,WAAW,GACX,eAAe,GACf,YAAY,GACZ,cAAc,GACd,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,WAAW,GACX,WAAW,GACX,UAAU,GACV,WAAW,CACd,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,6BAA6B,CAAC,EAAE,OAAO,CAAC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,4BAA4B,GAAG;IACpE,UAAU,CAAC,EAAE,2BAA2B,CAAC;IACzC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClF,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,4BAA4B,GAAG;IACxE,UAAU,CAAC,EAAE,+BAA+B,CAAC;IAC7C,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,QAAQ,GAAG,eAAe,CAAC;CACpC,CAAC;AA+NF,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC,CAMlC;AAyDD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,4BAA4B,GACpC,uBAAuB,CAiEzB"}