@socketsecurity/lib 3.5.0 → 4.0.1

package/dist/bin.js

@@ -1,8 +1,10 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var bin_exports = {};
 __export(bin_exports, {
@@ -25,47 +35,26 @@ __export(bin_exports, {
   findRealPnpm: () => findRealPnpm,
   findRealYarn: () => findRealYarn,
   isShadowBinPath: () => isShadowBinPath,
-  resolveBinPathSync: () => resolveBinPathSync,
+  resolveRealBinSync: () => resolveRealBinSync,
   which: () => which,
-  whichBin: () => whichBin,
-  whichBinSync: () => whichBinSync,
+  whichReal: () => whichReal,
+  whichRealSync: () => whichRealSync,
   whichSync: () => whichSync
 });
 module.exports = __toCommonJS(bin_exports);
-var import_home = require("#env/home");
-var import_windows = require("#env/windows");
-var import_xdg = require("#env/xdg");
-var import_platform = require("#constants/platform");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_home = require("./env/home");
+var import_windows = require("./env/windows");
+var import_xdg = require("./env/xdg");
+var import_platform = require("./constants/platform");
+var import_which = __toESM(require("./external/which"));
 var import_fs = require("./fs");
-var import_path = require("./path");
+var import_normalize = require("./paths/normalize");
 var import_spawn = require("./spawn");
-let _fs;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-let _path;
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-let _which;
-// @__NO_SIDE_EFFECTS__
-function getWhich() {
-  if (_which === void 0) {
-    _which = require("./external/which.js");
-  }
-  return _which;
-}
 // @__NO_SIDE_EFFECTS__
 async function execBin(binPath, args, options) {
-  const resolvedPath = (0, import_path.isPath)(binPath) ? /* @__PURE__ */ resolveBinPathSync(binPath) : await whichBin(binPath);
+  const resolvedPath = (0, import_normalize.isPath)(binPath) ? /* @__PURE__ */ resolveRealBinSync(binPath) : await whichReal(binPath);
   if (!resolvedPath) {
     const error = new Error(
       `Binary not found: ${binPath}
@@ -87,61 +76,20 @@ To resolve:
     ...options
   });
 }
-async function which(binName, options) {
-  return await (/* @__PURE__ */ getWhich())(binName, options);
-}
-function whichSync(binName, options) {
-  return (/* @__PURE__ */ getWhich()).sync(binName, options);
-}
-async function whichBin(binName, options) {
-  const which2 = /* @__PURE__ */ getWhich();
-  const opts = { nothrow: true, ...options };
-  const result = await which2(binName, opts);
-  if (opts?.all) {
-    const paths = Array.isArray(result) ? result : typeof result === "string" ? [result] : void 0;
-    return paths?.length ? paths.map((p) => /* @__PURE__ */ resolveBinPathSync(p)) : paths;
-  }
-  if (!result) {
-    return void 0;
-  }
-  return /* @__PURE__ */ resolveBinPathSync(result);
-}
-function whichBinSync(binName, options) {
-  const opts = { nothrow: true, ...options };
-  const result = whichSync(binName, opts);
-  if (opts.all) {
-    const paths = Array.isArray(result) ? result : typeof result === "string" ? [result] : void 0;
-    return paths?.length ? paths.map((p) => /* @__PURE__ */ resolveBinPathSync(p)) : paths;
-  }
-  if (!result) {
-    return void 0;
-  }
-  return /* @__PURE__ */ resolveBinPathSync(result);
-}
-function isShadowBinPath(dirPath) {
-  if (!dirPath) {
-    return false;
-  }
-  const normalized = dirPath.replace(/\\/g, "/");
-  return normalized.includes("node_modules/.bin");
-}
 function findRealBin(binName, commonPaths = []) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  const which2 = /* @__PURE__ */ getWhich();
   for (const binPath2 of commonPaths) {
-    if (fs?.existsSync(binPath2)) {
+    if (import_node_fs.default.existsSync(binPath2)) {
       return binPath2;
     }
   }
-  const binPath = which2?.sync(binName, { nothrow: true });
+  const binPath = import_which.default.sync(binName, { nothrow: true });
   if (binPath) {
-    const binDir = path?.dirname(binPath);
+    const binDir = import_node_path.default.dirname(binPath);
     if (isShadowBinPath(binDir)) {
-      const allPaths = which2?.sync(binName, { all: true, nothrow: true }) || [];
+      const allPaths = import_which.default.sync(binName, { all: true, nothrow: true }) || [];
       const pathsArray = Array.isArray(allPaths) ? allPaths : typeof allPaths === "string" ? [allPaths] : [];
       for (const altPath of pathsArray) {
-        const altDir = path?.dirname(altPath);
+        const altDir = import_node_path.default.dirname(altPath);
         if (!isShadowBinPath(altDir)) {
           return altPath;
         }
@@ -152,87 +100,88 @@ function findRealBin(binName, commonPaths = []) {
   return void 0;
 }
 function findRealNpm() {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  const nodeDir = path?.dirname(process.execPath);
-  const npmInNodeDir = path?.join(nodeDir, "npm");
-  if (fs?.existsSync(npmInNodeDir)) {
+  const nodeDir = import_node_path.default.dirname(process.execPath);
+  const npmInNodeDir = import_node_path.default.join(nodeDir, "npm");
+  if (import_node_fs.default.existsSync(npmInNodeDir)) {
     return npmInNodeDir;
   }
   const commonPaths = ["/usr/local/bin/npm", "/usr/bin/npm"];
   const result = findRealBin("npm", commonPaths);
-  if (result && fs?.existsSync(result)) {
+  if (result && import_node_fs.default.existsSync(result)) {
     return result;
   }
-  const npmPath = whichBinSync("npm", { nothrow: true });
-  if (npmPath && typeof npmPath === "string" && fs?.existsSync(npmPath)) {
+  const npmPath = whichRealSync("npm", { nothrow: true });
+  if (npmPath && typeof npmPath === "string" && import_node_fs.default.existsSync(npmPath)) {
     return npmPath;
   }
   return "npm";
 }
 function findRealPnpm() {
-  const path = /* @__PURE__ */ getPath();
   const commonPaths = import_platform.WIN32 ? [
     // Windows common paths.
-    path?.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
-    path?.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
-    path?.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
-    path?.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
+    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm.cmd"),
+    import_node_path.default.join((0, import_windows.getAppdata)(), "npm", "pnpm"),
+    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm.cmd"),
+    import_node_path.default.join((0, import_windows.getLocalappdata)(), "pnpm", "pnpm"),
     "C:\\Program Files\\nodejs\\pnpm.cmd",
     "C:\\Program Files\\nodejs\\pnpm"
   ].filter(Boolean) : [
     // Unix common paths.
     "/usr/local/bin/pnpm",
     "/usr/bin/pnpm",
-    path?.join(
+    import_node_path.default.join(
       (0, import_xdg.getXdgDataHome)() || `${(0, import_home.getHome)()}/.local/share`,
       "pnpm/pnpm"
     ),
-    path?.join((0, import_home.getHome)(), ".pnpm/pnpm")
+    import_node_path.default.join((0, import_home.getHome)(), ".pnpm/pnpm")
   ].filter(Boolean);
   return findRealBin("pnpm", commonPaths) ?? "";
 }
 function findRealYarn() {
-  const path = /* @__PURE__ */ getPath();
   const commonPaths = [
     "/usr/local/bin/yarn",
     "/usr/bin/yarn",
-    path?.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
-    path?.join(
+    import_node_path.default.join((0, import_home.getHome)(), ".yarn/bin/yarn"),
+    import_node_path.default.join(
       (0, import_home.getHome)(),
       ".config/yarn/global/node_modules/.bin/yarn"
     )
   ].filter(Boolean);
   return findRealBin("yarn", commonPaths) ?? "";
 }
+function isShadowBinPath(dirPath) {
+  if (!dirPath) {
+    return false;
+  }
+  const normalized = dirPath.replace(/\\/g, "/");
+  return normalized.includes("node_modules/.bin");
+}
 // @__NO_SIDE_EFFECTS__
-function resolveBinPathSync(binPath) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  if (!path?.isAbsolute(binPath)) {
+function resolveRealBinSync(binPath) {
+  if (!import_node_path.default.isAbsolute(binPath)) {
     try {
-      const resolved = whichBinSync(binPath);
+      const resolved = whichRealSync(binPath);
       if (resolved) {
         binPath = resolved;
       }
     } catch {
     }
   }
-  binPath = (0, import_path.normalizePath)(binPath);
+  binPath = (0, import_normalize.normalizePath)(binPath);
   if (binPath === ".") {
     return binPath;
   }
-  const ext = path?.extname(binPath);
+  const ext = import_node_path.default.extname(binPath);
   const extLowered = ext.toLowerCase();
-  const basename = path?.basename(binPath, ext);
+  const basename = import_node_path.default.basename(binPath, ext);
   const voltaIndex = basename === "node" ? -1 : /(?<=\/)\.volta\//i.exec(binPath)?.index ?? -1;
   if (voltaIndex !== -1) {
     const voltaPath = binPath.slice(0, voltaIndex);
-    const voltaToolsPath = path?.join(voltaPath, "tools");
-    const voltaImagePath = path?.join(voltaToolsPath, "image");
-    const voltaUserPath = path?.join(voltaToolsPath, "user");
+    const voltaToolsPath = import_node_path.default.join(voltaPath, "tools");
+    const voltaImagePath = import_node_path.default.join(voltaToolsPath, "image");
+    const voltaUserPath = import_node_path.default.join(voltaToolsPath, "user");
     const voltaPlatform = (0, import_fs.readJsonSync)(
-      path?.join(voltaUserPath, "platform.json"),
+      import_node_path.default.join(voltaUserPath, "platform.json"),
       { throws: false }
     );
     const voltaNodeVersion = voltaPlatform?.node?.runtime;
@@ -241,35 +190,35 @@ function resolveBinPathSync(binPath) {
     if (basename === "npm" || basename === "npx") {
       if (voltaNpmVersion) {
         const relCliPath = `bin/${basename}-cli.js`;
-        voltaBinPath = path?.join(
+        voltaBinPath = import_node_path.default.join(
           voltaImagePath,
           `npm/${voltaNpmVersion}/${relCliPath}`
         );
-        if (voltaNodeVersion && !fs?.existsSync(voltaBinPath)) {
-          voltaBinPath = path?.join(
+        if (voltaNodeVersion && !import_node_fs.default.existsSync(voltaBinPath)) {
+          voltaBinPath = import_node_path.default.join(
             voltaImagePath,
             `node/${voltaNodeVersion}/lib/node_modules/npm/${relCliPath}`
           );
-          if (!fs?.existsSync(voltaBinPath)) {
+          if (!import_node_fs.default.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
       }
     } else {
-      const voltaUserBinPath = path?.join(voltaUserPath, "bin");
+      const voltaUserBinPath = import_node_path.default.join(voltaUserPath, "bin");
       const binInfo = (0, import_fs.readJsonSync)(
-        path?.join(voltaUserBinPath, `${basename}.json`),
+        import_node_path.default.join(voltaUserBinPath, `${basename}.json`),
         { throws: false }
       );
       const binPackage = binInfo?.package;
       if (binPackage) {
-        voltaBinPath = path?.join(
+        voltaBinPath = import_node_path.default.join(
           voltaImagePath,
           `packages/${binPackage}/bin/${basename}`
         );
-        if (!fs?.existsSync(voltaBinPath)) {
+        if (!import_node_fs.default.existsSync(voltaBinPath)) {
           voltaBinPath = `${voltaBinPath}.cmd`;
-          if (!fs?.existsSync(voltaBinPath)) {
+          if (!import_node_fs.default.existsSync(voltaBinPath)) {
             voltaBinPath = "";
           }
         }
@@ -277,7 +226,7 @@ function resolveBinPathSync(binPath) {
     }
     if (voltaBinPath) {
       try {
-        return (0, import_path.normalizePath)(fs?.realpathSync.native(voltaBinPath));
+        return (0, import_normalize.normalizePath)(import_node_fs.default.realpathSync.native(voltaBinPath));
       } catch {
       }
       return voltaBinPath;
@@ -288,13 +237,13 @@ function resolveBinPathSync(binPath) {
     const isNpmOrNpx = basename === "npm" || basename === "npx";
     const isPnpmOrYarn = basename === "pnpm" || basename === "yarn";
     if (hasKnownExt && isNpmOrNpx) {
-      const quickPath = path?.join(
-        path?.dirname(binPath),
+      const quickPath = import_node_path.default.join(
+        import_node_path.default.dirname(binPath),
         `node_modules/npm/bin/${basename}-cli.js`
       );
-      if (fs?.existsSync(quickPath)) {
+      if (import_node_fs.default.existsSync(quickPath)) {
         try {
-          return fs?.realpathSync.native(quickPath);
+          return import_node_fs.default.realpathSync.native(quickPath);
         } catch {
         }
         return quickPath;
@@ -304,8 +253,8 @@ function resolveBinPathSync(binPath) {
     if (hasKnownExt && // Only parse shell scripts and batch files, not actual executables.
     // .exe files are already executables and don't need path resolution from wrapper scripts.
     extLowered !== ".exe" && // Check if file exists before attempting to read it to avoid ENOENT errors.
-    fs?.existsSync(binPath)) {
-      const source = fs?.readFileSync(binPath, "utf8");
+    import_node_fs.default.existsSync(binPath)) {
+      const source = import_node_fs.default.readFileSync(binPath, "utf8");
       if (isNpmOrNpx) {
         if (extLowered === ".cmd") {
           relPath = basename === "npm" ? /(?<="NPM_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "" : /(?<="NPX_CLI_JS=%~dp0\\).*(?=")/.exec(source)?.[0] || "";
@@ -352,7 +301,7 @@ function resolveBinPathSync(binPath) {
         relPath = /(?<="\$basedir\/).*(?=" $args\n)/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_path.normalizePath)(path?.resolve(path?.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
       }
     }
   } else {
@@ -364,10 +313,10 @@ function resolveBinPathSync(binPath) {
       if (binIndex !== -1) {
         const baseBinPath = binPath.slice(0, binIndex + "/.bin/pnpm".length);
         try {
-          const stats = fs?.statSync(baseBinPath);
+          const stats = import_node_fs.default.statSync(baseBinPath);
           if (stats.isFile()) {
-            binPath = (0, import_path.normalizePath)(baseBinPath);
-            hasNoExt = !path?.extname(binPath);
+            binPath = (0, import_normalize.normalizePath)(baseBinPath);
+            hasNoExt = !import_node_path.default.extname(binPath);
           }
         } catch {
         }
@@ -375,8 +324,8 @@ function resolveBinPathSync(binPath) {
     }
     if (hasNoExt && (isPnpmOrYarn || isNpmOrNpx) && // For extensionless files (Unix shell scripts), verify existence before reading.
     // This prevents ENOENT errors when the bin path doesn't exist.
-    fs?.existsSync(binPath)) {
-      const source = fs?.readFileSync(binPath, "utf8");
+    import_node_fs.default.existsSync(binPath)) {
+      const source = import_node_fs.default.readFileSync(binPath, "utf8");
       let relPath = "";
       if (isPnpmOrYarn) {
         relPath = /(?<="\$basedir\/)\.tools\/[^"]+(?="\s+"\$@")/.exec(source)?.[0] || "";
@@ -398,16 +347,62 @@ function resolveBinPathSync(binPath) {
         relPath = basename === "npm" ? /(?<=NPM_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "" : /(?<=NPX_CLI_JS="\$CLI_BASEDIR\/).*(?=")/.exec(source)?.[0] || "";
       }
       if (relPath) {
-        binPath = (0, import_path.normalizePath)(path?.resolve(path?.dirname(binPath), relPath));
+        binPath = (0, import_normalize.normalizePath)(import_node_path.default.resolve(import_node_path.default.dirname(binPath), relPath));
       }
     }
   }
   try {
-    const realPath = fs?.realpathSync.native(binPath);
-    return (0, import_path.normalizePath)(realPath);
+    const realPath = import_node_fs.default.realpathSync.native(binPath);
+    return (0, import_normalize.normalizePath)(realPath);
+  } catch {
+  }
+  return (0, import_normalize.normalizePath)(binPath);
+}
+async function which(binName, options) {
+  if ((0, import_normalize.isPath)(binName)) {
+    return binName;
+  }
+  try {
+    const result = await (0, import_which.default)(binName, options);
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function whichReal(binName, options) {
+  const opts = { nothrow: true, ...options };
+  const result = await (0, import_which.default)(binName, opts);
+  if (opts?.all) {
+    const paths = Array.isArray(result) ? result : typeof result === "string" ? [result] : void 0;
+    return paths?.length ? paths.map((p) => /* @__PURE__ */ resolveRealBinSync(p)) : paths;
+  }
+  if (!result) {
+    return void 0;
+  }
+  return /* @__PURE__ */ resolveRealBinSync(result);
+}
+function whichRealSync(binName, options) {
+  const opts = { nothrow: true, ...options };
+  const result = whichSync(binName, opts);
+  if (opts.all) {
+    const paths = Array.isArray(result) ? result : typeof result === "string" ? [result] : void 0;
+    return paths?.length ? paths.map((p) => /* @__PURE__ */ resolveRealBinSync(p)) : paths;
+  }
+  if (!result) {
+    return void 0;
+  }
+  return /* @__PURE__ */ resolveRealBinSync(result);
+}
+function whichSync(binName, options) {
+  if ((0, import_normalize.isPath)(binName)) {
+    return binName;
+  }
+  try {
+    const result = import_which.default.sync(binName, options);
+    return result;
   } catch {
+    return null;
   }
-  return (0, import_path.normalizePath)(binPath);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -417,9 +412,9 @@ function resolveBinPathSync(binPath) {
   findRealPnpm,
   findRealYarn,
   isShadowBinPath,
-  resolveBinPathSync,
+  resolveRealBinSync,
   which,
-  whichBin,
-  whichBinSync,
+  whichReal,
+  whichRealSync,
   whichSync
 });

package/dist/cacache.d.ts

@@ -33,7 +33,7 @@ export interface RemoveOptions {
 /**
  * Get the cacache module for cache operations.
  */
-export declare function getCacache(): any;
+export declare function getCacache(): import("./external/cacache").CacacheInstance;
 /**
  * Clear entries from the Socket shared cache.
  *
@@ -71,7 +71,10 @@ export declare function get(key: string, options?: GetOptions | undefined): Prom
  *
  * @throws {TypeError} If key contains wildcards (*)
  */
-export declare function put(key: string, data: string | Buffer, options?: PutOptions | undefined): Promise<any>;
+export declare function put(key: string, data: string | Buffer, options?: PutOptions | undefined): Promise<{
+    integrity: string;
+    size: number;
+}>;
 /**
  * Remove an entry from the Socket shared cache by key.
  *

package/dist/cacache.js

@@ -1,8 +1,10 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cacache_exports = {};
 __export(cacache_exports, {
@@ -28,9 +38,10 @@ __export(cacache_exports, {
   withTmp: () => withTmp
 });
 module.exports = __toCommonJS(cacache_exports);
-var import_paths = require("./paths");
+var import_cacache = __toESM(require("./external/cacache"));
+var import_socket = require("./paths/socket");
 function getCacache() {
-  return require("./external/cacache.js");
+  return import_cacache.default;
 }
 function patternToRegex(pattern) {
   const escaped = pattern.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&");
@@ -46,11 +57,11 @@ function matchesPattern(key, pattern) {
 }
 async function clear(options) {
   const opts = { __proto__: null, ...options };
-  const cacache = getCacache();
-  const cacheDir = (0, import_paths.getSocketCacacheDir)();
+  const cacache2 = getCacache();
+  const cacheDir = (0, import_socket.getSocketCacacheDir)();
   if (!opts.prefix) {
     try {
-      await cacache.rm.all(cacheDir);
+      await cacache2.rm.all(cacheDir);
       return;
     } catch (e) {
       if (e?.code !== "ENOTEMPTY") {
@@ -62,11 +73,11 @@ async function clear(options) {
   const hasWildcard = opts.prefix.includes("*");
   if (!hasWildcard) {
     let removed2 = 0;
-    const stream2 = cacache.ls.stream(cacheDir);
+    const stream2 = cacache2.ls.stream(cacheDir);
     for await (const entry of stream2) {
       if (entry.key.startsWith(opts.prefix)) {
         try {
-          await cacache.rm.entry(cacheDir, entry.key);
+          await cacache2.rm.entry(cacheDir, entry.key);
           removed2++;
         } catch {
         }
@@ -75,11 +86,11 @@ async function clear(options) {
     return removed2;
   }
   let removed = 0;
-  const stream = cacache.ls.stream(cacheDir);
+  const stream = cacache2.ls.stream(cacheDir);
   for await (const entry of stream) {
     if (matchesPattern(entry.key, opts.prefix)) {
       try {
-        await cacache.rm.entry(cacheDir, entry.key);
+        await cacache2.rm.entry(cacheDir, entry.key);
         removed++;
       } catch {
       }
@@ -93,8 +104,8 @@ async function get(key, options) {
       'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
     );
   }
-  const cacache = getCacache();
-  return await cacache.get((0, import_paths.getSocketCacacheDir)(), key, options);
+  const cacache2 = getCacache();
+  return await cacache2.get((0, import_socket.getSocketCacacheDir)(), key, options);
 }
 async function put(key, data, options) {
   if (key.includes("*")) {
@@ -102,8 +113,8 @@ async function put(key, data, options) {
       'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
     );
   }
-  const cacache = getCacache();
-  return await cacache.put((0, import_paths.getSocketCacacheDir)(), key, data, options);
+  const cacache2 = getCacache();
+  return await cacache2.put((0, import_socket.getSocketCacacheDir)(), key, data, options);
 }
 async function remove(key) {
   if (key.includes("*")) {
@@ -111,8 +122,8 @@ async function remove(key) {
       'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
     );
   }
-  const cacache = getCacache();
-  return await cacache.rm.entry((0, import_paths.getSocketCacacheDir)(), key);
+  const cacache2 = getCacache();
+  return await cacache2.rm.entry((0, import_socket.getSocketCacacheDir)(), key);
 }
 async function safeGet(key, options) {
   try {
@@ -122,9 +133,9 @@ async function safeGet(key, options) {
   }
 }
 async function withTmp(callback) {
-  const cacache = getCacache();
-  return await cacache.tmp.withTmp(
-    (0, import_paths.getSocketCacacheDir)(),
+  const cacache2 = getCacache();
+  return await cacache2.tmp.withTmp(
+    (0, import_socket.getSocketCacacheDir)(),
     {},
     callback
   );

package/dist/cache-with-ttl.js

@@ -114,7 +114,7 @@ function createTtlCache(options) {
         results.set(originalKey, entry.data);
       }
     }
-    const cacheDir = (await import("./paths")).getSocketCacacheDir();
+    const cacheDir = (await import("./paths/socket")).getSocketCacacheDir();
     const cacacheModule = await import("./cacache");
     const stream = cacacheModule.getCacache().ls.stream(cacheDir);
     for await (const cacheEntry of stream) {

package/dist/constants/agents.d.ts

@@ -1,7 +1,3 @@
-/**
- * Package manager agent constants.
- * Agent names, lockfile names, registry URLs, and configuration field names.
- */
 // Agent names.
 export declare const NPM = "npm";
 export declare const PNPM = "pnpm";