Are There Hidden Dangers in Using for...in in JavaScript?

I wrote the algorithm below and asked an AI to evaluate my solution.

//TESTS:

console.log(firstNonRepeatingCharacter('abacabaz')) //c
console.log(firstNonRepeatingCharacter('aabbccdeefgghijj')) //d
console.log(firstNonRepeatingCharacter('abcdefgggghhhhhiiiii')) //a  
console.log(firstNonRepeatingCharacter('kkllmnnopqestuvxyzzz')) //m


function firstNonRepeatingCharacter(str){
  const charMap = {}
  let result = ''

  for(let i=0; i < str.length; i++) {
    if(!charMap[str[i]]) {
      charMap[str[i]] = 1
    } else {
      charMap[str[i]]++ 
    }
  }

  for(let char in charMap) { // <-- Problem detected by IA
    if(charMap[char] == 1) {
      result = char;
      return result;
    }
  }

  //console.log(charMap)
}

It gave me the following feedback about using for...in over an object:

"Your solution works, but there's a small conceptual issue: the order of keys when using for...in over the charMap object is not guaranteed across all JavaScript environments. As a result, it might not return the first non-repeating character in the original string order — only the first according to the key order of the object, which doesn't always match the string's order."

I've always done it this way, and it has always worked. All the test cases I tried passed.

How accurate is this information given by the AI? Could someone clarify this for me? Was the AI possibly mistaken?

Note: I'm not looking for an improved solution or suggestions. I've already learned how to solve this more efficiently. I’d just like clarification on the specific concern the AI raised.

Yes

The inconsistent iteration is basically not an issue. All relevant environments will use the order of keys that was codified by the specifications a decade ago: Does ES6 introduce a well-defined order of enumeration for object properties?

There might be a few environments where the iteration order will not be guaranteed but very few and very rare. Most notably writing embedded JavaScript code for a PDF document will use very old specifications. But, again, that is rare.

However, there is still an issue and it is exactly with the well-defined enumeration of properties. That goes in insertion order except for non-negative integers which will be ahead of everything else and sorted in ascending order.

const obj = {};

obj["foo"] = "hello";
obj["bar"] = "wolrd";

console.log(obj); // keys: first "foo" then "bar"

obj[2] = "this will be second";
obj[1] = "this will be first";

console.log(obj); // keys: first "1" then "2", then "foo", then "bar"

Therefore, since the algorithm relies on the property order in an object, if a string contains any numbers then the smallest of them will be reported as the "first" non-repeating character regardless of where it is found in the string:

console.log(firstNonRepeatingCharacter('abbccc9'))  //9
console.log(firstNonRepeatingCharacter('abbccc91')) //1


function firstNonRepeatingCharacter(str){
  const charMap = {}
  let result = ''

  for(let i=0; i < str.length; i++) {
    if(!charMap[str[i]]) {
      charMap[str[i]] = 1
    } else {
      charMap[str[i]]++ 
    }
  }

  for(let char in charMap) { // <-- Problem detected by IA
    if(charMap[char] == 1) {
      result = char;
      return result;
    }
  }

  //console.log(charMap)
}