console-time | console.time & console.timeEnd polyfill | Command Line Interface library

This is a fairly standard situation when dealing with shared memory. Each thread accessing shared memory is allowed to keep its own copy (a "cache") for performance reasons until/unless some synchronization occurs, at which point the local copy must be reconciled with the shared copy.

The old storage specification talked about acquiring a storage mutex on every storage operation:

Whenever the properties of a localStorage attribute's Storage object are to be examined, returned, set, or deleted, whether as part of a direct property access, when checking for the presence of a property, during property enumeration, when determining the number of properties present, or as part of the execution of any of the methods or attributes defined on the Storage interface, the user agent must first obtain the storage mutex.

But that specification has been subsumed into the WHAT-WG "HTML" specification (which is about a lot more than HTML) in §11 ("Web Storage") and the requirement that every operation must acquire a storage mutex has been dropped. (I don't know why, but I would guess for performance reasons.) The current specification says:

Warning: The localStorage attribute provides access to shared state. This specification does not define the interaction with other browsing contexts in a multiprocess user agent, and authors are encouraged to assume that there is no locking mechanism.

The specification also doesn't discuss synchronization of storage across browsing contexts. That means implementations are free to optimize.

Looking into it with a modified version of your script, it looks like Firefox optimizes by having a local copy of local storage for each browsing context (tab) which it appears to update based on the storage event from other contexts (tabs). But if both tabs set the value (generating a storage event for the other tab) before the storage event from the other tab is processed, they both get and process the storage event from the other, updating with that value (the other tab's value), causing the behavior you describe.

Side note: The operation writing to persistent storage (what a third tab would see if you opened it after doing all this) also appears to be asynchronous, and the two tabs are in a race to see which one writes last (a race that is not always won by the last one writing to its local copy!).

This is effectively a large-scale version of what happens with shared memory between threads when there's only loose synchronization between the threads and no locking semantics, which the spec no longer requires.

Chrome would appear to be doing locking or similar.

The way the library you are using is written, it only outputs the resulting time to console, it does not return it. Because of that, while you can see it in debug console, you will always receive undefined from both .time() and .timeEnd() functions. This is also the same for browsers, and you can actually test it in your Javascript console.

However the library's code seems to be short, you can actually add the functionality. If you add return delta.toFixed(3); at the end of the .timeEnd() function (21st line in the index.js) you can get the result you want.

Short answer: it's not possible to set the connect timeout.

Long answer. Microsoft uses DuplexChannelFactory class for SDK Data Layer connection. This class has 7 different timeout settings: Explaination of different timeout types. The actual code, Microsoft creates an instance of Channel Factory class is below: