@socketsecurity/lib 6.0.6 → 6.0.7

package/dist/fs/_internal.js

@@ -9,36 +9,36 @@ const require_paths_socket = require('../paths/socket.js');
 * @file Private state shared between `fs/safe` and `fs/path-cache`. The `_`
 *   prefix keeps this module out of the generated package.json `exports` map
 *   (the `dist/**\/_*` ignore pattern in
-*   `scripts/fix/generate-package-exports.mts` filters it out), so it is not
+*   `scripts/post-build/make-package-exports.mts` filters it out), so it is not
 *   part of the public surface — it exists only to give the two leaves above a
 *   common owner for the allowed-directory cache. The cache is invalidated by
 *   `invalidatePathCache()` in `fs/path-cache.ts` whenever paths are rewired in
 *   tests (`paths/rewire.ts` registers `invalidatePathCache` as one of its
 *   cache callbacks); `getAllowedDirectories()` rehydrates on next call.
 */
-let _cachedAllowedDirs;
+let cachedAllowedDirs;
 /**
 * Clear the cached allowed-directories list. Used by `invalidatePathCache()`
 * when test path rewiring changes any of the underlying paths so the next read
 * picks up the new resolved values.
 */
 function clearAllowedDirectories() {
-	_cachedAllowedDirs = void 0;
+	cachedAllowedDirs = void 0;
 }
 /**
 * Get resolved allowed directories for safe deletion with lazy caching. These
 * directories are resolved once and cached for the process lifetime.
 */
 function getAllowedDirectories() {
-	if (_cachedAllowedDirs === void 0) {
-		const path = /* @__PURE__ */ require_node_path.getNodePath();
-		_cachedAllowedDirs = [
+	if (cachedAllowedDirs === void 0) {
+		const path = require_node_path.getNodePath();
+		cachedAllowedDirs = [
 			path.resolve(require_paths_socket.getOsTmpDir()),
 			path.resolve(require_paths_socket.getSocketCacacheDir()),
 			path.resolve(require_paths_socket.getSocketUserDir())
 		];
 	}
-	return _cachedAllowedDirs;
+	return cachedAllowedDirs;
 }
 
 //#endregion

package/dist/fs/access.js

@@ -23,13 +23,12 @@ const require_smol_path = require('../smol/path.js');
 *
 * @returns True if the access check succeeds.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canAccess(path, mode) {
 	/* c8 ignore start - native access arm only on socket-btm smol binaries; getSmolPath() is undefined on stock Node. */
-	const smolAccess = (/* @__PURE__ */ require_smol_path.getSmolPath())?.access;
+	const smolAccess = require_smol_path.getSmolPath()?.access;
 	if (smolAccess) return smolAccess(path, mode);
 	/* c8 ignore stop */
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		fs.accessSync(path, mode);
 		return true;
@@ -40,23 +39,20 @@ function canAccess(path, mode) {
 /**
 * Can the process execute `path`? (`X_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canExecute(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.X_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.X_OK);
 }
 /**
 * Can the process read `path`? (`R_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canRead(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.R_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.R_OK);
 }
 /**
 * Can the process write `path`? (`W_OK`)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function canWrite(path) {
-	return /* @__PURE__ */ canAccess(path, (/* @__PURE__ */ require_node_fs.getNodeFs()).constants.W_OK);
+	return canAccess(path, require_node_fs.getNodeFs().constants.W_OK);
 }
 
 //#endregion

package/dist/fs/{path-cache.js → allowed-dirs-cache.js}

@@ -4,7 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_paths_rewire = require('../paths/rewire.js');
 const require_fs__internal = require('./_internal.js');
 
-//#region src/fs/path-cache.ts
+//#region src/fs/allowed-dirs-cache.ts
 /**
 * @file Cache-invalidation entry point for the allowed-directories list used by
 *   `safeDelete` / `safeDeleteSync`. Loading this module registers

package/dist/fs/encoding.js

@@ -23,9 +23,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *
 * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeEncoding(enc) {
-	return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : /* @__PURE__ */ normalizeEncodingSlow(enc);
+	return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : normalizeEncodingSlow(enc);
 }
 /**
 * Move the "slow cases" to a separate function to make sure this function gets
@@ -46,11 +45,10 @@ function normalizeEncoding(enc) {
 *
 * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
 */
-/*@__NO_SIDE_EFFECTS__*/
 function normalizeEncodingSlow(enc) {
 	const { length } = enc;
 	if (length === 4) {
-		if (enc === "ucs2" || enc === "UCS2") return "utf16le";
+		if (enc === "UCS2" || enc === "ucs2") return "utf16le";
 		if (enc.toLowerCase() === "ucs2") return "utf16le";
 	} else if (length === 3 && enc === "hex" || enc === "HEX" || enc.toLowerCase() === "hex") return "hex";
 	else if (length === 5) {
@@ -63,12 +61,12 @@ function normalizeEncodingSlow(enc) {
 		if (enc === "ucs-2") return "utf16le";
 	} else if (length === 6) {
 		if (enc === "base64") return "base64";
-		if (enc === "latin1" || enc === "binary") return "latin1";
+		if (enc === "binary" || enc === "latin1") return "latin1";
 		if (enc === "BASE64") return "base64";
-		if (enc === "LATIN1" || enc === "BINARY") return "latin1";
+		if (enc === "BINARY" || enc === "LATIN1") return "latin1";
 		enc = enc.toLowerCase();
 		if (enc === "base64") return "base64";
-		if (enc === "latin1" || enc === "binary") return "latin1";
+		if (enc === "binary" || enc === "latin1") return "latin1";
 	} else if (length === 7) {
 		if (enc === "utf16le" || enc === "UTF16LE" || enc.toLowerCase() === "utf16le") return "utf16le";
 	} else if (length === 8) {

package/dist/fs/{find-up.js → find.js}

@@ -12,7 +12,7 @@ const require_paths_walk = require('../paths/walk.js');
 let node_process = require("node:process");
 node_process = require_runtime.__toESM(node_process);
 
-//#region src/fs/find-up.ts
+//#region src/fs/find.ts
 /**
 * @file Walk parent directories to locate a file or directory by name. The
 *   traversal includes the filesystem root (or the caller-supplied `stopAt`
@@ -43,7 +43,6 @@ const abortSignal = require_process_abort.getAbortSignal();
 *
 * @returns Normalized absolute path if found, undefined otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function findUp(name, options) {
 	const { cwd = node_process.default.cwd(), signal = abortSignal } = {
 		__proto__: null,
@@ -55,16 +54,16 @@ async function findUp(name, options) {
 	};
 	if (onlyDirectories) onlyFiles = false;
 	if (onlyFiles) onlyDirectories = false;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const names = require_arrays_predicates.isArray(name) ? name : [name];
 	for (const dir of require_paths_walk.walkUp(cwd)) for (const n of names) {
 		if (signal?.aborted) return;
 		const thePath = path.join(dir, n);
 		try {
 			const stats = await fs.promises.stat(thePath);
-			if (!onlyDirectories && stats.isFile()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
-			if (!onlyFiles && stats.isDirectory()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+			if (!onlyDirectories && stats.isFile()) return require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return require_paths_normalize.normalizePath(thePath);
 		} catch {}
 	}
 }
@@ -94,7 +93,6 @@ async function findUp(name, options) {
 *
 * @returns Normalized absolute path if found, undefined otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function findUpSync(name, options) {
 	const { cwd = node_process.default.cwd(), stopAt } = {
 		__proto__: null,
@@ -106,22 +104,22 @@ function findUpSync(name, options) {
 	};
 	if (onlyDirectories) onlyFiles = false;
 	if (onlyFiles) onlyDirectories = false;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const names = require_arrays_predicates.isArray(name) ? name : [name];
 	/* c8 ignore start - native findUp arm only on socket-btm smol binaries; getSmolPath() is undefined on stock Node. */
-	const smolFindUp = (/* @__PURE__ */ require_smol_path.getSmolPath())?.findUp;
+	const smolFindUp = require_smol_path.getSmolPath()?.findUp;
 	if (smolFindUp && stopAt === void 0) {
 		const found = smolFindUp(path.resolve(cwd), names, { onlyDirectories });
-		return found === void 0 ? void 0 : /* @__PURE__ */ require_paths_normalize.normalizePath(found);
+		return found === void 0 ? void 0 : require_paths_normalize.normalizePath(found);
 	}
 	/* c8 ignore stop */
 	for (const dir of require_paths_walk.walkUp(cwd, { stopAt })) for (const n of names) {
 		const thePath = path.join(dir, n);
 		try {
 			const stats = fs.statSync(thePath);
-			if (!onlyDirectories && stats.isFile()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
-			if (!onlyFiles && stats.isDirectory()) return /* @__PURE__ */ require_paths_normalize.normalizePath(thePath);
+			if (!onlyDirectories && stats.isFile()) return require_paths_normalize.normalizePath(thePath);
+			if (!onlyFiles && stats.isDirectory()) return require_paths_normalize.normalizePath(thePath);
 		} catch {}
 	}
 }

package/dist/fs/inspect.js

@@ -29,9 +29,8 @@ const require_globs_matcher = require('../globs/matcher.js');
 *
 * @returns `true` if path is a directory, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function isDir(filepath) {
-	return !!(await /* @__PURE__ */ safeStat(filepath))?.isDirectory();
+	return !!(await safeStat(filepath))?.isDirectory();
 }
 /**
 * Check if a directory is empty synchronously. A directory is considered empty
@@ -52,18 +51,17 @@ async function isDir(filepath) {
 *
 * @returns `true` if directory is empty (or doesn't exist), `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isDirEmptySync(dirname, options) {
 	const { ignore = require_globs_defaults.defaultIgnore } = {
 		__proto__: null,
 		...options
 	};
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		const files = fs.readdirSync(dirname);
 		const { length } = files;
 		if (length === 0) return true;
-		const matcher = /* @__PURE__ */ require_globs_matcher.getGlobMatcher(ignore, { cwd: /* @__PURE__ */ require_paths__internal.pathLikeToString(dirname) });
+		const matcher = require_globs_matcher.getGlobMatcher(ignore, { cwd: require_paths__internal.pathLikeToString(dirname) });
 		let ignoredCount = 0;
 		for (let i = 0; i < length; i += 1) {
 			const file = files[i];
@@ -89,9 +87,8 @@ function isDirEmptySync(dirname, options) {
 *
 * @returns `true` if path is a directory, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isDirSync(filepath) {
-	return !!(/* @__PURE__ */ safeStatSync(filepath))?.isDirectory();
+	return !!safeStatSync(filepath)?.isDirectory();
 }
 /**
 * Check if a path is a symbolic link synchronously. Uses `lstat` to check the
@@ -108,9 +105,8 @@ function isDirSync(filepath) {
 *
 * @returns `true` if path is a symbolic link, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isSymlinkSync(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.lstatSync(filepath).isSymbolicLink();
 	} catch {}
@@ -135,9 +131,8 @@ function isSymlinkSync(filepath) {
 *
 * @returns Promise resolving to Stats object, or undefined on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function safeStat(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return await fs.promises.stat(filepath);
 	} catch {}
@@ -161,9 +156,8 @@ async function safeStat(filepath) {
 *
 * @returns Stats object, or undefined on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 function safeStatSync(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.statSync(filepath, {
 			__proto__: null,

package/dist/fs/read-dir.js

@@ -24,15 +24,14 @@ const require_fs_inspect = require('./inspect.js');
 *
 * @returns Array of directory names, optionally sorted
 */
-/*@__NO_SIDE_EFFECTS__*/
 function innerReadDirNames(dirents, dirname, options) {
 	const { ignore, includeEmpty = true, sort = true } = {
 		__proto__: null,
 		...options
 	};
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
-	const names = dirents.filter((d) => d.isDirectory() && (includeEmpty || !/* @__PURE__ */ require_fs_inspect.isDirEmptySync(path.join(dirname || d.parentPath, d.name), { ignore }))).map((d) => d.name);
-	return sort ? names.sort(require_sorts_natural.naturalCompare) : names;
+	const path = require_node_path.getNodePath();
+	const names = dirents.filter((d) => d.isDirectory() && (includeEmpty || !require_fs_inspect.isDirEmptySync(path.join(dirname || d.parentPath, d.name), { ignore }))).map((d) => d.name);
+	return sort ? names.toSorted(require_sorts_natural.naturalCompare) : names;
 }
 /**
 * Read directory names asynchronously with filtering and sorting. Returns only
@@ -56,11 +55,10 @@ function innerReadDirNames(dirents, dirname, options) {
 *
 * @returns Array of directory names, empty array on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readDirNames(dirname, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
-		return /* @__PURE__ */ innerReadDirNames(await fs.promises.readdir(dirname, {
+		return innerReadDirNames(await fs.promises.readdir(dirname, {
 			__proto__: null,
 			encoding: "utf8",
 			withFileTypes: true
@@ -90,11 +88,10 @@ async function readDirNames(dirname, options) {
 *
 * @returns Array of directory names, empty array on error
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readDirNamesSync(dirname, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	try {
-		return /* @__PURE__ */ innerReadDirNames(fs.readdirSync(dirname, {
+		return innerReadDirNames(fs.readdirSync(dirname, {
 			__proto__: null,
 			encoding: "utf8",
 			withFileTypes: true

package/dist/fs/read-file.js

@@ -34,10 +34,9 @@ const abortSignal = require_process_abort.getAbortSignal();
 *
 * @returns Promise resolving to Buffer containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readFileBinary(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return await (/* @__PURE__ */ require_node_fs.getNodeFs()).promises.readFile(filepath, {
+	return await require_node_fs.getNodeFs().promises.readFile(filepath, {
 		signal: abortSignal,
 		...opts,
 		encoding: void 0
@@ -61,10 +60,9 @@ async function readFileBinary(filepath, options) {
 *
 * @returns Buffer containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readFileBinarySync(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return (/* @__PURE__ */ require_node_fs.getNodeFs()).readFileSync(filepath, {
+	return require_node_fs.getNodeFs().readFileSync(filepath, {
 		...opts,
 		encoding: void 0
 	});
@@ -87,10 +85,9 @@ function readFileBinarySync(filepath, options) {
 *
 * @returns Promise resolving to string containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readFileUtf8(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return await (/* @__PURE__ */ require_node_fs.getNodeFs()).promises.readFile(filepath, {
+	return await require_node_fs.getNodeFs().promises.readFile(filepath, {
 		signal: abortSignal,
 		...opts,
 		encoding: "utf8"
@@ -115,15 +112,13 @@ async function readFileUtf8(filepath, options) {
 *
 * @returns String containing file contents
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readFileUtf8Sync(filepath, options) {
 	const opts = typeof options === "string" ? { encoding: options } : options;
-	return (/* @__PURE__ */ require_node_fs.getNodeFs()).readFileSync(filepath, {
+	return require_node_fs.getNodeFs().readFileSync(filepath, {
 		...opts,
 		encoding: "utf8"
 	});
 }
-/*@__NO_SIDE_EFFECTS__*/
 async function safeReadFile(filepath, options) {
 	const { defaultValue, ...rawReadOpts } = typeof options === "string" ? {
 		__proto__: null,
@@ -138,8 +133,8 @@ async function safeReadFile(filepath, options) {
 	};
 	const shouldReturnBuffer = readOpts.encoding === null;
 	/* c8 ignore next 3 */
-	const encoding = shouldReturnBuffer ? void 0 : /* @__PURE__ */ require_fs_encoding.normalizeEncoding(readOpts.encoding);
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const encoding = shouldReturnBuffer ? void 0 : require_fs_encoding.normalizeEncoding(readOpts.encoding);
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return await fs.promises.readFile(filepath, {
 			__proto__: null,
@@ -152,7 +147,6 @@ async function safeReadFile(filepath, options) {
 	if (shouldReturnBuffer) return require_primordials_buffer.BufferIsBuffer(defaultValue) ? defaultValue : void 0;
 	return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }
-/*@__NO_SIDE_EFFECTS__*/
 function safeReadFileSync(filepath, options) {
 	const { defaultValue, ...rawReadOpts } = typeof options === "string" ? {
 		__proto__: null,
@@ -167,8 +161,8 @@ function safeReadFileSync(filepath, options) {
 	};
 	const shouldReturnBuffer = readOpts.encoding === null;
 	/* c8 ignore next 3 */
-	const encoding = shouldReturnBuffer ? void 0 : /* @__PURE__ */ require_fs_encoding.normalizeEncoding(readOpts.encoding);
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const encoding = shouldReturnBuffer ? void 0 : require_fs_encoding.normalizeEncoding(readOpts.encoding);
+	const fs = require_node_fs.getNodeFs();
 	try {
 		return fs.readFileSync(filepath, {
 			__proto__: null,

package/dist/fs/read-json-cache.d.ts

@@ -5,10 +5,12 @@
  *
  *   - Stat-validated keys: a `stat()` call before serving a cache hit ensures the
  *     file hasn't changed (mtime + size mismatch ⇒ cache miss, re-read).
- *   - Defensive clone on hit: every hit returns `structuredClone(parsed)` so
- *     callers can mutate the returned object without poisoning the cache for
- *     the next reader. The clone cost is far less than re-read + re-parse for
- *     anything bigger than a trivial JSON document.
+ *   - Defensive clone on hit: every hit returns a JSON round-trip clone
+ *     (`JSON.parse(JSON.stringify(parsed))`) so callers can mutate the returned
+ *     object without poisoning the cache for the next reader. The clone cost is
+ *     far less than re-read + re-parse for anything bigger than a trivial JSON
+ *     document, and the round-trip is faster than `structuredClone` over the
+ *     JSON subset these values always belong to.
  *   - Reviver opt-out: when the caller passes a `reviver` function, we skip the
  *     cache. Function identity isn't safely hashable across boundaries, and the
  *     reviver can produce a different shape from the same bytes.

package/dist/fs/read-json-cache.js

@@ -6,6 +6,7 @@ const require_primordials_error = require('../primordials/error.js');
 const require_primordials_number = require('../primordials/number.js');
 const require_primordials_map_set = require('../primordials/map-set.js');
 const require_primordials_date = require('../primordials/date.js');
+const require_primordials_json = require('../primordials/json.js');
 let node_process = require("node:process");
 node_process = require_runtime.__toESM(node_process);
 
@@ -17,10 +18,12 @@ node_process = require_runtime.__toESM(node_process);
 *
 *   - Stat-validated keys: a `stat()` call before serving a cache hit ensures the
 *     file hasn't changed (mtime + size mismatch ⇒ cache miss, re-read).
-*   - Defensive clone on hit: every hit returns `structuredClone(parsed)` so
-*     callers can mutate the returned object without poisoning the cache for
-*     the next reader. The clone cost is far less than re-read + re-parse for
-*     anything bigger than a trivial JSON document.
+*   - Defensive clone on hit: every hit returns a JSON round-trip clone
+*     (`JSON.parse(JSON.stringify(parsed))`) so callers can mutate the returned
+*     object without poisoning the cache for the next reader. The clone cost is
+*     far less than re-read + re-parse for anything bigger than a trivial JSON
+*     document, and the round-trip is faster than `structuredClone` over the
+*     JSON subset these values always belong to.
 *   - Reviver opt-out: when the caller passes a `reviver` function, we skip the
 *     cache. Function identity isn't safely hashable across boundaries, and the
 *     reviver can produce a different shape from the same bytes.
@@ -85,7 +88,7 @@ function getCachedJson(key, ino, size, mtimeMs) {
 		return;
 	}
 	hits += 1;
-	return structuredClone(entry.parsed);
+	return require_primordials_json.JSONParse(require_primordials_json.JSONStringify(entry.parsed));
 }
 /**
 * Snapshot diagnostics. Useful for tests and for tooling that wants to log
@@ -131,7 +134,7 @@ function setCachedJson(key, ino, size, mtimeMs, parsed) {
 		ino,
 		size,
 		mtimeMs,
-		parsed: structuredClone(parsed),
+		parsed: require_primordials_json.JSONParse(require_primordials_json.JSONStringify(parsed)),
 		insertedAt: require_primordials_date.DateNow()
 	});
 }

package/dist/fs/read-json.js

@@ -49,7 +49,6 @@ const require_json_parse = require('../json/parse.js');
 * @returns Promise resolving to parsed JSON value, or undefined if throws is
 *   false and an error occurs.
 */
-/*@__NO_SIDE_EFFECTS__*/
 async function readJson(filepath, options) {
 	const { cache, reviver, throws, ...fsOptions } = {
 		__proto__: null,
@@ -57,7 +56,7 @@ async function readJson(filepath, options) {
 	};
 	const shouldThrow = throws === void 0 || !!throws;
 	const cacheEnabled = cache !== false && reviver === void 0;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const pathStr = String(filepath);
 	if (cacheEnabled) try {
 		const stat = await fs.promises.stat(filepath);
@@ -82,7 +81,7 @@ async function readJson(filepath, options) {
 		}
 		return;
 	}
-	const parsed = /* @__PURE__ */ require_json_parse.parseJson(content, {
+	const parsed = require_json_parse.parseJson(content, {
 		filepath: pathStr,
 		reviver,
 		throws: shouldThrow
@@ -123,7 +122,6 @@ async function readJson(filepath, options) {
 * @returns Parsed JSON value, or undefined if throws is false and an error
 *   occurs.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function readJsonSync(filepath, options) {
 	const { cache, reviver, throws, ...fsOptions } = {
 		__proto__: null,
@@ -131,7 +129,7 @@ function readJsonSync(filepath, options) {
 	};
 	const shouldThrow = throws === void 0 || !!throws;
 	const cacheEnabled = cache !== false && reviver === void 0;
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const pathStr = String(filepath);
 	if (cacheEnabled) try {
 		const stat = fs.statSync(filepath);
@@ -156,7 +154,7 @@ function readJsonSync(filepath, options) {
 		}
 		return;
 	}
-	const parsed = /* @__PURE__ */ require_json_parse.parseJson(content, {
+	const parsed = require_json_parse.parseJson(content, {
 		filepath: pathStr,
 		reviver,
 		throws: shouldThrow

package/dist/fs/resolve-module.js

@@ -22,7 +22,7 @@ function requireResolveFrom(fromDir, specifier, options) {
 		__proto__: null,
 		...options
 	};
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	const anchor = path.join(path.resolve(fromDir), "noop.js");
 	try {
 		return (0, node_module.createRequire)(anchor).resolve(specifier);

package/dist/fs/safe.d.ts

@@ -5,7 +5,7 @@
  *   true`. The mkdir helpers default to `recursive: true` and swallow `EEXIST`
  *   so concurrent callers don't race-condition each other.
  */
-import './path-cache';
+import './allowed-dirs-cache';
 import type { MakeDirectoryOptions, PathLike } from 'node:fs';
 import type { deleteAsync as deleteAsyncType, deleteSync as deleteSyncType } from '../external/del';
 import type { RemoveOptions } from './types';

package/dist/fs/safe.js

@@ -28,11 +28,10 @@ const defaultRemoveOptions = require_objects_mutate.objectFreeze({
 	recursive: true,
 	retryDelay: 200
 });
-let _del;
-/*@__NO_SIDE_EFFECTS__*/
+let delModule;
 function getDel() {
-	if (_del === void 0) _del = /*@__PURE__*/ require("../external/del");
-	return _del;
+	if (delModule === void 0) delModule = /*@__PURE__*/ require("../external/del");
+	return delModule;
 }
 /**
 * Safely delete a file or directory asynchronously with built-in protections.
@@ -75,11 +74,11 @@ async function safeDelete(filepath, options) {
 		__proto__: null,
 		...options
 	};
-	const patterns = require_arrays_predicates.isArray(filepath) ? filepath.map(require_paths__internal.pathLikeToString) : [/* @__PURE__ */ require_paths__internal.pathLikeToString(filepath)];
+	const patterns = require_arrays_predicates.isArray(filepath) ? filepath.map(require_paths__internal.pathLikeToString) : [require_paths__internal.pathLikeToString(filepath)];
 	/* c8 ignore start */
 	let shouldForce = opts.force !== false;
 	if (!shouldForce && patterns.length > 0) {
-		const path = /* @__PURE__ */ require_node_path.getNodePath();
+		const path = require_node_path.getNodePath();
 		const allowedDirs = require_fs__internal.getAllowedDirectories();
 		if (patterns.every((pattern) => {
 			const resolvedPath = path.resolve(pattern);
@@ -95,8 +94,8 @@ async function safeDelete(filepath, options) {
 	const maxRetries = opts.maxRetries ?? defaultRemoveOptions.maxRetries;
 	const retryDelay = opts.retryDelay ?? defaultRemoveOptions.retryDelay;
 	/* c8 ignore start - External del call */
-	const del = /* @__PURE__ */ getDel();
-	await /* @__PURE__ */ require_promises_retry.pRetry(async () => {
+	const del = getDel();
+	await require_promises_retry.pRetry(async () => {
 		await del.deleteAsync(patterns, {
 			dryRun: false,
 			force: shouldForce,
@@ -151,11 +150,11 @@ function safeDeleteSync(filepath, options) {
 		__proto__: null,
 		...options
 	};
-	const patterns = require_arrays_predicates.isArray(filepath) ? filepath.map(require_paths__internal.pathLikeToString) : [/* @__PURE__ */ require_paths__internal.pathLikeToString(filepath)];
+	const patterns = require_arrays_predicates.isArray(filepath) ? filepath.map(require_paths__internal.pathLikeToString) : [require_paths__internal.pathLikeToString(filepath)];
 	/* c8 ignore start */
 	let shouldForce = opts.force !== false;
 	if (!shouldForce && patterns.length > 0) {
-		const path = /* @__PURE__ */ require_node_path.getNodePath();
+		const path = require_node_path.getNodePath();
 		const allowedDirs = require_fs__internal.getAllowedDirectories();
 		if (patterns.every((pattern) => {
 			const resolvedPath = path.resolve(pattern);
@@ -171,7 +170,7 @@ function safeDeleteSync(filepath, options) {
 	const maxRetries = opts.maxRetries ?? defaultRemoveOptions.maxRetries;
 	const retryDelay = opts.retryDelay ?? defaultRemoveOptions.retryDelay;
 	/* c8 ignore start - External del call */
-	const del = /* @__PURE__ */ getDel();
+	const del = getDel();
 	let lastError;
 	let delay = retryDelay;
 	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
@@ -225,7 +224,7 @@ function safeDeleteSync(filepath, options) {
 * @returns Promise that resolves when directory is created or already exists
 */
 async function safeMkdir(path, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const opts = {
 		__proto__: null,
 		recursive: true,
@@ -269,7 +268,7 @@ async function safeMkdir(path, options) {
 *   settings.
 */
 function safeMkdirSync(path, options) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
+	const fs = require_node_fs.getNodeFs();
 	const opts = {
 		__proto__: null,
 		recursive: true,

package/dist/fs/unique.js

@@ -33,12 +33,11 @@ const require_node_path = require('../node/path.js');
 * @returns Normalized unique filepath (original if it doesn't exist, or with
 *   number suffix)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function uniqueSync(filepath) {
-	const fs = /* @__PURE__ */ require_node_fs.getNodeFs();
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const fs = require_node_fs.getNodeFs();
+	const path = require_node_path.getNodePath();
 	const filepathStr = String(filepath);
-	if (!fs.existsSync(filepathStr)) return /* @__PURE__ */ require_paths_normalize.normalizePath(filepathStr);
+	if (!fs.existsSync(filepathStr)) return require_paths_normalize.normalizePath(filepathStr);
 	const dirname = path.dirname(filepathStr);
 	const ext = path.extname(filepathStr);
 	const basename = path.basename(filepathStr, ext);
@@ -48,7 +47,7 @@ function uniqueSync(filepath) {
 		uniquePath = path.join(dirname, `${basename}-${counter}${ext}`);
 		counter++;
 	} while (fs.existsSync(uniquePath));
-	return /* @__PURE__ */ require_paths_normalize.normalizePath(uniquePath);
+	return require_paths_normalize.normalizePath(uniquePath);
 }
 
 //#endregion