@socketsecurity/lib 4.3.0 → 5.0.0

package/dist/dlx/paths.js

@@ -0,0 +1,75 @@
+"use strict";
+/* Socket Lib - Built with esbuild */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paths_exports = {};
+__export(paths_exports, {
+  getDlxInstalledPackageDir: () => getDlxInstalledPackageDir,
+  getDlxPackageDir: () => getDlxPackageDir,
+  getDlxPackageJsonPath: () => getDlxPackageJsonPath,
+  getDlxPackageNodeModulesDir: () => getDlxPackageNodeModulesDir,
+  isInSocketDlx: () => isInSocketDlx
+});
+module.exports = __toCommonJS(paths_exports);
+var import_normalize = require("../paths/normalize");
+var import_socket = require("../paths/socket");
+let _path;
+// @__NO_SIDE_EFFECTS__
+function getPath() {
+  if (_path === void 0) {
+    _path = require("node:path");
+  }
+  return _path;
+}
+function getDlxInstalledPackageDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_normalize.normalizePath)(
+    path.join(getDlxPackageNodeModulesDir(packageName), packageName)
+  );
+}
+function getDlxPackageDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_normalize.normalizePath)(path.join((0, import_socket.getSocketDlxDir)(), packageName));
+}
+function getDlxPackageJsonPath(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_normalize.normalizePath)(
+    path.join(getDlxInstalledPackageDir(packageName), "package.json")
+  );
+}
+function getDlxPackageNodeModulesDir(packageName) {
+  const path = /* @__PURE__ */ getPath();
+  return (0, import_normalize.normalizePath)(path.join(getDlxPackageDir(packageName), "node_modules"));
+}
+function isInSocketDlx(filePath) {
+  if (!filePath) {
+    return false;
+  }
+  const path = /* @__PURE__ */ getPath();
+  const dlxDir = (0, import_socket.getSocketDlxDir)();
+  const absolutePath = (0, import_normalize.normalizePath)(path.resolve(filePath));
+  return absolutePath.startsWith(`${dlxDir}/`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDlxInstalledPackageDir,
+  getDlxPackageDir,
+  getDlxPackageJsonPath,
+  getDlxPackageNodeModulesDir,
+  isInSocketDlx
+});

package/dist/fs.d.ts

@@ -4,7 +4,7 @@
  */
 import type { Abortable } from 'events';
 import type { MakeDirectoryOptions, ObjectEncodingOptions, OpenMode, PathLike } from 'fs';
-import type { JsonReviver } from './json';
+import type { JsonReviver } from './json/types';
 import { type Remap } from './objects';
 /**
  * Supported text encodings for Node.js Buffers.
@@ -282,6 +282,13 @@ export declare function findUp(name: string | string[] | readonly string[], opti
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function findUpSync(name: string | string[] | readonly string[], options?: FindUpSyncOptions | undefined): string;
+/**
+ * Invalidate the cached allowed directories.
+ * Called automatically by the paths/rewire module when paths are overridden in tests.
+ *
+ * @internal Used for test rewiring
+ */
+export declare function invalidatePathCache(): void;
 /**
  * Check if a path is a directory asynchronously.
  * Returns `true` for directories, `false` for files or non-existent paths.
@@ -351,53 +358,37 @@ export declare function isDirEmptySync(dirname: PathLike, options?: IsDirEmptyOp
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isSymLinkSync(filepath: PathLike): boolean;
 /**
- * Result of file readability validation.
- * Contains lists of valid and invalid file paths.
- */
-export interface ValidateFilesResult {
-    /**
-     * File paths that passed validation and are readable.
-     */
-    validPaths: string[];
-    /**
-     * File paths that failed validation (unreadable, permission denied, or non-existent).
-     * Common with Yarn Berry PnP virtual filesystem, pnpm symlinks, or filesystem race conditions.
-     */
-    invalidPaths: string[];
-}
-/**
- * Validate that file paths are readable before processing.
- * Filters out files from glob results that cannot be accessed (common with
- * Yarn Berry PnP virtual filesystem, pnpm content-addressable store symlinks,
- * or filesystem race conditions in CI/CD environments).
+ * Normalize encoding string to canonical form.
+ * Handles common encodings inline for performance, delegates to slowCases for others.
  *
- * This defensive pattern prevents ENOENT errors when files exist in glob
- * results but are not accessible via standard filesystem operations.
+ * Based on Node.js internal/util.js normalizeEncoding implementation.
+ * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
  *
- * @param filepaths - Array of file paths to validate
- * @returns Object with `validPaths` (readable) and `invalidPaths` (unreadable)
+ * @param enc - Encoding to normalize (can be null/undefined)
+ * @returns Normalized encoding string, defaults to 'utf8'
  *
  * @example
  * ```ts
- * import { validateFiles } from '@socketsecurity/lib/fs'
- *
- * const files = ['package.json', '.pnp.cjs/virtual-file.json']
- * const { validPaths, invalidPaths } = validateFiles(files)
- *
- * console.log(`Valid: ${validPaths.length}`)
- * console.log(`Invalid: ${invalidPaths.length}`)
+ * normalizeEncoding('UTF-8') // Returns 'utf8'
+ * normalizeEncoding('binary') // Returns 'latin1'
+ * normalizeEncoding('ucs-2') // Returns 'utf16le'
+ * normalizeEncoding(null) // Returns 'utf8'
  * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function normalizeEncoding(enc: BufferEncoding | string | null | undefined): BufferEncoding;
+/**
+ * Move the "slow cases" to a separate function to make sure this function gets
+ * inlined properly. That prioritizes the common case.
  *
- * @example
- * ```ts
- * // Typical usage in Socket CLI commands
- * const packagePaths = await getPackageFilesForScan(targets)
- * const { validPaths } = validateFiles(packagePaths)
- * await sdk.uploadManifestFiles(orgSlug, validPaths)
- * ```
+ * Based on Node.js internal/util.js normalizeEncoding implementation.
+ * @see https://github.com/nodejs/node/blob/ae62b36d442b7bf987e85ae6e0df0f02cc1bb17f/lib/internal/util.js#L247-L310
+ *
+ * @param enc - Encoding to normalize
+ * @returns Normalized encoding string, defaults to 'utf8' for unknown encodings
  */
 /*@__NO_SIDE_EFFECTS__*/
-export declare function validateFiles(filepaths: string[] | readonly string[]): ValidateFilesResult;
+export declare function normalizeEncodingSlow(enc: string): BufferEncoding;
 /**
  * Read directory names asynchronously with filtering and sorting.
  * Returns only directory names (not files), with optional filtering for empty directories
@@ -554,7 +545,7 @@ export declare function readFileUtf8Sync(filepath: PathLike, options?: ReadFileO
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-export declare function readJson(filepath: PathLike, options?: ReadJsonOptions | string | undefined): Promise<import("./json").JsonValue>;
+export declare function readJson(filepath: PathLike, options?: ReadJsonOptions | string | undefined): Promise<import("./json/types").JsonValue>;
 /**
  * Read and parse a JSON file synchronously.
  * Reads the file as UTF-8 text and parses it as JSON.
@@ -584,14 +575,7 @@ export declare function readJson(filepath: PathLike, options?: ReadJsonOptions |
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-export declare function readJsonSync(filepath: PathLike, options?: ReadJsonOptions | string | undefined): import("./json").JsonValue;
-/**
- * Invalidate the cached allowed directories.
- * Called automatically by the paths/rewire module when paths are overridden in tests.
- *
- * @internal Used for test rewiring
- */
-export declare function invalidatePathCache(): void;
+export declare function readJsonSync(filepath: PathLike, options?: ReadJsonOptions | string | undefined): import("./json/types").JsonValue;
 /**
  * Safely delete a file or directory asynchronously with built-in protections.
  * Uses `del` for safer deletion that prevents removing cwd and above by default.
@@ -707,14 +691,15 @@ export declare function safeMkdirSync(path: PathLike, options?: MakeDirectoryOpt
  * Safely read a file asynchronously, returning undefined on error.
  * Useful when you want to attempt reading a file without handling errors explicitly.
  * Returns undefined for any error (file not found, permission denied, etc.).
+ * Defaults to UTF-8 encoding, returning a string unless encoding is explicitly set to null.
  *
  * @param filepath - Path to file
  * @param options - Read options including encoding and default value
- * @returns Promise resolving to file contents, or undefined on error
+ * @returns Promise resolving to file contents (string by default), or undefined on error
  *
  * @example
  * ```ts
- * // Try to read a file, get undefined if it doesn't exist
+ * // Try to read a file as UTF-8 string (default), get undefined if it doesn't exist
  * const content = await safeReadFile('./optional-config.txt')
  * if (content) {
  *   console.log('Config found:', content)
@@ -722,33 +707,48 @@ export declare function safeMkdirSync(path: PathLike, options?: MakeDirectoryOpt
  *
  * // Read with specific encoding
  * const data = await safeReadFile('./data.txt', { encoding: 'utf8' })
+ *
+ * // Read as Buffer by setting encoding to null
+ * const buffer = await safeReadFile('./binary.dat', { encoding: null })
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-export declare function safeReadFile(filepath: PathLike, options?: SafeReadOptions | undefined): Promise<NonSharedBuffer>;
+export declare function safeReadFile(filepath: PathLike, options: SafeReadOptions & {
+    encoding: null;
+}): Promise<Buffer | undefined>;
+/*@__NO_SIDE_EFFECTS__*/
+export declare function safeReadFile(filepath: PathLike, options?: SafeReadOptions | undefined): Promise<string | undefined>;
 /**
  * Safely read a file synchronously, returning undefined on error.
  * Useful when you want to attempt reading a file without handling errors explicitly.
  * Returns undefined for any error (file not found, permission denied, etc.).
+ * Defaults to UTF-8 encoding, returning a string unless encoding is explicitly set to null.
  *
  * @param filepath - Path to file
  * @param options - Read options including encoding and default value
- * @returns File contents, or undefined on error
+ * @returns File contents (string by default), or undefined on error
  *
  * @example
  * ```ts
- * // Try to read a config file
+ * // Try to read a config file as UTF-8 string (default)
  * const config = safeReadFileSync('./config.txt')
  * if (config) {
  *   console.log('Config loaded successfully')
  * }
  *
- * // Read binary file safely
+ * // Read with explicit encoding
+ * const data = safeReadFileSync('./data.txt', { encoding: 'utf8' })
+ *
+ * // Read binary file by setting encoding to null
  * const buffer = safeReadFileSync('./image.png', { encoding: null })
  * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
-export declare function safeReadFileSync(filepath: PathLike, options?: SafeReadOptions | undefined): string | NonSharedBuffer;
+export declare function safeReadFileSync(filepath: PathLike, options: SafeReadOptions & {
+    encoding: null;
+}): Buffer | undefined;
+/*@__NO_SIDE_EFFECTS__*/
+export declare function safeReadFileSync(filepath: PathLike, options?: SafeReadOptions | undefined): string | undefined;
 /**
  * Safely get file stats asynchronously, returning undefined on error.
  * Useful for checking file existence and properties without error handling.
@@ -812,6 +812,54 @@ export declare function safeStatsSync(filepath: PathLike, options?: ReadFileOpti
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function uniqueSync(filepath: PathLike): string;
+/**
+ * Result of file readability validation.
+ * Contains lists of valid and invalid file paths.
+ */
+export interface ValidateFilesResult {
+    /**
+     * File paths that passed validation and are readable.
+     */
+    validPaths: string[];
+    /**
+     * File paths that failed validation (unreadable, permission denied, or non-existent).
+     * Common with Yarn Berry PnP virtual filesystem, pnpm symlinks, or filesystem race conditions.
+     */
+    invalidPaths: string[];
+}
+/**
+ * Validate that file paths are readable before processing.
+ * Filters out files from glob results that cannot be accessed (common with
+ * Yarn Berry PnP virtual filesystem, pnpm content-addressable store symlinks,
+ * or filesystem race conditions in CI/CD environments).
+ *
+ * This defensive pattern prevents ENOENT errors when files exist in glob
+ * results but are not accessible via standard filesystem operations.
+ *
+ * @param filepaths - Array of file paths to validate
+ * @returns Object with `validPaths` (readable) and `invalidPaths` (unreadable)
+ *
+ * @example
+ * ```ts
+ * import { validateFiles } from '@socketsecurity/lib/fs'
+ *
+ * const files = ['package.json', '.pnp.cjs/virtual-file.json']
+ * const { validPaths, invalidPaths } = validateFiles(files)
+ *
+ * console.log(`Valid: ${validPaths.length}`)
+ * console.log(`Invalid: ${invalidPaths.length}`)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Typical usage in Socket CLI commands
+ * const packagePaths = await getPackageFilesForScan(targets)
+ * const { validPaths } = validateFiles(packagePaths)
+ * await sdk.uploadManifestFiles(orgSlug, validPaths)
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function validateFiles(filepaths: string[] | readonly string[]): ValidateFilesResult;
 /**
  * Write JSON content to a file asynchronously with formatting.
  * Stringifies the value with configurable indentation and line endings.

package/dist/fs.js

@@ -26,6 +26,8 @@ __export(fs_exports, {
   isDirEmptySync: () => isDirEmptySync,
   isDirSync: () => isDirSync,
   isSymLinkSync: () => isSymLinkSync,
+  normalizeEncoding: () => normalizeEncoding,
+  normalizeEncodingSlow: () => normalizeEncodingSlow,
   readDirNames: () => readDirNames,
   readDirNamesSync: () => readDirNamesSync,
   readFileBinary: () => readFileBinary,
@@ -52,7 +54,7 @@ var import_process = require("./constants/process");
 var import_arrays = require("./arrays");
 var import_del = require("./external/del");
 var import_globs = require("./globs");
-var import_json = require("./json");
+var import_parse = require("./json/parse");
 var import_objects = require("./objects");
 var import_normalize = require("./paths/normalize");
 var import_rewire = require("./paths/rewire");
@@ -66,6 +68,26 @@ const defaultRemoveOptions = (0, import_objects.objectFreeze)({
   recursive: true,
   retryDelay: 200
 });
+let _cachedAllowedDirs;
+function getAllowedDirectories() {
+  if (_cachedAllowedDirs === void 0) {
+    const path = /* @__PURE__ */ getPath();
+    _cachedAllowedDirs = [
+      path.resolve((0, import_socket.getOsTmpDir)()),
+      path.resolve((0, import_socket.getSocketCacacheDir)()),
+      path.resolve((0, import_socket.getSocketUserDir)())
+    ];
+  }
+  return _cachedAllowedDirs;
+}
+let _buffer;
+// @__NO_SIDE_EFFECTS__
+function getBuffer() {
+  if (_buffer === void 0) {
+    _buffer = require("node:buffer");
+  }
+  return _buffer;
+}
 let _fs;
 // @__NO_SIDE_EFFECTS__
 function getFs() {
@@ -201,6 +223,10 @@ function findUpSync(name, options) {
   }
   return void 0;
 }
+function invalidatePathCache() {
+  _cachedAllowedDirs = void 0;
+}
+(0, import_rewire.registerCacheInvalidation)(invalidatePathCache);
 // @__NO_SIDE_EFFECTS__
 async function isDir(filepath) {
   return !!(await /* @__PURE__ */ safeStats(filepath))?.isDirectory();
@@ -250,20 +276,75 @@ function isSymLinkSync(filepath) {
   return false;
 }
 // @__NO_SIDE_EFFECTS__
-function validateFiles(filepaths) {
-  const fs = /* @__PURE__ */ getFs();
-  const validPaths = [];
-  const invalidPaths = [];
-  const { R_OK } = fs.constants;
-  for (const filepath of filepaths) {
-    try {
-      fs.accessSync(filepath, R_OK);
-      validPaths.push(filepath);
-    } catch {
-      invalidPaths.push(filepath);
+function normalizeEncoding(enc) {
+  return enc == null || enc === "utf8" || enc === "utf-8" ? "utf8" : /* @__PURE__ */ normalizeEncodingSlow(enc);
+}
+// @__NO_SIDE_EFFECTS__
+function normalizeEncodingSlow(enc) {
+  const { length } = enc;
+  if (length === 4) {
+    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) {
+    if (enc === "ascii") {
+      return "ascii";
+    }
+    if (enc === "ucs-2") {
+      return "utf16le";
+    }
+    if (enc === "ASCII") {
+      return "ascii";
+    }
+    if (enc === "UCS-2") {
+      return "utf16le";
+    }
+    enc = enc.toLowerCase();
+    if (enc === "ascii") {
+      return "ascii";
+    }
+    if (enc === "ucs-2") {
+      return "utf16le";
+    }
+  } else if (length === 6) {
+    if (enc === "base64") {
+      return "base64";
+    }
+    if (enc === "latin1" || enc === "binary") {
+      return "latin1";
+    }
+    if (enc === "BASE64") {
+      return "base64";
+    }
+    if (enc === "LATIN1" || enc === "BINARY") {
+      return "latin1";
+    }
+    enc = enc.toLowerCase();
+    if (enc === "base64") {
+      return "base64";
+    }
+    if (enc === "latin1" || enc === "binary") {
+      return "latin1";
+    }
+  } else if (length === 7) {
+    if (enc === "utf16le" || enc === "UTF16LE" || enc.toLowerCase() === "utf16le") {
+      return "utf16le";
+    }
+  } else if (length === 8) {
+    if (enc === "utf-16le" || enc === "UTF-16LE" || enc.toLowerCase() === "utf-16le") {
+      return "utf16le";
+    }
+  } else if (length === 9) {
+    if (enc === "base64url" || enc === "BASE64URL" || enc.toLowerCase() === "base64url") {
+      return "base64url";
     }
   }
-  return { __proto__: null, validPaths, invalidPaths };
+  return "utf8";
 }
 // @__NO_SIDE_EFFECTS__
 async function readDirNames(dirname, options) {
@@ -350,8 +431,8 @@ async function readJson(filepath, options) {
   try {
     content = await fs.promises.readFile(filepath, {
       __proto__: null,
-      encoding: "utf8",
-      ...fsOptions
+      ...fsOptions,
+      encoding: "utf8"
     });
   } catch (e) {
     if (shouldThrow) {
@@ -374,7 +455,7 @@ Check file permissions or run with appropriate access.`,
     }
     return void 0;
   }
-  return (0, import_json.jsonParse)(content, {
+  return (0, import_parse.jsonParse)(content, {
     filepath: String(filepath),
     reviver,
     throws: shouldThrow
@@ -393,8 +474,8 @@ function readJsonSync(filepath, options) {
   try {
     content = fs.readFileSync(filepath, {
       __proto__: null,
-      encoding: "utf8",
-      ...fsOptions
+      ...fsOptions,
+      encoding: "utf8"
     });
   } catch (e) {
     if (shouldThrow) {
@@ -417,28 +498,12 @@ Check file permissions or run with appropriate access.`,
     }
     return void 0;
   }
-  return (0, import_json.jsonParse)(content, {
+  return (0, import_parse.jsonParse)(content, {
     filepath: String(filepath),
     reviver,
     throws: shouldThrow
   });
 }
-let _cachedAllowedDirs;
-function getAllowedDirectories() {
-  if (_cachedAllowedDirs === void 0) {
-    const path = /* @__PURE__ */ getPath();
-    _cachedAllowedDirs = [
-      path.resolve((0, import_socket.getOsTmpDir)()),
-      path.resolve((0, import_socket.getSocketCacacheDir)()),
-      path.resolve((0, import_socket.getSocketUserDir)())
-    ];
-  }
-  return _cachedAllowedDirs;
-}
-function invalidatePathCache() {
-  _cachedAllowedDirs = void 0;
-}
-(0, import_rewire.registerCacheInvalidation)(invalidatePathCache);
 async function safeDelete(filepath, options) {
   const opts = { __proto__: null, ...options };
   const patterns = (0, import_arrays.isArray)(filepath) ? filepath.map(import_normalize.pathLikeToString) : [(0, import_normalize.pathLikeToString)(filepath)];
@@ -523,29 +588,54 @@ function safeMkdirSync(path, options) {
 }
 // @__NO_SIDE_EFFECTS__
 async function safeReadFile(filepath, options) {
-  const opts = typeof options === "string" ? { encoding: options } : options;
+  const opts = typeof options === "string" ? { __proto__: null, encoding: options } : { __proto__: null, ...options };
+  const { defaultValue, ...rawReadOpts } = opts;
+  const readOpts = { __proto__: null, ...rawReadOpts };
+  const shouldReturnBuffer = readOpts.encoding === null;
+  const encoding = shouldReturnBuffer ? null : /* @__PURE__ */ normalizeEncoding(readOpts.encoding);
   const fs = /* @__PURE__ */ getFs();
   try {
     return await fs.promises.readFile(filepath, {
+      __proto__: null,
       signal: abortSignal,
-      ...opts
+      ...readOpts,
+      encoding
     });
   } catch {
   }
-  return void 0;
+  if (defaultValue === void 0) {
+    return void 0;
+  }
+  if (shouldReturnBuffer) {
+    const { Buffer: Buffer2 } = /* @__PURE__ */ getBuffer();
+    return Buffer2.isBuffer(defaultValue) ? defaultValue : void 0;
+  }
+  return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }
 // @__NO_SIDE_EFFECTS__
 function safeReadFileSync(filepath, options) {
-  const opts = typeof options === "string" ? { encoding: options } : options;
+  const opts = typeof options === "string" ? { __proto__: null, encoding: options } : { __proto__: null, ...options };
+  const { defaultValue, ...rawReadOpts } = opts;
+  const readOpts = { __proto__: null, ...rawReadOpts };
+  const shouldReturnBuffer = readOpts.encoding === null;
+  const encoding = shouldReturnBuffer ? null : /* @__PURE__ */ normalizeEncoding(readOpts.encoding);
   const fs = /* @__PURE__ */ getFs();
   try {
     return fs.readFileSync(filepath, {
       __proto__: null,
-      ...opts
+      ...readOpts,
+      encoding
     });
   } catch {
   }
-  return void 0;
+  if (defaultValue === void 0) {
+    return void 0;
+  }
+  if (shouldReturnBuffer) {
+    const { Buffer: Buffer2 } = /* @__PURE__ */ getBuffer();
+    return Buffer2.isBuffer(defaultValue) ? defaultValue : void 0;
+  }
+  return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }
 // @__NO_SIDE_EFFECTS__
 async function safeStats(filepath) {
@@ -589,6 +679,22 @@ function uniqueSync(filepath) {
   } while (fs.existsSync(uniquePath));
   return (0, import_normalize.normalizePath)(uniquePath);
 }
+// @__NO_SIDE_EFFECTS__
+function validateFiles(filepaths) {
+  const fs = /* @__PURE__ */ getFs();
+  const validPaths = [];
+  const invalidPaths = [];
+  const { R_OK } = fs.constants;
+  for (const filepath of filepaths) {
+    try {
+      fs.accessSync(filepath, R_OK);
+      validPaths.push(filepath);
+    } catch {
+      invalidPaths.push(filepath);
+    }
+  }
+  return { __proto__: null, validPaths, invalidPaths };
+}
 async function writeJson(filepath, jsonContent, options) {
   const opts = typeof options === "string" ? { encoding: options } : options;
   const { EOL, finalEOL, replacer, spaces, ...fsOptions } = {
@@ -638,6 +744,8 @@ function writeJsonSync(filepath, jsonContent, options) {
   isDirEmptySync,
   isDirSync,
   isSymLinkSync,
+  normalizeEncoding,
+  normalizeEncodingSlow,
   readDirNames,
   readDirNamesSync,
   readFileBinary,

package/dist/json/edit.d.ts

@@ -0,0 +1,16 @@
+import type { EditableJsonConstructor } from './types';
+/**
+ * Get the EditableJson class for JSON file manipulation.
+ *
+ * @example
+ * ```ts
+ * import { getEditableJsonClass } from '@socketsecurity/lib/json'
+ *
+ * const EditableJson = getEditableJsonClass<MyConfigType>()
+ * const config = await EditableJson.load('./config.json')
+ * config.update({ someField: 'newValue' })
+ * await config.save({ sort: true })
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function getEditableJsonClass<T = Record<string, unknown>>(): EditableJsonConstructor<T>;