---
title: 'Which Element Caused This Blog''s <em>CLS</em>'
tags:
  - web-performance
  - debugging
  - blogging
  - browser
  - css
published: true
date: 2026-11-16 22:15:00
description: 'Two causes found through the shifted elements recorded alongside CLS values: a decorative element that follows the cursor and was counted as a layout shift, and a home page list that pushed the footer down while the overall p75 stayed at 0.000. Both were confirmed with field data and lab reproductions.'
art:
  undraw: design-components
---

## Table of Contents

## Seven Days Counted by Shifted Element

On October 24, a week after I started [collecting Core Web Vitals myself](/2026/10/cwv-self-hosted-blog), I counted the CLS gathered so far by element. Along with the CLS value, the collection code records the selector of the element that shifted in the trace. The table below groups the 585 initial page loads received from 15:00 on October 17 to 15:00 on October 24, 2026 by that selector.

| Recorded shifted element    | Loads | CLS 0.1 or higher | Median CLS |
| --------------------------- | ----: | ----------------: | ---------: |
| `#cursor-glow`              |   404 |               138 |      0.077 |
| No shift                    |   121 |                 0 |          0 |
| `body>div`                  |    22 |                21 |      0.540 |
| No element recorded         |    21 |                16 |      0.160 |
| `footer`                    |     8 |                 0 |      0.043 |
| `span.reading-progress-num` |     5 |                 0 |      0.000 |
| Other                       |     4 |                 0 |      0.028 |

The CLS p75 for this period was 0.116, above the good threshold of 0.1, and 175 loads (29.9%) were at 0.1 or higher. 138 of them are in the first row. `#cursor-glow` is a decorative element that follows the mouse cursor. It pushes no other element, yet it was recorded as the shifted element in 69% of initial loads. `body>div` and `footer` had few loads at the time, so I moved on without looking for a cause, but they rose sharply on the home page over six days in early November.

After I fixed the glow, the weekly p75 of overall CLS was 0.000. Yet during those six days, 45% of initial loads on the home page had a CLS of 0.1 or higher. Even after the overall p75 came down, I still needed to look at pages and shifted elements separately.

This post follows the rows of the table from the top: why each element was counted as a layout shift, what I fixed, and how the values changed after the fix. At the end, I go over the rows whose causes I could not find.

### How the Selector Is Recorded

CLS divides layout shifts into groups called session windows. It adds up scores while shifts are less than 1 second apart and less than 5 seconds from the first shift, then uses the value of the group with the largest total ([`LayoutShiftManager.ts`](https://github.com/GoogleChrome/web-vitals/blob/v6.2.3/src/lib/LayoutShiftManager.ts), [`onCLS.ts`](https://github.com/GoogleChrome/web-vitals/blob/v6.2.3/src/onCLS.ts#L98-L102)).

The attribution build of web-vitals 6.2.3 picks the `layout-shift` entry with the largest score in that group. It then looks for the first item in that entry's `sources` whose `node` is an Element, and falls back to the first item if there is none. The selector of the resulting node is `largestShiftTarget` ([`attribution/onCLS.ts`](https://github.com/GoogleChrome/web-vitals/blob/v6.2.3/src/attribution/onCLS.ts#L29-L35)).

```ts
const getLargestLayoutShiftSource = (sources: LayoutShiftAttribution[]) => {
  return sources.find((s) => s.node?.nodeType === 1) || sources[0];
};
```

According to the Layout Instability specification, `sources` holds information about up to five nodes, sorted by impacted area from largest to smallest.[^1] The selector in the table represents the highest-scoring shift within the group that determined CLS. Even if several elements shifted during one load, only one selector is recorded. This selector alone cannot tell you what caused the shift or how much each element contributed in total.

The collection code stores this value in the span attribute [`cwv.cls.largest_shift_target`](https://github.com/yceffort/blog/blob/0318847a1dc5c023755f32ebc0870747240f3404/apps/blog/src/utils/telemetry/attributes.ts#L42-L50). Atomic class names generated by StyleX change every time a style is edited, so they are stripped from the selector. That is why selectors without classes, such as `body>div`, show up.

Each entry in the table is one page load. I excluded shifts within SPA navigations and metrics newly created by bfcache restores. CLS is reported only in browsers that support `layout-shift` entries, and 1,909 of the 1,917 initial loads covered in this post came from Chromium-based browsers.

The collection code [aggregates only the first reported value for each metric ID](https://github.com/yceffort/blog/blob/0318847a1dc5c023755f32ebc0870747240f3404/apps/blog/src/utils/telemetry/vitals.ts#L28-L48). The value is usually reported when the page is first hidden, but this blog uses `reportSoftNavs: true`. In browsers that support it, if an SPA navigation is detected before the page is hidden, [the CLS of the previous navigation is reported](https://github.com/GoogleChrome/web-vitals/blob/v6.2.3/src/onCLS.ts#L107-L117). So the values in the table cover the time until the page is first hidden or the first soft navigation is detected. The default reporting behavior is covered in [when web-vitals reports](/2026/10/web-vitals-report-timing).

## `#cursor-glow`

### A 500px Circle That Follows the Cursor

The background of this blog has a 500px-wide circle that faintly lights up the area around the cursor. It is a single `position: fixed` `div` with a radial gradient, its opacity lowered to 0.08. Each `pointermove` event stores the coordinates, the next frame updates `left` and `top`, and CSS puts a 400ms transition on both properties so the circle trails slightly behind the cursor. Below is [`AmbientEffects.tsx`](https://github.com/yceffort/blog/blob/b39c87bedd8760d42c0765564b8ab10c28aec85b/packages/shared/src/components/AmbientEffects.tsx#L25-L38) before the fix.

```tsx
const onMove = (e: PointerEvent) => {
  nextX = e.clientX
  nextY = e.clientY
  if (!raf) {
    raf = window.requestAnimationFrame(() => {
      glow.style.left = `${nextX}px`
      glow.style.top = `${nextY}px`
      raf = 0
    })
  }
}
window.addEventListener('pointermove', onMove, {
  passive: true,
})
```

Nothing looks wrong on screen. The circle sits behind the content, and because it is fixed, it pushes nothing. Nothing jumps while you read.

### A Shift That Pushes Nothing

If you think of CLS only as how far content gets pushed around, it is hard to explain why this element is in the first row of the table. The [Layout Instability specification](https://wicg.github.io/layout-instability/#sec-unstable-nodes) has no condition about what was pushed. It compares each element's starting point (the coordinates of the corner where the element's box begins) with the previous frame, and if it changed, the element is considered shifted.

> A Node N has shifted in a coordinate space C if:
>
> - the starting point of N in C differs significantly from the previous frame starting point of N in C, and
> - the transform-indifferent starting point of N in C differs significantly from the previous frame transform-indifferent starting point of N in C.

The browser decides what "differs significantly" means, and according to a note in the specification, Chrome uses 3px or more horizontally or vertically. For a shifted element to count, it must have a box, its `visibility` must be `visible`, and neither it nor any ancestor may have an `opacity` of 0. Whether the element is in the document flow, or whether it affected the position of other elements, is not among the conditions. A fixed element with an opacity of 0.08 becomes a shifted element as soon as its `left` and `top` change.

The score of a single shift is the impact fraction multiplied by the distance fraction. The impact region is the part of the union of the areas the shifted elements occupied in the previous and current frames that lies within the viewport. Overlapping areas are counted once, and dividing this area by the viewport area gives the fraction. The distance fraction is the distance moved by the element that moved farthest, divided by the longer of the viewport's width and height, and is capped at 1. Here, the distance is the larger of the horizontal and vertical movement ([calculation definitions in the specification](https://wicg.github.io/layout-instability/#sec-layout-shift-value)).

When fully on screen, the glow's box (500×500px) covers 19% of a 1440×900 viewport. The actual impact region depends on its positions before and after the move and on how much of it is clipped off screen. It moves a little each frame during the 400ms transition, so every frame that crosses the movement threshold adds a score.

The [specification explainer](https://github.com/WICG/layout-instability/blob/04a596c53010bbf0b6b82cff6f429359803e1ed3/README.md#limitations) lists this kind of case as a limitation of CLS.

> Conversely, it's possible for a website to provide a smooth user experience, but score poorly on CLS. For example, an image carousel that animates a layout property such as `left` will produce a layout shift on every frame of the animation.

### Mouse Movement and `hadRecentInput`

CLS leaves out shifts that happen within 500ms of user input. This keeps changes the user caused, such as a menu opening after a button press, from being counted as instability. The `hadRecentInput` field of a `layout-shift` entry marks this. However, mouse movement is not among the [inputs defined by the specification](https://wicg.github.io/layout-instability/#sec-input-exclusion).

> Excluding inputs generally include mousedown, keydown, pointerdown, and change events. However, an event whose only effect is to begin or update a flick or scroll gesture is not an excluding input.
>
> The mousemove and pointermove events are also not excluding inputs.

The glow reacts to `pointermove`. That event does not trigger input exclusion on its own. Unless some other excluding input, such as a click, occurs, layout shifts caused by moving the mouse are counted toward CLS.

I checked this by building the commit right before the fix ([`b39c87be`](https://github.com/yceffort/blog/commit/b39c87bedd8760d42c0765564b8ab10c28aec85b)). I served a post page with `next start`, opened it in Chromium 156 through Playwright 1.64.1 with a 1440×900 viewport, moved the mouse to six points on the screen in turn, and collected the `layout-shift` entries. Each move was split into 12 steps, with a 450ms wait before the next one.

| Build                      | `layout-shift` entries | Sum of values | Entries with `hadRecentInput` true |
| -------------------------- | ---------------------: | ------------: | ---------------------------------: |
| Build right before the fix |                133-134 |         0.618 |                                  0 |

There were 133 to 134 entries, and the sum of values was 0.618 to three decimal places in all five runs. Every entry had `#cursor-glow` as its only source. The first entry was a frame in which the element's top-left corner moved from (470, 200) to (338, 118), with a value of 0.0245. More than 130 such frames followed over a little more than 3 seconds. There was never a gap of 1 second or more between shifts, so they all fell into the single session window described earlier, and CLS came out at 0.618.

The field median of 0.077 is much smaller than the lab result. In the lab, I moved across the screen six times without pausing, while real visitors probably often did not move the mouse that much before CLS was first reported. Even so, 138 of the 404 loads had a CLS of 0.1 or higher.

### From `left` and `top` to `transform`

I kept the effect and changed only how the circle moves ([`048eccb2`](https://github.com/yceffort/blog/commit/048eccb2c1a84dd4b40f30e107ed3a45d2502f86)).

```diff
         raf = window.requestAnimationFrame(() => {
-          glow.style.left = `${nextX}px`
-          glow.style.top = `${nextY}px`
+          // left/top 이동은 layout shift 로 집계돼 CLS 에 쌓인다. transform 이동은 집계에서 제외된다.
+          glow.style.transform = `translate3d(${nextX}px, ${nextY}px, 0) translate(-50%, -50%)`
           raf = 0
         })
```

```diff
       position: 'fixed',
-      top: '50%',
-      left: '50%',
+      top: '0',
+      left: '0',
       zIndex: '0',
       width: '500px',
       height: '500px',
@@ -54,9 +54,8 @@ const styles = stylex.create({
-      transform: 'translate(-50%, -50%)',
-      transition:
-        'left 400ms cubic-bezier(0.2, 0.9, 0.2, 1),\n    top 400ms cubic-bezier(0.2, 0.9, 0.2, 1)',
+      transform: 'translate3d(50vw, 50vh, 0) translate(-50%, -50%)',
+      transition: 'transform 400ms cubic-bezier(0.2, 0.9, 0.2, 1)',
```

`left` and `top` stay at 0, and the position is set only through `transform`. The initial position also moved from `top: 50%`, `left: 50%` to `translate3d(50vw, 50vh, 0)`. The research site uses the same component, so I updated its CSS as well.

The second condition in the definition quoted earlier is what leaves `transform` out. The transform-indifferent starting point is the starting point calculated as if there were no `transform` at all. For an element whose only change is its `transform`, this value stays the same, so it does not become a shifted element. The [specification](https://wicg.github.io/layout-instability/#sec-basic-concepts) gives the reason in a note.

> NOTE: To determine whether a node has shifted, we consider the starting point both with and without transforms, to ensure that a node is not made unstable solely due to a transform change.

The [explainer](https://github.com/WICG/layout-instability/blob/04a596c53010bbf0b6b82cff6f429359803e1ed3/README.md#transform-changes) gives three reasons for excluding `transform`: it does not reflow surrounding content, it is commonly used for smooth animations, and it is easy to handle in the compositing stage, separate from the thread where layout and scripts run. The glow did not reflow anything around it before the fix either, and the motion on screen looks the same after it. What changed is how the browser counts this element.

### Values Before and After the Fix

Under the same lab conditions, the current build produced 0 `layout-shift` entries in all five runs.

For the field data, I compared the period from October 25, the day after the fix was deployed, to 11:00 on November 12 against the 7 days before the fix.

| Metric                                     | Before (10/17-10/24) | After (10/25-11/12) |
| ------------------------------------------ | -------------------: | ------------------: |
| Initial loads                              |                  585 |               1,332 |
| CLS p75                                    |                0.116 |               0.000 |
| CLS 0.1 or higher                          |          175 (29.9%) |           71 (5.3%) |
| Recorded shifted element is `#cursor-glow` |                  404 |                   2 |
| Post pages at 0.1 or higher                |           141 of 374 |            9 of 846 |
| Mobile at 0.1 or higher                    |             25 of 44 |             0 of 90 |

Loads with `#cursor-glow` recorded and a CLS of 0.1 or higher ran at 21 to 30 a day from October 19 to 23, and after the 25th there was only one, on November 11. This was not a controlled experiment, but the drop in this element's records lines up with the deployment, and the shifts also disappeared in the lab, so I concluded it was the effect of the fix.[^2]

Mobile values came down too. Before the fix, 12 of the 44 mobile loads had `#cursor-glow` as the recorded shifted element. Touch screens also fire `pointermove` when a finger moves. On the other hand, 16 of the 25 mobile loads with a CLS of 0.1 or higher had no element recorded, so I cannot say what caused them. I come back to these 16 in the last section.

After the fix, 71 loads were still at 0.1 or higher. 62 of them were on the home page.

## `body>div` and `footer`

### Six Days on the Home Page

When I queried three weeks of data again on November 12 to check the effect of the glow fix, the home page values were high only between November 3 and 9.

| Date  | Home initial loads | CLS 0.1 or higher | Shifts below 0.1 |
| ----- | -----------------: | ----------------: | ---------------: |
| 11/02 |                 24 |                 0 |                0 |
| 11/03 |                 15 |                 2 |                5 |
| 11/04 |                 30 |                11 |               14 |
| 11/05 |                 25 |                12 |                9 |
| 11/06 |                 21 |                12 |                9 |
| 11/07 |                  5 |                 1 |                3 |
| 11/08 |                  9 |                 4 |                3 |
| 11/09 |                 24 |                14 |                4 |
| 11/10 |                 12 |                 0 |                0 |

The start and end of this period match two commits. Between [`b74ccf5a`](https://github.com/yceffort/blog/commit/b74ccf5a1241d143ec492d4be8784a34a8fd622c) on November 3 and [`6056cae8`](https://github.com/yceffort/blog/commit/6056cae8f2d87cf9d6b58e3dfdc13800b381da23) on November 9, there were 121 initial loads of the home page. 55 of them were at 0.1 or higher, 47 had shifts below 0.1, and 19 had no shift.

Of the 55 at 0.1 or higher, most had `body>div` (51) as the recorded shifted element, with values between 0.27 and 0.91. Of the 47 below 0.1, most had `footer` (43). The shifts with a recorded selector happened 543ms after navigation start (the median of the 55). In the 9 days before (from October 25 until `b74ccf5a`), 7 of 185 loads were at 0.1 or higher, and afterwards 0 of 47. Of the 2 loads on November 3 in the table, 1 came in the early morning, before the commit.

These are the same names as two rows in the pre-fix 7-day table, and the values are of similar size. In that table, the median for `body>div` was 0.540 and for `footer` 0.043.

### A List That Arrives After the First Screen

Both commits came out of fixing the problem where [content wrapped in Suspense was sent as a hidden element](/2026/11/react-19-2-progressive-chunk-size). `b74ccf5a` removed the `<Suspense fallback={null}>` that wrapped the whole page in the root layout, so that crawlers that do not run JavaScript could read post bodies. The `<Suspense>` around the home page's post list stayed in place.

That difference changed the home page HTML. Before the removal, the header and footer were also inside the outer boundary, so the part rendered first (the shell) had no visible elements. After the removal, the header and footer moved into the shell, and only the post list was placed further down the document in a `div` with the `hidden` attribute. When the list was later moved into place, it pushed the footer off screen.

The two images below are screenshots of the home page at a 1440×900 viewport, taken from a build of the commit between those two ([`cb89b3ad`](https://github.com/yceffort/blog/commit/cb89b3adb901489353967ccec0635fca6ecb1bae)). The first was taken while holding back the `requestAnimationFrame` callback, before the list was moved, and the second after releasing it. The footer was at y 781 and moved down to 2,848.

![The home page before the list arrives. Only the header and footer are there, and the footer is visible at the bottom of the screen](./images/which-element-caused-cls/home-before-reveal.png)

![The home page after the list arrives. The footer has been pushed off screen and a vertical scrollbar has appeared on the right](./images/which-element-caused-cls/home-after-reveal.png)

### Why the List Arrives in a Separate Frame

Here is a condensed version of the home page HTML from the same build. After an empty `main` and the footer comes the hidden list, and a script moves it into `main`.

```html
<main id="main"><!--$?--><template id="B:0"></template><!--/$--></main>
<footer>…</footer>
…
<div hidden id="S:0">…</div>
<script>
  …$RC("B:0","S:0")
</script>
```

The first 30KB holds the header, the empty `main` and the footer, followed by about 68KB of list and the `$RC` call. `$RC` is the `completeBoundary` function that React ships in the HTML, and it moves the contents of the `hidden` element into the boundary's original position. This function does not move the content right away; it only schedules the move. Here is the relevant part of the [source](https://github.com/react/react/blob/278794d7dee9cd2a3a2aaf9f0b2a4b8b747d74ee/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetShared.js#L439-L460) of the React bundled with Next.js 16.4.5 (19.3.0-canary-278794d7).

```js
  if (window['$RB'].length === 2) {
    // This is the first time we've pushed to the batch. We need to schedule a callback
    // to flush the batch. This is delayed by the throttle heuristic.
    if (typeof window['$RT'] !== 'number') {
      // If we haven't had our rAF callback yet, schedule everything for the first paint.
      requestAnimationFrame(window['$RV'].bind(null, window['$RB']));
    } else {
```

`$RT` records the time of the shell's first frame. If it has not been recorded yet, `$RV` runs on the next frame; if it has, `$RV` runs on a timer set for 300ms after `$RT`. `$RV` is what actually moves the content.

This blog wraps the layout's `main` in React's `<ViewTransition>` for page transition effects, so the `$RV` shipped in the HTML is the version that uses view transitions. That version moves the content [inside the `update` callback of `document.startViewTransition()`](https://github.com/react/react/blob/278794d7dee9cd2a3a2aaf9f0b2a4b8b747d74ee/packages/react-dom-bindings/src/server/fizz-instruction-set/ReactDOMFizzInstructionSetShared.js#L296-L300).

```js
      const transition = (document['__reactViewTransition'] = document[
        'startViewTransition'
      ]({
        update: () => {
          revealBoundaries(batch);
```

A view transition captures the screen before the update first, and only then calls the `update` callback. So even on a local server where the whole document arrives at once, a screen without the list was produced once first. Below are the call times recorded while opening the home page at 1920×1080. The values are from the first of three runs, and the other two followed the same order.

| Time | Event                                                  |
| ---: | ------------------------------------------------------ |
| 18ms | `$RC` called (`$RT` not set yet)                       |
| 19ms | First `requestAnimationFrame` callback, `$RT` recorded |
| 30ms | `document.startViewTransition()` called                |
| 45ms | `update` callback done (list moved into `main`)        |
| 70ms | `layout-shift` entry, value 0.0369                     |
| 96ms | first-paint                                            |

The footer already had a position in the frame before the list arrived, so it becomes a shifted element. Across five measurements at 1920×1080, there was exactly one `layout-shift` entry each time, with `footer` as its only source and a value of 0.0369. This is the same size as the 1920-wide values (0.033-0.043) among the 47 field loads below 0.1.

In the October 24 build, before the layout boundary was removed, no shift was ever recorded under the same conditions. The shell had no visible elements, so the header, list and footer appeared all at once, and it seems no element had a position in the previous frame.

The field's 543ms is probably later than the lab's 70ms because the rest of the document arrives later over real connections. When I throttled the lab to a 1,600kbps download speed with 150ms of latency, the `$RC` call moved to 664-687ms and the shift to 728-757ms.

### The Scrollbar and 7px

There was one cause, but the field values fell into two clusters. Looking only at loads with a viewport width of 1920, there were 13 at 0.55-0.56, 1 at 0.67 and 3 at 0.033-0.043, and nothing in between.

In the lab, the condition behind this difference was the scrollbar. When the list arrives, the document gets longer and a vertical scrollbar appears. If the scrollbar floats over the content, as with the default macOS setting, the layout width stays the same. Where the scrollbar takes up width, the viewport narrows by that much and every centered element moves sideways. I simulated a 15px scrollbar with CSS (`::-webkit-scrollbar`) and ran the same measurement. The values were identical in all five runs for each condition.

| Viewport  | Overlay scrollbar | 15px scrollbar |
| --------- | ----------------: | -------------: |
| 1920×1080 |             0.037 |          0.675 |
| 1440×900  |             0.060 |          0.848 |
| 2560×1440 |      Not measured |          0.305 |
| 390×844   |             0.070 |   Not measured |

With a 15px scrollbar at 1920×1080, the `layout-shift` entry had three `sources`.

| Element      | Previous frame (x, y, width, height) | Current frame (x, y, width, height) |
| ------------ | ------------------------------------ | ----------------------------------- |
| `body>div`   | 320, 77, 1280, 948                   | 313, 77, 1280, 1003                 |
| `header>div` | 240, 0, 1440, 76                     | 233, 0, 1440, 76                    |
| `footer`     | 352, 961, 1216, 64                   | Outside the viewport                |

`body>div`, which holds the content, moved 7px from x 320 to 313. That is about half of the 15px scrollbar, and above Chrome's 3px threshold. Counting only the footer, the area fraction is 1216×64 divided by 1920×1080, or 0.0375. The footer moved outside the viewport, so the distance fraction is 0.98, and multiplying the two gives 0.037. Once `body>div` and `header>div` are also counted as shifted elements, the area fraction, now including their areas before and after the move, grows to 0.69. The maximum distance is still set by the footer, so the distance fraction stays the same, and the score becomes 0.675. The 7px movement of the content and header, on top of the list pushing the footer down, changed the score dramatically.

The large field values were smaller on wider screens: 0.27-0.28 at 2560 wide, 0.55-0.56 at 1920 wide, and 0.68-0.87 for widths between 1439 and 1512. The content area has a maximum width, so the wider the screen, the smaller the share of the viewport taken up by `body>div`; that appears to be the reason. The lab values follow the same order.

Some things I could not confirm. The 15px scrollbar was simulated, and I did not measure on Windows directly. I did not collect visitors' scrollbar widths or viewport heights, so tying the two field clusters to scrollbar settings is an inference that rests on the lab results. Also, at 1280×720 the content area filled the full width, so there was no horizontal shift and the value was only 0.117, yet the field had 4 loads at 0.76 at 1280 wide. I could not explain this difference.

### A Fix Made for Crawlers

The home page values went back to 0 after `6056cae8` was deployed. This commit removes the home page's `<Suspense>` from production builds.

```diff
 export default function HomeView({locale}: {locale: Locale}) {
-  return (
-    <Suspense>
-      <HomeContent locale={locale} />
-    </Suspense>
-  )
+  if (process.env.NODE_ENV !== 'production') {
+    // 경계는 개발 모드의 connection()에만 필요하다. 프로덕션에서 감싸면 React가 완성된 경계도
+    // hidden 세그먼트로 빼내서 JS 없는 크롤러가 홈의 글 목록을 못 읽는다
+    return (
+      <Suspense>
+        <HomeContent locale={locale} />
+      </Suspense>
+    )
+  }
+  return <HomeContent locale={locale} />
 }
```

As the comment says, the goal was crawlers. After fixing post bodies, the same problem remained on the home page, so I brought it in line; it was not a fix made because of CLS. The current build has 0 shifts under both scrollbar conditions, and in the field, none of the 47 home page initial loads since then were at 0.1 or higher.

Judging by the results alone, the November 3 fix introduced CLS on the home page and the November 9 fix removed it. I only found out that 45% of home page initial loads had a CLS of 0.1 or higher during those six days when I queried past data on November 12.

## Rows Left in the Table

Counting the 1,211 loads from the post-fix period by element again, leaving out the home page's six days, gives the following.

| Recorded shifted element    | Loads | CLS 0.1 or higher |
| --------------------------- | ----: | ----------------: |
| No shift                    |   829 |                 0 |
| `span.reading-progress-num` |   277 |                 0 |
| Other                       |    85 |                 5 |
| `body>div`                  |    10 |                10 |
| No element recorded         |     6 |                 0 |
| `#cursor-glow`              |     2 |                 1 |
| `footer`                    |     2 |                 0 |

`span.reading-progress-num` is the number that shows how much of a post has been read. All 277 loads had CLS values below 0.0001. It stayed out of sight while the glow was recorded as the representative shifted element and only reached the table once the glow was gone, so I did not treat it as something to fix.

`body>div` is the row I could not explain. Outside the home page's six days there were 32 more loads (22 in the 7 days before the fix and 10 after), 31 of them at 0.1 or higher. 21 were post pages and 11 were the home page. Their median values of 0.54-0.62 matched the large home page cluster, so I suspected the same cause. I tried the October 24 build, which still had the layout boundary, with the download speed throttled to 400kbps, and also measured a second visit controlled by the service worker, but neither condition produced a shift. By date, they appear only from October 18 to 31, and after November 3, when the layout boundary was removed, there are none outside the home page's six days. All I have confirmed is that it no longer appears.

The no-element row dropped from 21 before the fix to 6, and the remaining 6 all have values of 0.01 or less. Of the 21 before the fix, 16 were mobile loads with a CLS of 0.1 or higher. I could not confirm why no element was recorded. All I know is that after the glow fix, mobile loads at 0.1 or higher went to 0 of 90.

The 2 `#cursor-glow` loads were post page loads on October 29 and November 11. Both came after the fix was deployed, and I could not confirm why they remained.

## Values and Elements

Had I collected only CLS values, on October 24 I would have had a single number, 0.116. Labels would have told me that post pages were at 0.136 and mobile at 0.172, but finding what to fix would have taken a separate search in the lab. And in a lab measurement where the mouse does not move, the glow never moves at all.

The home page's six days never showed up in the overall p75. For each of the three weeks after the fix, the p75 was 0.000. The values only surfaced once the home page was separated out or loads were counted by element.

Working through these two cases, I also rechecked what CLS actually counts. The glow pushed nothing, yet it was recorded as the representative shifted element in 138 initial loads with a CLS of 0.1 or higher (24% of all 585). On the home page, the score was either 0.037 or 0.675 depending on whether the scrollbar took up space when the list arrived. The specification explainer itself lists as a limitation that the value is not always proportional to the inconvenience users experience. So on this blog, I intend to look at CLS by page and use the recorded elements as clues to reproduce and confirm the causes.

[^1]: Specification quotes are based on the Draft Community Group Report dated November 8, 2026 (repository commit [`04a596c`](https://github.com/WICG/layout-instability/tree/04a596c53010bbf0b6b82cff6f429359803e1ed3)). The sort order of `sources` is described in the [LayoutShift interface](https://wicg.github.io/layout-instability/#sec-layout-shift) section.

[^2]: The Mimir dashboard in Grafana shows the p75 for the same periods going from 0.123 to 0.008. Those values are interpolated within histogram buckets, so samples concentrated in the 0-0.01 bucket come out as 0.008. The good ratio went from 69.7% (567 loads) to 94.7% (1,314 loads). Why trace and metric counts differ is explained in [the post on self-hosting the collection](/2026/10/cwv-self-hosted-blog).
