The implementation is three closures: a called flag, a cached result, and the wrapper itself. After the first invocation, the wrapper returns the cached result without calling fn again, so subsequent calls are O(1) and side-effect-free. The early return result matches what callers expect: they get the same value every time, even if they forget that the work has already happened. This pairs nicely with module-level init functions, single-shot bootstrap routines, and event handlers like a click that should only ever fire once.

Async initialisers (DB pool, websocket connection, feature-flag fetch) get hit by parallel callers before the first call resolves, so the synchronous once would let the work run twice. Caching the in-flight Promise makes every concurrent caller share the same single fetch. The catch branch resets pending to null on failure so the next caller can retry instead of being stuck with a rejected Promise forever. This is the only correct shape for lazy bootstrap functions in modern apps; without the catch reset, one transient failure poisons the cache for the lifetime of the module.

Tests, hot-module-reload, and feature-flag flips all want to clear the memoised result so the next call runs fresh. Exposing a reset method on the wrapper keeps the API ergonomic without forcing the caller to recreate the wrapper. The trade-off is that reset is now part of the public surface, so any caller can clear the cache at any time. Reach for this version inside test suites or anywhere a dependency injection layer needs to swap out the cached value (for example clearing a memoised tenant config when the tenant changes).