@socketsecurity/lib 4.2.0 → 4.4.0

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.4.0](https://github.com/SocketDev/socket-lib/releases/tag/v4.4.0) - 2025-11-25
+
+### Added
+
+- **fs**: Exported `normalizeEncoding()` function for robust encoding string normalization
+  - Handles case-insensitive encoding names (e.g., 'UTF-8', 'utf8', 'UTF8')
+  - Supports encoding aliases (e.g., 'binary' → 'latin1', 'ucs-2' → 'utf16le')
+  - Fast-path optimization for common encodings
+  - Defaults to 'utf8' for invalid or null encodings
+  - Export: `@socketsecurity/lib/fs`
+
+### Fixed
+
+- **fs**: `safeReadFile()` and `safeReadFileSync()` type signatures and encoding handling
+  - Corrected type overloads: `encoding: null` → `Buffer | undefined`, no encoding → `string | undefined` (UTF-8 default)
+  - Fixed implementation to properly handle `encoding: null` for Buffer returns
+
+- **suppress-warnings**: `withSuppressedWarnings()` now properly restores warning state
+  - Fixed state restoration to only remove warning types that were added by the function
+  - Prevents accidental removal of warnings that were already suppressed
+  - Ensures correct cleanup behavior when warning types are nested or reused
+
+## [4.3.0](https://github.com/SocketDev/socket-lib/releases/tag/v4.3.0) - 2025-11-20
+
+### Added
+
+- **globs**: New `glob()` and `globSync()` wrapper functions for fast-glob
+  - Provides convenient wrappers around fast-glob with normalized options
+  - Maintains consistent API with existing glob functionality
+  - Export: `@socketsecurity/lib/globs`
+
 ## [4.1.0](https://github.com/SocketDev/socket-lib/releases/tag/v4.1.0) - 2025-11-17
 
 ### Added

package/README.md

@@ -2,7 +2,7 @@
 
 [![Socket Badge](https://socket.dev/api/badge/npm/package/@socketsecurity/lib)](https://socket.dev/npm/package/@socketsecurity/lib)
 [![CI](https://github.com/SocketDev/socket-lib/actions/workflows/ci.yml/badge.svg)](https://github.com/SocketDev/socket-lib/actions/workflows/ci.yml)
-![Coverage](https://img.shields.io/badge/coverage-83.95%25-brightgreen)
+![Coverage](https://img.shields.io/badge/coverage-83.78%25-brightgreen)
 
 [![Follow @SocketSecurity](https://img.shields.io/twitter/follow/SocketSecurity?style=social)](https://twitter.com/SocketSecurity)
 [![Follow @socket.dev on Bluesky](https://img.shields.io/badge/Follow-@socket.dev-1DA1F2?style=social&logo=bluesky)](https://bsky.app/profile/socket.dev)

package/dist/external/fast-glob.js

@@ -5723,7 +5723,11 @@ var require_out4 = __commonJS({
 
 // src/external/fast-glob.js
 var fastGlob = require_out4();
-module.exports = fastGlob.globStream ? { globStream: fastGlob.globStream } : fastGlob;
+module.exports = fastGlob.globStream ? {
+  glob: fastGlob,
+  globStream: fastGlob.globStream,
+  globSync: fastGlob.sync
+} : fastGlob;
 /*! Bundled license information:
 
 is-extglob/index.js:

package/dist/fs.d.ts

@@ -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
@@ -585,13 +576,6 @@ 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;
 /**
  * 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,
@@ -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) {
@@ -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) {
@@ -423,22 +504,6 @@ Check file permissions or run with appropriate access.`,
     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/globs.d.ts

@@ -44,3 +44,15 @@ export declare function getGlobMatcher(glob: Pattern | Pattern[], options?: {
     nocase?: boolean;
     ignore?: string[];
 }): (path: string) => boolean;
+/**
+ * Asynchronously find files matching glob patterns.
+ * Wrapper around fast-glob.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function glob(patterns: Pattern | Pattern[], options?: FastGlobOptions): Promise<string[]>;
+/**
+ * Synchronously find files matching glob patterns.
+ * Wrapper around fast-glob.sync.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function globSync(patterns: Pattern | Pattern[], options?: FastGlobOptions): string[];

package/dist/globs.js

@@ -31,7 +31,9 @@ var globs_exports = {};
 __export(globs_exports, {
   defaultIgnore: () => defaultIgnore,
   getGlobMatcher: () => getGlobMatcher,
-  globStreamLicenses: () => globStreamLicenses
+  glob: () => glob,
+  globStreamLicenses: () => globStreamLicenses,
+  globSync: () => globSync
 });
 module.exports = __toCommonJS(globs_exports);
 var fastGlob = __toESM(require("./external/fast-glob.js"));
@@ -107,8 +109,8 @@ function globStreamLicenses(dirname, options) {
 }
 const matcherCache = /* @__PURE__ */ new Map();
 // @__NO_SIDE_EFFECTS__
-function getGlobMatcher(glob, options) {
-  const patterns = Array.isArray(glob) ? glob : [glob];
+function getGlobMatcher(glob2, options) {
+  const patterns = Array.isArray(glob2) ? glob2 : [glob2];
   const key = JSON.stringify({ patterns, options });
   let matcher = matcherCache.get(key);
   if (matcher) {
@@ -129,9 +131,19 @@ function getGlobMatcher(glob, options) {
   matcherCache.set(key, matcher);
   return matcher;
 }
+// @__NO_SIDE_EFFECTS__
+function glob(patterns, options) {
+  return fastGlob.glob(patterns, options);
+}
+// @__NO_SIDE_EFFECTS__
+function globSync(patterns, options) {
+  return fastGlob.globSync(patterns, options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   defaultIgnore,
   getGlobMatcher,
-  globStreamLicenses
+  glob,
+  globStreamLicenses,
+  globSync
 });

package/dist/objects.d.ts

@@ -55,33 +55,6 @@ type SortedObject<T> = {
     [key: PropertyKey]: T;
 };
 export type { GetterDefObj, LazyGetterStats, ConstantsObjectOptions, Remap };
-/**
- * Create a lazy getter function that memoizes its result.
- *
- * The returned function will only call the getter once, caching the result
- * for subsequent calls. This is useful for expensive computations or
- * operations that should only happen when needed.
- *
- * @param name - The property key name for the getter (used for debugging and stats)
- * @param getter - Function that computes the value on first access
- * @param stats - Optional stats object to track initialization
- * @returns A memoized getter function
- *
- * @example
- * ```ts
- * const stats = { initialized: new Set() }
- * const getLargeData = createLazyGetter('data', () => {
- *   console.log('Computing expensive data...')
- *   return { large: 'dataset' }
- * }, stats)
- *
- * getLargeData() // Logs "Computing expensive data..." and returns data
- * getLargeData() // Returns cached data without logging
- * console.log(stats.initialized.has('data')) // true
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): () => T;
 /**
  * Create a frozen constants object with lazy getters and internal properties.
  *
@@ -120,6 +93,33 @@ export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T,
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function createConstantsObject(props: object, options_?: ConstantsObjectOptions | undefined): Readonly<object>;
+/**
+ * Create a lazy getter function that memoizes its result.
+ *
+ * The returned function will only call the getter once, caching the result
+ * for subsequent calls. This is useful for expensive computations or
+ * operations that should only happen when needed.
+ *
+ * @param name - The property key name for the getter (used for debugging and stats)
+ * @param getter - Function that computes the value on first access
+ * @param stats - Optional stats object to track initialization
+ * @returns A memoized getter function
+ *
+ * @example
+ * ```ts
+ * const stats = { initialized: new Set() }
+ * const getLargeData = createLazyGetter('data', () => {
+ *   console.log('Computing expensive data...')
+ *   return { large: 'dataset' }
+ * }, stats)
+ *
+ * getLargeData() // Logs "Computing expensive data..." and returns data
+ * getLargeData() // Returns cached data without logging
+ * console.log(stats.initialized.has('data')) // true
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function createLazyGetter<T>(name: PropertyKey, getter: () => T, stats?: LazyGetterStats | undefined): () => T;
 /**
  * Define a getter property on an object.
  *
@@ -393,6 +393,40 @@ export declare const objectAssign: {
     <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
     (target: object, ...sources: any[]): any;
 };
+/**
+ * Deep merge source object into target object.
+ *
+ * Recursively merges properties from `source` into `target`. Arrays in source
+ * completely replace arrays in target (no element-wise merging). Objects are
+ * merged recursively. Includes infinite loop detection for safety.
+ *
+ * @param target - The object to merge into (will be modified)
+ * @param source - The object to merge from
+ * @returns The modified target object
+ *
+ * @example
+ * ```ts
+ * const target = { a: { x: 1 }, b: [1, 2] }
+ * const source = { a: { y: 2 }, b: [3, 4, 5], c: 3 }
+ * merge(target, source)
+ * // { a: { x: 1, y: 2 }, b: [3, 4, 5], c: 3 }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Arrays are replaced, not merged
+ * merge({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
+ *
+ * // Deep object merging
+ * merge(
+ *   { config: { api: 'v1', timeout: 1000 } },
+ *   { config: { api: 'v2', retries: 3 } }
+ * )
+ * // { config: { api: 'v2', timeout: 1000, retries: 3 } }
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function merge<T extends object, U extends object>(target: T, source: U): T & U;
 /**
  * Get all own property entries (key-value pairs) from an object.
  *
@@ -438,40 +472,6 @@ export declare const objectFreeze: {
     }, U extends string | number | bigint | symbol | boolean>(o: T): Readonly<T>;
     <T>(o: T): Readonly<T>;
 };
-/**
- * Deep merge source object into target object.
- *
- * Recursively merges properties from `source` into `target`. Arrays in source
- * completely replace arrays in target (no element-wise merging). Objects are
- * merged recursively. Includes infinite loop detection for safety.
- *
- * @param target - The object to merge into (will be modified)
- * @param source - The object to merge from
- * @returns The modified target object
- *
- * @example
- * ```ts
- * const target = { a: { x: 1 }, b: [1, 2] }
- * const source = { a: { y: 2 }, b: [3, 4, 5], c: 3 }
- * merge(target, source)
- * // { a: { x: 1, y: 2 }, b: [3, 4, 5], c: 3 }
- * ```
- *
- * @example
- * ```ts
- * // Arrays are replaced, not merged
- * merge({ arr: [1, 2] }, { arr: [3] }) // { arr: [3] }
- *
- * // Deep object merging
- * merge(
- *   { config: { api: 'v1', timeout: 1000 } },
- *   { config: { api: 'v2', retries: 3 } }
- * )
- * // { config: { api: 'v2', timeout: 1000, retries: 3 } }
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function merge<T extends object, U extends object>(target: T, source: U): T & U;
 /**
  * Convert an object to a new object with sorted keys.
  *

package/dist/objects.js

@@ -56,20 +56,6 @@ const ObjectPrototype = Object.prototype;
 const ObjectSetPrototypeOf = Object.setPrototypeOf;
 const ReflectOwnKeys = Reflect.ownKeys;
 // @__NO_SIDE_EFFECTS__
-function createLazyGetter(name, getter, stats) {
-  let lazyValue = import_core.UNDEFINED_TOKEN;
-  const { [name]: lazyGetter } = {
-    [name]() {
-      if (lazyValue === import_core.UNDEFINED_TOKEN) {
-        stats?.initialized?.add(name);
-        lazyValue = getter();
-      }
-      return lazyValue;
-    }
-  };
-  return lazyGetter;
-}
-// @__NO_SIDE_EFFECTS__
 function createConstantsObject(props, options_) {
   const options = { __proto__: null, ...options_ };
   const attributes = ObjectFreeze({
@@ -123,6 +109,20 @@ function createConstantsObject(props, options_) {
   }
   return ObjectFreeze(object);
 }
+// @__NO_SIDE_EFFECTS__
+function createLazyGetter(name, getter, stats) {
+  let lazyValue = import_core.UNDEFINED_TOKEN;
+  const { [name]: lazyGetter } = {
+    [name]() {
+      if (lazyValue === import_core.UNDEFINED_TOKEN) {
+        stats?.initialized?.add(name);
+        lazyValue = getter();
+      }
+      return lazyValue;
+    }
+  };
+  return lazyGetter;
+}
 function defineGetter(object, propKey, getter) {
   ObjectDefineProperty(object, propKey, {
     get: getter,
@@ -209,22 +209,6 @@ function isObjectObject(value) {
 }
 const objectAssign = Object.assign;
 // @__NO_SIDE_EFFECTS__
-function objectEntries(obj) {
-  if (obj === null || obj === void 0) {
-    return [];
-  }
-  const keys = ReflectOwnKeys(obj);
-  const { length } = keys;
-  const entries = Array(length);
-  const record = obj;
-  for (let i = 0; i < length; i += 1) {
-    const key = keys[i];
-    entries[i] = [key, record[key]];
-  }
-  return entries;
-}
-const objectFreeze = Object.freeze;
-// @__NO_SIDE_EFFECTS__
 function merge(target, source) {
   if (!/* @__PURE__ */ isObject(target) || !/* @__PURE__ */ isObject(source)) {
     return target;
@@ -266,6 +250,22 @@ function merge(target, source) {
   return target;
 }
 // @__NO_SIDE_EFFECTS__
+function objectEntries(obj) {
+  if (obj === null || obj === void 0) {
+    return [];
+  }
+  const keys = ReflectOwnKeys(obj);
+  const { length } = keys;
+  const entries = Array(length);
+  const record = obj;
+  for (let i = 0; i < length; i += 1) {
+    const key = keys[i];
+    entries[i] = [key, record[key]];
+  }
+  return entries;
+}
+const objectFreeze = Object.freeze;
+// @__NO_SIDE_EFFECTS__
 function toSortedObject(obj) {
   return /* @__PURE__ */ toSortedObjectFromEntries(/* @__PURE__ */ objectEntries(obj));
 }

package/dist/package-default-node-range.d.ts

@@ -1,2 +1,3 @@
+/* c8 ignore next - External semver call */
 declare const packageDefaultNodeRange: string;
 export { packageDefaultNodeRange };

package/dist/package-extensions.js

@@ -36,6 +36,7 @@ var yarnPkgExtensions = __toESM(require("./external/@yarnpkg/extensions.js"));
 const { freeze: ObjectFreeze } = Object;
 const packageExtensions = ObjectFreeze(
   [
+    /* c8 ignore next - External @yarnpkg/extensions data */
     ...yarnPkgExtensions.packageExtensions,
     [
       "@yarnpkg/extensions@>=1.1.0",

package/dist/promises.d.ts

@@ -208,25 +208,6 @@ export declare function normalizeIterationOptions(options?: number | IterationOp
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function normalizeRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
-/**
- * Resolve retry options from various input formats.
- *
- * Converts shorthand and partial options into a base configuration that can be
- * further normalized. This is an internal helper for option processing.
- *
- * @param options - Retry count as number, or partial options object, or undefined
- * @returns Resolved retry options with defaults for basic properties
- *
- * @example
- * resolveRetryOptions(3)
- * // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }
- *
- * @example
- * resolveRetryOptions({ retries: 5, maxTimeout: 5000 })
- * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;
 /**
  * Execute an async function for each array element with concurrency control.
  *
@@ -455,3 +436,22 @@ export declare function pFilterChunk<T>(chunks: T[][], callbackFn: (value: T) =>
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function pRetry<T>(callbackFn: (...args: unknown[]) => Promise<T>, options?: number | RetryOptions | undefined): Promise<T | undefined>;
+/**
+ * Resolve retry options from various input formats.
+ *
+ * Converts shorthand and partial options into a base configuration that can be
+ * further normalized. This is an internal helper for option processing.
+ *
+ * @param options - Retry count as number, or partial options object, or undefined
+ * @returns Resolved retry options with defaults for basic properties
+ *
+ * @example
+ * resolveRetryOptions(3)
+ * // => { retries: 3, minTimeout: 200, maxTimeout: 10000, factor: 2 }
+ *
+ * @example
+ * resolveRetryOptions({ retries: 5, maxTimeout: 5000 })
+ * // => { retries: 5, minTimeout: 200, maxTimeout: 5000, factor: 2 }
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function resolveRetryOptions(options?: number | RetryOptions | undefined): RetryOptions;

package/dist/promises.js

@@ -101,20 +101,6 @@ function normalizeRetryOptions(options) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function resolveRetryOptions(options) {
-  const defaults = {
-    __proto__: null,
-    retries: 0,
-    baseDelayMs: 200,
-    maxDelayMs: 1e4,
-    backoffFactor: 2
-  };
-  if (typeof options === "number") {
-    return { ...defaults, retries: options };
-  }
-  return options ? { ...defaults, ...options } : defaults;
-}
-// @__NO_SIDE_EFFECTS__
 async function pEach(array, callbackFn, options) {
   const iterOpts = /* @__PURE__ */ normalizeIterationOptions(options);
   const { concurrency, retries, signal } = iterOpts;
@@ -259,6 +245,20 @@ async function pRetry(callbackFn, options) {
   }
   return void 0;
 }
+// @__NO_SIDE_EFFECTS__
+function resolveRetryOptions(options) {
+  const defaults = {
+    __proto__: null,
+    retries: 0,
+    baseDelayMs: 200,
+    maxDelayMs: 1e4,
+    backoffFactor: 2
+  };
+  if (typeof options === "number") {
+    return { ...defaults, retries: options };
+  }
+  return options ? { ...defaults, ...options } : defaults;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   normalizeIterationOptions,

package/dist/sorts.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Compare semantic versions.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function compareSemver(a: string, b: string): number;
+/**
+ * Simple string comparison.
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function compareStr(a: string, b: string): number;
 /**
  * Compare two strings using locale-aware comparison.
  */
@@ -15,14 +25,4 @@ type FastSortFunction = ReturnType<typeof import('fast-sort').createNewSortInsta
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function naturalSorter<T>(arrayToSort: T[]): ReturnType<FastSortFunction>;
-/**
- * Simple string comparison.
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function compareStr(a: string, b: string): number;
-/**
- * Compare semantic versions.
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function compareSemver(a: string, b: string): number;
 export {};

package/dist/sorts.js

@@ -38,6 +38,25 @@ __export(sorts_exports, {
 module.exports = __toCommonJS(sorts_exports);
 var fastSort = __toESM(require("./external/fast-sort.js"));
 var semver = __toESM(require("./external/semver.js"));
+// @__NO_SIDE_EFFECTS__
+function compareSemver(a, b) {
+  const validA = semver.valid(a);
+  const validB = semver.valid(b);
+  if (!validA && !validB) {
+    return 0;
+  }
+  if (!validA) {
+    return -1;
+  }
+  if (!validB) {
+    return 1;
+  }
+  return semver.compare(a, b);
+}
+// @__NO_SIDE_EFFECTS__
+function compareStr(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 let _localeCompare;
 // @__NO_SIDE_EFFECTS__
 function localeCompare(x, y) {
@@ -77,25 +96,6 @@ function naturalSorter(arrayToSort) {
   }
   return _naturalSorter(arrayToSort);
 }
-// @__NO_SIDE_EFFECTS__
-function compareStr(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-// @__NO_SIDE_EFFECTS__
-function compareSemver(a, b) {
-  const validA = semver.valid(a);
-  const validB = semver.valid(b);
-  if (!validA && !validB) {
-    return 0;
-  }
-  if (!validA) {
-    return -1;
-  }
-  if (!validB) {
-    return 1;
-  }
-  return semver.compare(a, b);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compareSemver,

package/dist/strings.d.ts

@@ -85,6 +85,41 @@ export declare function applyLinePrefix(str: string, options?: ApplyLinePrefixOp
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function camelToKebab(str: string): string;
+/**
+ * Center text within a given width.
+ *
+ * Adds spaces before and after the text to center it within the specified width.
+ * Distributes padding evenly on both sides. When the padding is odd, the extra
+ * space is added to the right side. Strips ANSI codes before calculating text
+ * length to ensure accurate centering of colored text.
+ *
+ * If the text is already wider than or equal to the target width, returns the
+ * original text unchanged (no truncation occurs).
+ *
+ * @param text - The text to center (may include ANSI codes)
+ * @param width - The target width in columns
+ * @returns The centered text with padding
+ *
+ * @example
+ * ```ts
+ * centerText('hello', 11)
+ * // Returns: '   hello   ' (3 spaces on each side)
+ *
+ * centerText('hi', 10)
+ * // Returns: '    hi    ' (4 spaces on each side)
+ *
+ * centerText('odd', 8)
+ * // Returns: '  odd   ' (2 left, 3 right)
+ *
+ * centerText('\x1b[31mred\x1b[0m', 7)
+ * // Returns: '  \x1b[31mred\x1b[0m  ' (ANSI codes preserved, 'red' centered)
+ *
+ * centerText('too long text', 5)
+ * // Returns: 'too long text' (no truncation, returned as-is)
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function centerText(text: string, width: number): string;
 export interface IndentStringOptions {
     /**
      * Number of spaces to indent each line.
@@ -181,6 +216,33 @@ export declare function isBlankString(value: unknown): value is BlankString;
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function isNonEmptyString(value: unknown): value is Exclude<string, EmptyString>;
+/**
+ * Repeat a string a specified number of times.
+ *
+ * Creates a new string by repeating the input string `count` times.
+ * Returns an empty string if count is 0 or negative.
+ *
+ * @param str - The string to repeat
+ * @param count - The number of times to repeat the string
+ * @returns The repeated string, or empty string if count <= 0
+ *
+ * @example
+ * ```ts
+ * repeatString('hello', 3)
+ * // Returns: 'hellohellohello'
+ *
+ * repeatString('x', 5)
+ * // Returns: 'xxxxx'
+ *
+ * repeatString('hello', 0)
+ * // Returns: ''
+ *
+ * repeatString('hello', -1)
+ * // Returns: ''
+ * ```
+ */
+/*@__NO_SIDE_EFFECTS__*/
+export declare function repeatString(str: string, count: number): string;
 export interface SearchOptions {
     /**
      * The position in the string to begin searching from.
@@ -252,6 +314,7 @@ export declare function search(str: string, regexp: RegExp, options?: SearchOpti
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function stripBom(str: string): string;
+/* c8 ignore stop */
 /**
  * Get the visual width of a string in terminal columns.
  *
@@ -403,66 +466,3 @@ export declare function toKebabCase(str: string): string;
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function trimNewlines(str: string): string;
-/**
- * Repeat a string n times.
- *
- * Creates a new string by repeating the input string the specified number of times.
- * Returns an empty string if count is zero or negative. This is a simple wrapper
- * around `String.prototype.repeat()` with guard for non-positive counts.
- *
- * @param str - The string to repeat
- * @param count - The number of times to repeat the string
- * @returns The repeated string, or empty string if count <= 0
- *
- * @example
- * ```ts
- * repeatString('hello', 3)
- * // Returns: 'hellohellohello'
- *
- * repeatString('x', 5)
- * // Returns: 'xxxxx'
- *
- * repeatString('hello', 0)
- * // Returns: ''
- *
- * repeatString('hello', -1)
- * // Returns: ''
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function repeatString(str: string, count: number): string;
-/**
- * Center text within a given width.
- *
- * Adds spaces before and after the text to center it within the specified width.
- * Distributes padding evenly on both sides. When the padding is odd, the extra
- * space is added to the right side. Strips ANSI codes before calculating text
- * length to ensure accurate centering of colored text.
- *
- * If the text is already wider than or equal to the target width, returns the
- * original text unchanged (no truncation occurs).
- *
- * @param text - The text to center (may include ANSI codes)
- * @param width - The target width in columns
- * @returns The centered text with padding
- *
- * @example
- * ```ts
- * centerText('hello', 11)
- * // Returns: '   hello   ' (3 spaces on each side)
- *
- * centerText('hi', 10)
- * // Returns: '    hi    ' (4 spaces on each side)
- *
- * centerText('odd', 8)
- * // Returns: '  odd   ' (2 left, 3 right)
- *
- * centerText('\x1b[31mred\x1b[0m', 7)
- * // Returns: '  \x1b[31mred\x1b[0m  ' (ANSI codes preserved, 'red' centered)
- *
- * centerText('too long text', 5)
- * // Returns: 'too long text' (no truncation, returned as-is)
- * ```
- */
-/*@__NO_SIDE_EFFECTS__*/
-export declare function centerText(text: string, width: number): string;

package/dist/strings.js

@@ -92,6 +92,17 @@ function camelToKebab(str) {
   return result;
 }
 // @__NO_SIDE_EFFECTS__
+function centerText(text, width) {
+  const textLength = (0, import_ansi.stripAnsi)(text).length;
+  if (textLength >= width) {
+    return text;
+  }
+  const padding = width - textLength;
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+}
+// @__NO_SIDE_EFFECTS__
 function indentString(str, options) {
   const { count = 1 } = { __proto__: null, ...options };
   return str.replace(/^(?!\s*$)/gm, " ".repeat(count));
@@ -105,6 +116,13 @@ function isNonEmptyString(value) {
   return typeof value === "string" && value.length > 0;
 }
 // @__NO_SIDE_EFFECTS__
+function repeatString(str, count) {
+  if (count <= 0) {
+    return "";
+  }
+  return str.repeat(count);
+}
+// @__NO_SIDE_EFFECTS__
 function search(str, regexp, options) {
   const { fromIndex = 0 } = { __proto__: null, ...options };
   const { length } = str;
@@ -215,24 +233,6 @@ function trimNewlines(str) {
   }
   return start === 0 && end === length ? str : str.slice(start, end);
 }
-// @__NO_SIDE_EFFECTS__
-function repeatString(str, count) {
-  if (count <= 0) {
-    return "";
-  }
-  return str.repeat(count);
-}
-// @__NO_SIDE_EFFECTS__
-function centerText(text, width) {
-  const textLength = (0, import_ansi.stripAnsi)(text).length;
-  if (textLength >= width) {
-    return text;
-  }
-  const padding = width - textLength;
-  const leftPad = Math.floor(padding / 2);
-  const rightPad = padding - leftPad;
-  return " ".repeat(leftPad) + text + " ".repeat(rightPad);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ansiRegex,

package/dist/suppress-warnings.js

@@ -82,11 +82,15 @@ function restoreWarnings() {
   }
 }
 async function withSuppressedWarnings(warningType, callback) {
+  const wasAlreadySuppressed = suppressedWarnings.has(warningType);
   const original = process.emitWarning;
   suppressWarningType(warningType);
   try {
     return await callback();
   } finally {
+    if (!wasAlreadySuppressed) {
+      suppressedWarnings.delete(warningType);
+    }
     process.emitWarning = original;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socketsecurity/lib",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "packageManager": "pnpm@10.22.0",
   "license": "MIT",
   "description": "Core utilities and infrastructure for Socket.dev security tools",
@@ -690,7 +690,7 @@
     "@socketregistry/is-unicode-supported": "1.0.5",
     "@socketregistry/packageurl-js": "1.3.5",
     "@socketregistry/yocto-spinner": "1.0.25",
-    "@socketsecurity/lib-stable": "npm:@socketsecurity/lib@4.1.0",
+    "@socketsecurity/lib-stable": "npm:@socketsecurity/lib@4.3.0",
     "@types/node": "24.9.2",
     "@typescript/native-preview": "7.0.0-dev.20250920.1",
     "@vitest/coverage-v8": "4.0.3",