@@ -7,3 +7,4 @@ Add a store interface to the `Virtualizer` and a `useVirtualizerState` hook for
 
 - `virtualizer.subscribe(listener)` registers any number of change listeners, and `virtualizer.getState()` returns an immutable `{ virtualItems, totalSize, range, isScrolling, scrollDirection }` snapshot that keeps its identity until a field changes.
 - `useVirtualizerState(virtualizer, selector?, isEqual?)` subscribes to that state through `useSyncExternalStore`. Values read through it stay live under the React Compiler, which can otherwise memoise `virtualizer.getVirtualItems()` on the stable instance. It works with both `useVirtualizer` and `useWindowVirtualizer`.
+- While a listener is subscribed, an option change that moves the visible range (such as a new `count`) fires `onChange` when it is committed, rather than at the next scroll event.
@@ -108,9 +108,10 @@ function useVirtualizerBase<
   directRef.current.enabled = directDomUpdates
   directRef.current.mode = directDomUpdatesMode
 
-  // Set while the virtualizer measures an item through `measureElement`, which is
-  // passed as a ref and therefore runs while React is committing.
-  const measuringFromRef = React.useRef(false)
+  // Set while React is committing and the virtualizer may notify: inside
+  // `measureElement`, which is passed as a ref, and inside `_willUpdate`,
+  // which runs in a layout effect. `flushSync` cannot flush in that window.
+  const committingRef = React.useRef(false)
 
   // Writes the size container's total extent to the DOM. Idempotent — guarded
   // by lastSize. Split out from applyDirectStyles so it can run *before* the
@@ -195,15 +196,17 @@ function useVirtualizerBase<
       }
 
       if (shouldRerender) {
-        // A sync notify raised from `measureElement` reaches us while React is
-        // committing, because `measureElement` is a ref callback. `flushSync`
-        // cannot flush there: React still runs the callback at sync priority, but
-        // it skips the flush and warns in development. The commit phase already
-        // runs at discrete (sync) priority, so leaving `flushSync` out for that
-        // window keeps the same lane and the same flush point — without the
-        // warning. Every other sync notify (ResizeObserver re-measures, scroll
-        // adjustments) still flushes synchronously.
-        if (useFlushSync && sync && !measuringFromRef.current) {
+        // A sync notify can reach us while React is committing: from
+        // `measureElement`, a ref callback, or from `_willUpdate`, a layout
+        // effect, when it publishes an option change that moved the range
+        // mid-scroll. `flushSync` cannot flush there: React still runs the
+        // callback at sync priority, but it skips the flush and warns in
+        // development. The commit phase already runs at discrete (sync)
+        // priority, so leaving `flushSync` out for that window keeps the same
+        // lane and the same flush point — without the warning. Every other
+        // sync notify (ResizeObserver re-measures, scroll adjustments) still
+        // flushes synchronously.
+        if (useFlushSync && sync && !committingRef.current) {
           flushSync(rerender)
         } else {
           rerender()
@@ -218,11 +221,11 @@ function useVirtualizerBase<
     const v = new Virtualizer<TScrollElement, TItemElement>(resolvedOptions)
     const measureElement = v.measureElement
     v.measureElement = (node: TItemElement | null) => {
-      measuringFromRef.current = true
+      committingRef.current = true
       try {
         measureElement(node)
       } finally {
-        measuringFromRef.current = false
+        committingRef.current = false
       }
       // A row can mount in a commit that does not include this component — a
       // memoised child re-rendered through `useVirtualizerState` — which the
@@ -263,7 +266,12 @@ function useVirtualizerBase<
     // top until the next scroll. Positions are written afterwards by the
     // applyDirectStyles effect below.
     applyContainerSize(instance)
-    return instance._willUpdate()
+    committingRef.current = true
+    try {
+      return instance._willUpdate()
+    } finally {
+      committingRef.current = false
+    }
   })
 
   // After every render commit, newly mounted item refs have registered in
 
@@ -387,3 +387,42 @@ test('directDomUpdates positions rows a memoised child mounts together with the
   expect(transformOf('row-1')).toBe('translate3d(0, 50px, 0)')
   expect(transformOf('row-3')).toBe('translate3d(0, 150px, 0)')
 })
+
+test('an option change committed mid-scroll notifies a subscriber without flushSync', () => {
+  const errors = vi.spyOn(console, 'error').mockImplementation(() => {})
+  const scroll = createScrollDriver()
+  const onChange = vi.fn()
+
+  function TotalSize({ virtualizer }: { virtualizer: TestVirtualizer }) {
+    const totalSize = useVirtualizerState(virtualizer, (s) => s.totalSize)
+    return <div data-testid="total">{totalSize}</div>
+  }
+
+  const Memoized = React.memo(TotalSize)
+
+  function App({ count }: { count: number }) {
+    const { parentRef, virtualizer } = useTestVirtualizer(count, {
+      observeElementOffset: scroll.observeElementOffset,
+      onChange,
+    })
+    return (
+      <div ref={parentRef}>
+        <Memoized virtualizer={virtualizer} />
+      </div>
+    )
+  }
+
+  const { rerender } = render(<App count={100} />)
+  act(() => scroll.scrollTo(10))
+  onChange.mockClear()
+  errors.mockClear()
+
+  // `isScrolling` is true, so the range change `_willUpdate` publishes is a
+  // sync notify raised inside a layout effect, where React cannot flushSync.
+  rerender(<App count={2} />)
+
+  expect(screen.getByTestId('total')).toHaveTextContent('100')
+  expect(onChange).toHaveBeenCalledWith(expect.anything(), true)
+  expect(errors).not.toHaveBeenCalled()
+  errors.mockRestore()
+})
Original file line number	Diff line number	Diff line change
@@ -7,3 +7,4 @@ Add a store interface to the `Virtualizer` and a `useVirtualizerState` hook for
`7`	`7`
`8`	`8`	- `virtualizer.subscribe(listener)` registers any number of change listeners, and `virtualizer.getState()` returns an immutable `{ virtualItems, totalSize, range, isScrolling, scrollDirection }` snapshot that keeps its identity until a field changes.
`9`	`9`	- `useVirtualizerState(virtualizer, selector?, isEqual?)` subscribes to that state through `useSyncExternalStore`. Values read through it stay live under the React Compiler, which can otherwise memoise `virtualizer.getVirtualItems()` on the stable instance. It works with both `useVirtualizer` and `useWindowVirtualizer`.
	`10`	+- While a listener is subscribed, an option change that moves the visible range (such as a new `count`) fires `onChange` when it is committed, rather than at the next scroll event.