@warlock.js/fs 4.1.1

package/README.md

@@ -0,0 +1,76 @@
+# @warlock.js/fs
+
+A pocket-sized filesystem toolkit for Node — the shape you wish `node:fs/promises` had, without pulling in `fs-extra`, `rimraf`, `mkdirp`, `write-file-atomic`, and `hasha`. Standalone: usable in any Node project, no `@warlock.js/core` required.
+
+Every helper picks the right defaults — writes create parent directories for you, deletes swallow `ENOENT`, `atomicWriteAsync` writes-then-renames, and `hashFileAsync` streams so a 1 GB file doesn't blow the heap.
+
+## Install
+
+```bash
+yarn add @warlock.js/fs
+# or
+npm install @warlock.js/fs
+```
+
+## One naming convention
+
+That's the whole vocabulary:
+
+- **`*Async`** returns a `Promise` — use it in server / runtime code.
+- **bare name** is synchronous — use it in CLI tools, codegen, and one-shot scripts.
+
+One canonical name per operation; no aliases to remember. If the obvious name isn't there, the operation isn't there.
+
+## 30-second tour
+
+```ts
+import {
+  putJsonFileAsync,
+  getJsonFileAsync,
+  atomicWriteAsync,
+  ensureDirectoryAsync,
+  listFilesAsync,
+  hashFileAsync,
+} from "@warlock.js/fs";
+
+// Write JSON (parent dirs auto-created, pretty-printed at 2 spaces)
+await putJsonFileAsync("./build/manifest.json", { version: "1.0.0" });
+
+// Read it back, typed
+const manifest = await getJsonFileAsync<{ version: string }>("./build/manifest.json");
+
+// Atomic write — concurrent readers never see a half-written file
+await atomicWriteAsync("./build/state.lock", manifest.version);
+
+// Directory ops
+await ensureDirectoryAsync("./build/cache");
+const files = await listFilesAsync("./build"); // full paths, not bare names
+
+// Content fingerprint (streaming — constant memory)
+const digest = await hashFileAsync("./build/manifest.json");
+```
+
+## What you get
+
+- **Read + write text and JSON** — `getFileAsync`, `getJsonFileAsync`, `putFileAsync`, `putJsonFileAsync`. Writes auto-create parent directories; JSON variants pretty-print at 2-space indent.
+- **Atomic writes** — `atomicWriteAsync` (accepts `string | Buffer`) and `atomicWriteJsonAsync`, for files other processes read concurrently.
+- **Directory management** — `ensureDirectoryAsync`, `list(Async)` / `listFiles(Async)` / `listDirectories(Async)`, `copyFile(Async)` / `copyDirectory(Async)`, `renameFile(Async)`.
+- **Delete** — `unlink(Async)` and `removeDirectory(Async)`, both `ENOENT`-safe (no-op on missing targets).
+- **Content hashing** — `hashFileAsync` (streaming), `hashFileSmallAsync`, `hashString`, `hashBuffer`. SHA-256 default; `sha1` / `md5` / `sha512` supported.
+- **Existence + stats** — `pathExists`, `fileExists`, `directoryExists`, `lastModified`, `stats` (each with an `*Async` twin).
+
+## Full documentation
+
+The complete guide — getting started, essentials, task guides, recipes, and API reference — lives at **[warlock.js.org](https://warlock.js.org/v/latest/fs/)**.
+
+## Tests
+
+This package uses Vitest:
+
+```bash
+yarn test
+```
+
+## License
+
+MIT

package/cjs/index.cjs

@@ -0,0 +1,424 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_fs = require("node:fs");
+
+//#region ../../@warlock.js/fs/src/atomic.ts
+/**
+* Write a file atomically.
+*
+* Writes to a uniquely-named sibling temp file first, then renames it onto
+* the target. Readers either see the old content or the complete new
+* content — never a half-written file. If anything fails mid-write the
+* temp file is cleaned up.
+*
+* Parent directories are created if missing.
+*
+* @example
+*   await atomicWriteAsync("manifest.json", JSON.stringify(data));
+*/
+async function atomicWriteAsync(filePath, content) {
+	const dir = node_path.default.dirname(filePath);
+	await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+	const tempPath = node_path.default.join(dir, `.${node_path.default.basename(filePath)}.${(0, node_crypto.randomBytes)(6).toString("hex")}.tmp`);
+	try {
+		await (0, node_fs_promises.writeFile)(tempPath, content);
+		await (0, node_fs_promises.rename)(tempPath, filePath);
+	} catch (error) {
+		await (0, node_fs_promises.unlink)(tempPath).catch(() => void 0);
+		throw error;
+	}
+}
+/**
+* Atomic write convenience for JSON values (pretty-printed, 2-space indent).
+*/
+async function atomicWriteJsonAsync(filePath, value) {
+	await atomicWriteAsync(filePath, JSON.stringify(value, null, 2));
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/copy.ts
+/**
+* Copy a single file. Creates the destination's parent directory if needed.
+*/
+async function copyFileAsync(source, destination) {
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(destination), { recursive: true });
+	await (0, node_fs_promises.copyFile)(source, destination);
+}
+function copyFile(source, destination) {
+	(0, node_fs.mkdirSync)(node_path.default.dirname(destination), { recursive: true });
+	(0, node_fs.copyFileSync)(source, destination);
+}
+/**
+* Recursively copy a directory.
+*/
+async function copyDirectoryAsync(source, destination) {
+	await (0, node_fs_promises.cp)(source, destination, { recursive: true });
+}
+function copyDirectory(source, destination) {
+	(0, node_fs.cpSync)(source, destination, { recursive: true });
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/dirs.ts
+/**
+* Ensure a directory exists (recursively creating parents).
+* Idempotent — no error if the directory already exists.
+*/
+async function ensureDirectoryAsync(path) {
+	await (0, node_fs_promises.mkdir)(path, { recursive: true });
+}
+function ensureDirectory(path) {
+	(0, node_fs.mkdirSync)(path, { recursive: true });
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/exists.ts
+/**
+* Check whether a path exists, REGARDLESS of type — resolves `true` for both
+* files and directories, `false` only when nothing is there (ENOENT).
+*
+* Pick the right check for the job:
+*   - `pathExistsAsync`      — anything at this path (file OR directory).
+*   - `fileExistsAsync`      — exists AND is a regular file.
+*   - `directoryExistsAsync` — exists AND is a directory.
+*
+* @example
+* if (await pathExistsAsync("/var/data")) {
+*   // something is there — could be a file or a folder
+* }
+*/
+async function pathExistsAsync(path) {
+	try {
+		await (0, node_fs_promises.access)(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function pathExists(path) {
+	try {
+		(0, node_fs.accessSync)(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a path exists AND is a regular file. Resolves `false` for a
+* directory — use `directoryExistsAsync` for folders, or `pathExistsAsync`
+* when the type does not matter.
+*
+* @example
+* if (await fileExistsAsync("/etc/config.json")) {
+*   const raw = await readFile("/etc/config.json", "utf8");
+* }
+*/
+async function fileExistsAsync(path) {
+	try {
+		return (await (0, node_fs_promises.stat)(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+function fileExists(path) {
+	try {
+		return (0, node_fs.statSync)(path).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a path exists AND is a directory. Resolves `false` for a
+* regular file — use `fileExistsAsync` for files, or `pathExistsAsync` when
+* the type does not matter.
+*
+* @example
+* if (await directoryExistsAsync("/var/uploads")) {
+*   const entries = await readdir("/var/uploads");
+* }
+*/
+async function directoryExistsAsync(path) {
+	try {
+		return (await (0, node_fs_promises.stat)(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function directoryExists(path) {
+	try {
+		return (0, node_fs.statSync)(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/hash.ts
+/**
+* Compute a hex digest of a file's contents. Uses streaming for large
+* files so memory doesn't spike when hashing big assets.
+*
+* @param path - File to hash.
+* @param algorithm - Hash algorithm (default `sha256`).
+*
+* @example
+*   const fingerprint = await hashFile("./bundle.js");
+*   const quick = await hashFile("./small.txt", "md5");
+*/
+function hashFileAsync(path, algorithm = "sha256") {
+	return new Promise((resolve, reject) => {
+		const hash = (0, node_crypto.createHash)(algorithm);
+		const stream = (0, node_fs.createReadStream)(path);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("end", () => resolve(hash.digest("hex")));
+		stream.on("error", reject);
+	});
+}
+function hashFile(path, algorithm = "sha256") {
+	return (0, node_crypto.createHash)(algorithm).update((0, node_fs.readFileSync)(path)).digest("hex");
+}
+/**
+* Hash an in-memory string without touching disk. Convenient when the
+* caller already has the content loaded (e.g. file watcher diffing).
+*/
+function hashString(content, algorithm = "sha256") {
+	return (0, node_crypto.createHash)(algorithm).update(content).digest("hex");
+}
+/**
+* Hash an arbitrary buffer.
+*/
+function hashBuffer(content, algorithm = "sha256") {
+	return (0, node_crypto.createHash)(algorithm).update(content).digest("hex");
+}
+/**
+* Like `hashFileAsync` but reads the file in one go. Slightly faster for
+* small files; use the streaming variant for anything > ~1 MB.
+*/
+async function hashFileSmallAsync(path, algorithm = "sha256") {
+	return (0, node_crypto.createHash)(algorithm).update(await (0, node_fs_promises.readFile)(path)).digest("hex");
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/list.ts
+/**
+* List immediate children of a directory (files + subdirs), returning
+* full paths.
+*/
+async function listAsync(directoryPath) {
+	return (await (0, node_fs_promises.readdir)(directoryPath)).map((entry) => node_path.default.join(directoryPath, entry));
+}
+function list(directoryPath) {
+	return (0, node_fs.readdirSync)(directoryPath).map((entry) => node_path.default.join(directoryPath, entry));
+}
+/**
+* List only files (not subdirectories) directly inside a directory.
+*/
+async function listFilesAsync(directoryPath) {
+	const entries = await listAsync(directoryPath);
+	return (await Promise.all(entries.map(async (entry) => (await (0, node_fs_promises.stat)(entry)).isFile() ? entry : null))).filter((entry) => entry !== null);
+}
+function listFiles(directoryPath) {
+	return list(directoryPath).filter((entry) => (0, node_fs.statSync)(entry).isFile());
+}
+/**
+* List only subdirectories directly inside a directory.
+*/
+async function listDirectoriesAsync(directoryPath) {
+	const entries = await listAsync(directoryPath);
+	return (await Promise.all(entries.map(async (entry) => (await (0, node_fs_promises.stat)(entry)).isDirectory() ? entry : null))).filter((entry) => entry !== null);
+}
+function listDirectories(directoryPath) {
+	return list(directoryPath).filter((entry) => (0, node_fs.statSync)(entry).isDirectory());
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/read.ts
+/**
+* Read a file as UTF-8 text.
+*/
+async function getFileAsync(path) {
+	return (0, node_fs_promises.readFile)(path, "utf-8");
+}
+function getFile(path) {
+	return (0, node_fs.readFileSync)(path, "utf-8");
+}
+/**
+* Read a JSON file and parse it.
+*
+* @throws if the file does not exist or contains invalid JSON.
+*/
+async function getJsonFileAsync(path) {
+	return JSON.parse(await getFileAsync(path));
+}
+function getJsonFile(path) {
+	return JSON.parse(getFile(path));
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/remove.ts
+/**
+* Delete a single file. No error if the file doesn't exist.
+*/
+async function unlinkAsync(path) {
+	try {
+		await (0, node_fs_promises.unlink)(path);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+}
+function unlink(path) {
+	try {
+		(0, node_fs.unlinkSync)(path);
+	} catch (error) {
+		if (error?.code !== "ENOENT") throw error;
+	}
+}
+/**
+* Recursively delete a directory and its contents. No error if missing.
+*/
+async function removeDirectoryAsync(path) {
+	await (0, node_fs_promises.rm)(path, {
+		recursive: true,
+		force: true
+	});
+}
+function removeDirectory(path) {
+	(0, node_fs.rmSync)(path, {
+		recursive: true,
+		force: true
+	});
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/rename.ts
+/**
+* Rename / move a file or directory.
+*/
+async function renameFileAsync(from, to) {
+	await (0, node_fs_promises.rename)(from, to);
+}
+function renameFile(from, to) {
+	(0, node_fs.renameSync)(from, to);
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/stats.ts
+/**
+* Get last-modified time of a path. Returns a Date.
+*
+* @throws if the path does not exist.
+*/
+async function lastModifiedAsync(path) {
+	return (await (0, node_fs_promises.stat)(path)).mtime;
+}
+function lastModified(path) {
+	return (0, node_fs.statSync)(path).mtime;
+}
+/**
+* Return raw fs.Stats for a path.
+*/
+async function statsAsync(path) {
+	return (0, node_fs_promises.stat)(path);
+}
+function stats(path) {
+	return (0, node_fs.statSync)(path);
+}
+
+//#endregion
+//#region ../../@warlock.js/fs/src/write.ts
+/**
+* Write a UTF-8 string to disk, creating any missing parent directories.
+*/
+async function putFileAsync(filePath, content) {
+	await (0, node_fs_promises.mkdir)(node_path.default.dirname(filePath), { recursive: true });
+	await (0, node_fs_promises.writeFile)(filePath, content, "utf-8");
+}
+function putFile(filePath, content) {
+	(0, node_fs.mkdirSync)(node_path.default.dirname(filePath), { recursive: true });
+	(0, node_fs.writeFileSync)(filePath, content, "utf-8");
+}
+/**
+* Write a JSON-serialisable value to disk (pretty-printed, 2-space indent).
+*/
+async function putJsonFileAsync(filePath, value) {
+	await putFileAsync(filePath, JSON.stringify(value, null, 2));
+}
+function putJsonFile(filePath, value) {
+	putFile(filePath, JSON.stringify(value, null, 2));
+}
+
+//#endregion
+exports.atomicWriteAsync = atomicWriteAsync;
+exports.atomicWriteJsonAsync = atomicWriteJsonAsync;
+exports.copyDirectory = copyDirectory;
+exports.copyDirectoryAsync = copyDirectoryAsync;
+exports.copyFile = copyFile;
+exports.copyFileAsync = copyFileAsync;
+exports.directoryExists = directoryExists;
+exports.directoryExistsAsync = directoryExistsAsync;
+exports.ensureDirectory = ensureDirectory;
+exports.ensureDirectoryAsync = ensureDirectoryAsync;
+exports.fileExists = fileExists;
+exports.fileExistsAsync = fileExistsAsync;
+exports.getFile = getFile;
+exports.getFileAsync = getFileAsync;
+exports.getJsonFile = getJsonFile;
+exports.getJsonFileAsync = getJsonFileAsync;
+exports.hashBuffer = hashBuffer;
+exports.hashFile = hashFile;
+exports.hashFileAsync = hashFileAsync;
+exports.hashFileSmallAsync = hashFileSmallAsync;
+exports.hashString = hashString;
+exports.lastModified = lastModified;
+exports.lastModifiedAsync = lastModifiedAsync;
+exports.list = list;
+exports.listAsync = listAsync;
+exports.listDirectories = listDirectories;
+exports.listDirectoriesAsync = listDirectoriesAsync;
+exports.listFiles = listFiles;
+exports.listFilesAsync = listFilesAsync;
+exports.pathExists = pathExists;
+exports.pathExistsAsync = pathExistsAsync;
+exports.putFile = putFile;
+exports.putFileAsync = putFileAsync;
+exports.putJsonFile = putJsonFile;
+exports.putJsonFileAsync = putJsonFileAsync;
+exports.removeDirectory = removeDirectory;
+exports.removeDirectoryAsync = removeDirectoryAsync;
+exports.renameFile = renameFile;
+exports.renameFileAsync = renameFileAsync;
+exports.stats = stats;
+exports.statsAsync = statsAsync;
+exports.unlink = unlink;
+exports.unlinkAsync = unlinkAsync;
+//# sourceMappingURL=index.cjs.map

package/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["path","path","path","path"],"sources":["../../../../../@warlock.js/fs/src/atomic.ts","../../../../../@warlock.js/fs/src/copy.ts","../../../../../@warlock.js/fs/src/dirs.ts","../../../../../@warlock.js/fs/src/exists.ts","../../../../../@warlock.js/fs/src/hash.ts","../../../../../@warlock.js/fs/src/list.ts","../../../../../@warlock.js/fs/src/read.ts","../../../../../@warlock.js/fs/src/remove.ts","../../../../../@warlock.js/fs/src/rename.ts","../../../../../@warlock.js/fs/src/stats.ts","../../../../../@warlock.js/fs/src/write.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { mkdir, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\n/**\n * Write a file atomically.\n *\n * Writes to a uniquely-named sibling temp file first, then renames it onto\n * the target. Readers either see the old content or the complete new\n * content — never a half-written file. If anything fails mid-write the\n * temp file is cleaned up.\n *\n * Parent directories are created if missing.\n *\n * @example\n *   await atomicWriteAsync(\"manifest.json\", JSON.stringify(data));\n */\nexport async function atomicWriteAsync(filePath: string, content: string | Buffer): Promise<void> {\n  const dir = path.dirname(filePath);\n  await mkdir(dir, { recursive: true });\n\n  // Random suffix so concurrent writers don't fight over the same temp file.\n  const tempPath = path.join(dir, `.${path.basename(filePath)}.${randomBytes(6).toString(\"hex\")}.tmp`);\n\n  try {\n    await writeFile(tempPath, content);\n    await rename(tempPath, filePath);\n  } catch (error) {\n    await unlink(tempPath).catch(() => undefined);\n    throw error;\n  }\n}\n\n/**\n * Atomic write convenience for JSON values (pretty-printed, 2-space indent).\n */\nexport async function atomicWriteJsonAsync(filePath: string, value: unknown): Promise<void> {\n  await atomicWriteAsync(filePath, JSON.stringify(value, null, 2));\n}\n","import { cp, copyFile as copyFilePromise, mkdir } from \"node:fs/promises\";\nimport { copyFileSync, cpSync, mkdirSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Copy a single file. Creates the destination's parent directory if needed.\n */\nexport async function copyFileAsync(source: string, destination: string): Promise<void> {\n  await mkdir(path.dirname(destination), { recursive: true });\n  await copyFilePromise(source, destination);\n}\n\nexport function copyFile(source: string, destination: string): void {\n  mkdirSync(path.dirname(destination), { recursive: true });\n  copyFileSync(source, destination);\n}\n\n/**\n * Recursively copy a directory.\n */\nexport async function copyDirectoryAsync(source: string, destination: string): Promise<void> {\n  await cp(source, destination, { recursive: true });\n}\n\nexport function copyDirectory(source: string, destination: string): void {\n  cpSync(source, destination, { recursive: true });\n}\n","import { mkdir } from \"node:fs/promises\";\nimport { mkdirSync } from \"node:fs\";\n\n/**\n * Ensure a directory exists (recursively creating parents).\n * Idempotent — no error if the directory already exists.\n */\nexport async function ensureDirectoryAsync(path: string): Promise<void> {\n  await mkdir(path, { recursive: true });\n}\n\nexport function ensureDirectory(path: string): void {\n  mkdirSync(path, { recursive: true });\n}\n","import { access, stat } from \"node:fs/promises\";\nimport { accessSync, statSync } from \"node:fs\";\n\n/**\n * Check whether a path exists, REGARDLESS of type — resolves `true` for both\n * files and directories, `false` only when nothing is there (ENOENT).\n *\n * Pick the right check for the job:\n *   - `pathExistsAsync`      — anything at this path (file OR directory).\n *   - `fileExistsAsync`      — exists AND is a regular file.\n *   - `directoryExistsAsync` — exists AND is a directory.\n *\n * @example\n * if (await pathExistsAsync(\"/var/data\")) {\n *   // something is there — could be a file or a folder\n * }\n */\nexport async function pathExistsAsync(path: string): Promise<boolean> {\n  try {\n    await access(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport function pathExists(path: string): boolean {\n  try {\n    accessSync(path);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check whether a path exists AND is a regular file. Resolves `false` for a\n * directory — use `directoryExistsAsync` for folders, or `pathExistsAsync`\n * when the type does not matter.\n *\n * @example\n * if (await fileExistsAsync(\"/etc/config.json\")) {\n *   const raw = await readFile(\"/etc/config.json\", \"utf8\");\n * }\n */\nexport async function fileExistsAsync(path: string): Promise<boolean> {\n  try {\n    return (await stat(path)).isFile();\n  } catch {\n    return false;\n  }\n}\n\nexport function fileExists(path: string): boolean {\n  try {\n    return statSync(path).isFile();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check whether a path exists AND is a directory. Resolves `false` for a\n * regular file — use `fileExistsAsync` for files, or `pathExistsAsync` when\n * the type does not matter.\n *\n * @example\n * if (await directoryExistsAsync(\"/var/uploads\")) {\n *   const entries = await readdir(\"/var/uploads\");\n * }\n */\nexport async function directoryExistsAsync(path: string): Promise<boolean> {\n  try {\n    return (await stat(path)).isDirectory();\n  } catch {\n    return false;\n  }\n}\n\nexport function directoryExists(path: string): boolean {\n  try {\n    return statSync(path).isDirectory();\n  } catch {\n    return false;\n  }\n}\n","import { createHash } from \"node:crypto\";\nimport { createReadStream } from \"node:fs\";\nimport { readFile } from \"node:fs/promises\";\nimport { readFileSync } from \"node:fs\";\n\nexport type HashAlgorithm = \"sha256\" | \"sha1\" | \"md5\" | \"sha512\";\n\n/**\n * Compute a hex digest of a file's contents. Uses streaming for large\n * files so memory doesn't spike when hashing big assets.\n *\n * @param path - File to hash.\n * @param algorithm - Hash algorithm (default `sha256`).\n *\n * @example\n *   const fingerprint = await hashFile(\"./bundle.js\");\n *   const quick = await hashFile(\"./small.txt\", \"md5\");\n */\nexport function hashFileAsync(\n  path: string,\n  algorithm: HashAlgorithm = \"sha256\",\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const hash = createHash(algorithm);\n    const stream = createReadStream(path);\n    stream.on(\"data\", chunk => hash.update(chunk));\n    stream.on(\"end\", () => resolve(hash.digest(\"hex\")));\n    stream.on(\"error\", reject);\n  });\n}\n\nexport function hashFile(path: string, algorithm: HashAlgorithm = \"sha256\"): string {\n  return createHash(algorithm).update(readFileSync(path)).digest(\"hex\");\n}\n\n/**\n * Hash an in-memory string without touching disk. Convenient when the\n * caller already has the content loaded (e.g. file watcher diffing).\n */\nexport function hashString(content: string, algorithm: HashAlgorithm = \"sha256\"): string {\n  return createHash(algorithm).update(content).digest(\"hex\");\n}\n\n/**\n * Hash an arbitrary buffer.\n */\nexport function hashBuffer(\n  content: Buffer | Uint8Array,\n  algorithm: HashAlgorithm = \"sha256\",\n): string {\n  return createHash(algorithm).update(content).digest(\"hex\");\n}\n\n/**\n * Like `hashFileAsync` but reads the file in one go. Slightly faster for\n * small files; use the streaming variant for anything > ~1 MB.\n */\nexport async function hashFileSmallAsync(\n  path: string,\n  algorithm: HashAlgorithm = \"sha256\",\n): Promise<string> {\n  return createHash(algorithm).update(await readFile(path)).digest(\"hex\");\n}\n","import { readdir, stat } from \"node:fs/promises\";\nimport { readdirSync, statSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * List immediate children of a directory (files + subdirs), returning\n * full paths.\n */\nexport async function listAsync(directoryPath: string): Promise<string[]> {\n  const entries = await readdir(directoryPath);\n  return entries.map(entry => path.join(directoryPath, entry));\n}\n\nexport function list(directoryPath: string): string[] {\n  return readdirSync(directoryPath).map(entry => path.join(directoryPath, entry));\n}\n\n/**\n * List only files (not subdirectories) directly inside a directory.\n */\nexport async function listFilesAsync(directoryPath: string): Promise<string[]> {\n  const entries = await listAsync(directoryPath);\n  const checks = await Promise.all(\n    entries.map(async entry => ((await stat(entry)).isFile() ? entry : null)),\n  );\n  return checks.filter((entry): entry is string => entry !== null);\n}\n\nexport function listFiles(directoryPath: string): string[] {\n  return list(directoryPath).filter(entry => statSync(entry).isFile());\n}\n\n/**\n * List only subdirectories directly inside a directory.\n */\nexport async function listDirectoriesAsync(directoryPath: string): Promise<string[]> {\n  const entries = await listAsync(directoryPath);\n  const checks = await Promise.all(\n    entries.map(async entry => ((await stat(entry)).isDirectory() ? entry : null)),\n  );\n  return checks.filter((entry): entry is string => entry !== null);\n}\n\nexport function listDirectories(directoryPath: string): string[] {\n  return list(directoryPath).filter(entry => statSync(entry).isDirectory());\n}\n","import { readFile } from \"node:fs/promises\";\nimport { readFileSync } from \"node:fs\";\n\n/**\n * Read a file as UTF-8 text.\n */\nexport async function getFileAsync(path: string): Promise<string> {\n  return readFile(path, \"utf-8\");\n}\n\nexport function getFile(path: string): string {\n  return readFileSync(path, \"utf-8\");\n}\n\n/**\n * Read a JSON file and parse it.\n *\n * @throws if the file does not exist or contains invalid JSON.\n */\nexport async function getJsonFileAsync<T = unknown>(path: string): Promise<T> {\n  return JSON.parse(await getFileAsync(path)) as T;\n}\n\nexport function getJsonFile<T = unknown>(path: string): T {\n  return JSON.parse(getFile(path)) as T;\n}\n","import { rm, unlink as unlinkPromise } from \"node:fs/promises\";\nimport { rmSync, unlinkSync } from \"node:fs\";\n\n/**\n * Delete a single file. No error if the file doesn't exist.\n */\nexport async function unlinkAsync(path: string): Promise<void> {\n  try {\n    await unlinkPromise(path);\n  } catch (error: any) {\n    if (error?.code !== \"ENOENT\") throw error;\n  }\n}\n\nexport function unlink(path: string): void {\n  try {\n    unlinkSync(path);\n  } catch (error: any) {\n    if (error?.code !== \"ENOENT\") throw error;\n  }\n}\n\n/**\n * Recursively delete a directory and its contents. No error if missing.\n */\nexport async function removeDirectoryAsync(path: string): Promise<void> {\n  await rm(path, { recursive: true, force: true });\n}\n\nexport function removeDirectory(path: string): void {\n  rmSync(path, { recursive: true, force: true });\n}\n","import { rename as renamePromise } from \"node:fs/promises\";\nimport { renameSync } from \"node:fs\";\n\n/**\n * Rename / move a file or directory.\n */\nexport async function renameFileAsync(from: string, to: string): Promise<void> {\n  await renamePromise(from, to);\n}\n\nexport function renameFile(from: string, to: string): void {\n  renameSync(from, to);\n}\n","import { stat as statPromise } from \"node:fs/promises\";\nimport { statSync } from \"node:fs\";\n\n/**\n * Get last-modified time of a path. Returns a Date.\n *\n * @throws if the path does not exist.\n */\nexport async function lastModifiedAsync(path: string): Promise<Date> {\n  return (await statPromise(path)).mtime;\n}\n\nexport function lastModified(path: string): Date {\n  return statSync(path).mtime;\n}\n\n/**\n * Return raw fs.Stats for a path.\n */\nexport async function statsAsync(path: string) {\n  return statPromise(path);\n}\n\nexport function stats(path: string) {\n  return statSync(path);\n}\n","import { mkdir, writeFile } from \"node:fs/promises\";\nimport { mkdirSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Write a UTF-8 string to disk, creating any missing parent directories.\n */\nexport async function putFileAsync(filePath: string, content: string): Promise<void> {\n  await mkdir(path.dirname(filePath), { recursive: true });\n  await writeFile(filePath, content, \"utf-8\");\n}\n\nexport function putFile(filePath: string, content: string): void {\n  mkdirSync(path.dirname(filePath), { recursive: true });\n  writeFileSync(filePath, content, \"utf-8\");\n}\n\n/**\n * Write a JSON-serialisable value to disk (pretty-printed, 2-space indent).\n */\nexport async function putJsonFileAsync(filePath: string, value: unknown): Promise<void> {\n  await putFileAsync(filePath, JSON.stringify(value, null, 2));\n}\n\nexport function putJsonFile(filePath: string, value: unknown): void {\n  putFile(filePath, JSON.stringify(value, null, 2));\n}\n"],"mappings":"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"}

package/esm/atomic.d.mts

@@ -0,0 +1,22 @@
+//#region ../../@warlock.js/fs/src/atomic.d.ts
+/**
+ * Write a file atomically.
+ *
+ * Writes to a uniquely-named sibling temp file first, then renames it onto
+ * the target. Readers either see the old content or the complete new
+ * content — never a half-written file. If anything fails mid-write the
+ * temp file is cleaned up.
+ *
+ * Parent directories are created if missing.
+ *
+ * @example
+ *   await atomicWriteAsync("manifest.json", JSON.stringify(data));
+ */
+declare function atomicWriteAsync(filePath: string, content: string | Buffer): Promise<void>;
+/**
+ * Atomic write convenience for JSON values (pretty-printed, 2-space indent).
+ */
+declare function atomicWriteJsonAsync(filePath: string, value: unknown): Promise<void>;
+//#endregion
+export { atomicWriteAsync, atomicWriteJsonAsync };
+//# sourceMappingURL=atomic.d.mts.map

package/esm/atomic.mjs

@@ -0,0 +1,40 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+//#region ../../@warlock.js/fs/src/atomic.ts
+/**
+* Write a file atomically.
+*
+* Writes to a uniquely-named sibling temp file first, then renames it onto
+* the target. Readers either see the old content or the complete new
+* content — never a half-written file. If anything fails mid-write the
+* temp file is cleaned up.
+*
+* Parent directories are created if missing.
+*
+* @example
+*   await atomicWriteAsync("manifest.json", JSON.stringify(data));
+*/
+async function atomicWriteAsync(filePath, content) {
+	const dir = path.dirname(filePath);
+	await mkdir(dir, { recursive: true });
+	const tempPath = path.join(dir, `.${path.basename(filePath)}.${randomBytes(6).toString("hex")}.tmp`);
+	try {
+		await writeFile(tempPath, content);
+		await rename(tempPath, filePath);
+	} catch (error) {
+		await unlink(tempPath).catch(() => void 0);
+		throw error;
+	}
+}
+/**
+* Atomic write convenience for JSON values (pretty-printed, 2-space indent).
+*/
+async function atomicWriteJsonAsync(filePath, value) {
+	await atomicWriteAsync(filePath, JSON.stringify(value, null, 2));
+}
+
+//#endregion
+export { atomicWriteAsync, atomicWriteJsonAsync };
+//# sourceMappingURL=atomic.mjs.map

package/esm/atomic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.mjs","names":[],"sources":["../../../../../@warlock.js/fs/src/atomic.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport { mkdir, rename, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\n/**\n * Write a file atomically.\n *\n * Writes to a uniquely-named sibling temp file first, then renames it onto\n * the target. Readers either see the old content or the complete new\n * content — never a half-written file. If anything fails mid-write the\n * temp file is cleaned up.\n *\n * Parent directories are created if missing.\n *\n * @example\n *   await atomicWriteAsync(\"manifest.json\", JSON.stringify(data));\n */\nexport async function atomicWriteAsync(filePath: string, content: string | Buffer): Promise<void> {\n  const dir = path.dirname(filePath);\n  await mkdir(dir, { recursive: true });\n\n  // Random suffix so concurrent writers don't fight over the same temp file.\n  const tempPath = path.join(dir, `.${path.basename(filePath)}.${randomBytes(6).toString(\"hex\")}.tmp`);\n\n  try {\n    await writeFile(tempPath, content);\n    await rename(tempPath, filePath);\n  } catch (error) {\n    await unlink(tempPath).catch(() => undefined);\n    throw error;\n  }\n}\n\n/**\n * Atomic write convenience for JSON values (pretty-printed, 2-space indent).\n */\nexport async function atomicWriteJsonAsync(filePath: string, value: unknown): Promise<void> {\n  await atomicWriteAsync(filePath, JSON.stringify(value, null, 2));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,eAAsB,iBAAiB,UAAkB,SAAyC;CAChG,MAAM,MAAM,KAAK,QAAQ,QAAQ;CACjC,MAAM,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;CAGpC,MAAM,WAAW,KAAK,KAAK,KAAK,IAAI,KAAK,SAAS,QAAQ,EAAE,GAAG,YAAY,CAAC,EAAE,SAAS,KAAK,EAAE,KAAK;CAEnG,IAAI;EACF,MAAM,UAAU,UAAU,OAAO;EACjC,MAAM,OAAO,UAAU,QAAQ;CACjC,SAAS,OAAO;EACd,MAAM,OAAO,QAAQ,EAAE,YAAY,MAAS;EAC5C,MAAM;CACR;AACF;;;;AAKA,eAAsB,qBAAqB,UAAkB,OAA+B;CAC1F,MAAM,iBAAiB,UAAU,KAAK,UAAU,OAAO,MAAM,CAAC,CAAC;AACjE"}

package/esm/copy.d.mts

@@ -0,0 +1,14 @@
+//#region ../../@warlock.js/fs/src/copy.d.ts
+/**
+ * Copy a single file. Creates the destination's parent directory if needed.
+ */
+declare function copyFileAsync(source: string, destination: string): Promise<void>;
+declare function copyFile(source: string, destination: string): void;
+/**
+ * Recursively copy a directory.
+ */
+declare function copyDirectoryAsync(source: string, destination: string): Promise<void>;
+declare function copyDirectory(source: string, destination: string): void;
+//#endregion
+export { copyDirectory, copyDirectoryAsync, copyFile, copyFileAsync };
+//# sourceMappingURL=copy.d.mts.map

package/esm/copy.mjs

@@ -0,0 +1,29 @@
+import { copyFile, cp, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { copyFileSync, cpSync, mkdirSync } from "node:fs";
+
+//#region ../../@warlock.js/fs/src/copy.ts
+/**
+* Copy a single file. Creates the destination's parent directory if needed.
+*/
+async function copyFileAsync(source, destination) {
+	await mkdir(path.dirname(destination), { recursive: true });
+	await copyFile(source, destination);
+}
+function copyFile$1(source, destination) {
+	mkdirSync(path.dirname(destination), { recursive: true });
+	copyFileSync(source, destination);
+}
+/**
+* Recursively copy a directory.
+*/
+async function copyDirectoryAsync(source, destination) {
+	await cp(source, destination, { recursive: true });
+}
+function copyDirectory(source, destination) {
+	cpSync(source, destination, { recursive: true });
+}
+
+//#endregion
+export { copyDirectory, copyDirectoryAsync, copyFile$1 as copyFile, copyFileAsync };
+//# sourceMappingURL=copy.mjs.map

package/esm/copy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy.mjs","names":["copyFilePromise","copyFile"],"sources":["../../../../../@warlock.js/fs/src/copy.ts"],"sourcesContent":["import { cp, copyFile as copyFilePromise, mkdir } from \"node:fs/promises\";\nimport { copyFileSync, cpSync, mkdirSync } from \"node:fs\";\nimport path from \"node:path\";\n\n/**\n * Copy a single file. Creates the destination's parent directory if needed.\n */\nexport async function copyFileAsync(source: string, destination: string): Promise<void> {\n  await mkdir(path.dirname(destination), { recursive: true });\n  await copyFilePromise(source, destination);\n}\n\nexport function copyFile(source: string, destination: string): void {\n  mkdirSync(path.dirname(destination), { recursive: true });\n  copyFileSync(source, destination);\n}\n\n/**\n * Recursively copy a directory.\n */\nexport async function copyDirectoryAsync(source: string, destination: string): Promise<void> {\n  await cp(source, destination, { recursive: true });\n}\n\nexport function copyDirectory(source: string, destination: string): void {\n  cpSync(source, destination, { recursive: true });\n}\n"],"mappings":";;;;;;;;AAOA,eAAsB,cAAc,QAAgB,aAAoC;CACtF,MAAM,MAAM,KAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;CAC1D,MAAMA,SAAgB,QAAQ,WAAW;AAC3C;AAEA,SAAgBC,WAAS,QAAgB,aAA2B;CAClE,UAAU,KAAK,QAAQ,WAAW,GAAG,EAAE,WAAW,KAAK,CAAC;CACxD,aAAa,QAAQ,WAAW;AAClC;;;;AAKA,eAAsB,mBAAmB,QAAgB,aAAoC;CAC3F,MAAM,GAAG,QAAQ,aAAa,EAAE,WAAW,KAAK,CAAC;AACnD;AAEA,SAAgB,cAAc,QAAgB,aAA2B;CACvE,OAAO,QAAQ,aAAa,EAAE,WAAW,KAAK,CAAC;AACjD"}

package/esm/dirs.d.mts

@@ -0,0 +1,10 @@
+//#region ../../@warlock.js/fs/src/dirs.d.ts
+/**
+ * Ensure a directory exists (recursively creating parents).
+ * Idempotent — no error if the directory already exists.
+ */
+declare function ensureDirectoryAsync(path: string): Promise<void>;
+declare function ensureDirectory(path: string): void;
+//#endregion
+export { ensureDirectory, ensureDirectoryAsync };
+//# sourceMappingURL=dirs.d.mts.map