One TTL- and STM-backed store with the resident-byte budget, the entry-count bound, and the in-flight map that gives single-flight. Opaque: built with newSingleFlight and driven through resolveSingleFlight and the read-only views. Entries are wrapped in Weighted so the byte budget and the least-recently-used eviction have the weight and access stamp they need.

Build a store from its tunables (the TTL, the entry-count bound, and the resident-byte budget) and a value weigher. The TTL is converted to the cache library's monotonic TimeSpec and both bounds are clamped to at least one; the access clock starts at zero and the in-flight map empty.

The store's single-flight resolution: a fresh hit short-circuits; otherwise the caller leads one fetch (installing an in-flight marker) or follows an in-flight one. recordRequest records the hit/miss counter (or ignores it) and recordInsert refreshes the occupancy gauges from the post-insert CacheOccupancy after a leader insert (or ignores it), so each caller wires its own telemetry without the resolution logic knowing which store it serves. The first argument is a hook run on the leading thread at the single-flight claim → fetch-runner handoff, so a test can park a leader in that window deterministically; production callers pass pure ().

A hit bumps the entry's recency stamp before returning it, done in plain IO so recency is updated without writing the shared STM store (and so a hit never contends with a concurrent resolution). On a miss the fetch runs exactly once even under concurrent callers; a successful fetch is cached (subject to the TTL, the entry-count bound, and the resident-byte budget), a failed fetch caches nothing and its typed Left is handed to every waiter. A claimed slot is always eventually filled and de-registered even under an async exception in the claim → runner window: the claim commits under a mask and the run is handed straight to guardInFlight, which frees the slot on every exit and hands the orphaning error to any waiting follower (closing the single-flight orphan window); an async orphan re-resolves under restore (so the retried fetch and its parse stay cancellable, never masked, and the already-recorded miss is not counted again), a synchronous one re-raises (the fetch is total, so that arm is the invariant channel, not an outcome). A follower's own wait stays interruptible. The result is inserted before the slot is de-registered, so a caller arriving the instant the fetch returns becomes a follower rather than re-leading a redundant fetch.

Look up a key's stored value without fetching on a miss and without bumping recency: the store's read-only view, for inspection and tests. A Nothing is a miss or an expired entry; this never triggers a fetch and never collapses (use resolveSingleFlight on a serve path).

Look up a key's stored value like lookupStore, but bump the entry's recency on a hit: the serve path's read, so an entry read through it stays resident under the least-recently-used eviction rather than ageing out in insert order. It is the same lookup lookupStore runs, followed by the same touch a Hit takes, so a read here and a hit through resolveSingleFlight age an entry identically. Still never fetches and never collapses; a Nothing is a miss or an expired entry. The bump is a plain IORef write (never STM), so a read does not contend with a concurrent resolution.

A store's occupancy after a leader's insert: the held entry count and their summed resident weight, the values the occupancy and residency gauges report.