fix(ui): report 'zoom' not 'mixed' for a zoom repaint (SD-3311)

layoutUpdated and paginationUpdate are emitted back-to-back with the same
payload for the same paint (PresentationEditor.ts:6491-6492), so subscribing
geometry invalidation to both double-counted one repaint: a zoom coalesced to
'mixed' and the 'zoom' reason was unreachable. Subscribe to layoutUpdated only
- it covers every repaint. Adds regression coverage for the zoom and plain
layout reasons.

Author: caio-pizzol

packages/super-editor/src/ui/create-super-doc-ui.ts

@@ -1169,15 +1169,18 @@ export function createSuperDocUI(options: SuperDocUIOptions): SuperDocUI {
     PRESENTATION_EVENTS.forEach((name) => {
       next.on?.(name, onPresentationChange);
     });
-    // Geometry-only: layout/pagination repaints move painted rects without a
-    // body `transaction`. Drive the viewport geometry signal, NOT the slice
+    // Geometry-only: layout repaints move painted rects without a body
+    // `transaction`. Drive the viewport geometry signal, NOT the slice
     // recompute (which would re-attach editor listeners on every repaint).
+    // Listen to `layoutUpdated` only: `paginationUpdate` is emitted
+    // back-to-back with the same payload for the same paint
+    // (PresentationEditor.ts:6491-6492), so subscribing to both would
+    // double-count one repaint — a zoom would coalesce to 'mixed' instead of
+    // 'zoom'. `layoutUpdated` alone covers every repaint.
     next.on?.('layoutUpdated', onGeometryLayout);
-    next.on?.('paginationUpdate', onGeometryLayout);
     currentPresentationTeardown = () => {
       PRESENTATION_EVENTS.forEach((name) => next.off?.(name, onPresentationChange));
       next.off?.('layoutUpdated', onGeometryLayout);
-      next.off?.('paginationUpdate', onGeometryLayout);
     };
   };
 

packages/super-editor/src/ui/viewport.test.ts

@@ -607,3 +607,85 @@ describe('ui.viewport.observe — geometry invalidation (SD-3311)', () => {
     expect(events).toEqual([]);
   });
 });
+
+// Stub with real event emitters so tests can drive the engine signals that
+// feed ui.viewport.observe: superdoc `zoomChange` and presentation
+// `layoutUpdated` / `paginationUpdate`.
+function makeEmitter() {
+  const map = new Map<string, Set<(p?: unknown) => void>>();
+  return {
+    on: (e: string, h: (p?: unknown) => void) => {
+      if (!map.has(e)) map.set(e, new Set());
+      map.get(e)!.add(h);
+    },
+    off: (e: string, h: (p?: unknown) => void) => {
+      map.get(e)?.delete(h);
+    },
+    emit: (e: string, p?: unknown) => [...(map.get(e) ?? [])].forEach((h) => h(p)),
+  };
+}
+
+function makeGeometryStub() {
+  const sd = makeEmitter();
+  const pres = makeEmitter();
+  const emptyList = () => ({ evaluatedRevision: 'r1', total: 0, items: [], page: { limit: 0, offset: 0, returned: 0 } });
+  const editor: { on: ReturnType<typeof vi.fn>; off: ReturnType<typeof vi.fn>; doc: unknown; presentationEditor: unknown } = {
+    on: vi.fn(),
+    off: vi.fn(),
+    doc: {
+      selection: { current: vi.fn(() => ({ empty: true })) },
+      comments: { list: vi.fn(emptyList) },
+      trackChanges: { list: vi.fn(emptyList) },
+      contentControls: { list: vi.fn(() => ({ items: [], total: 0 })) },
+    },
+    presentationEditor: undefined,
+  };
+  editor.presentationEditor = {
+    on: pres.on,
+    off: pres.off,
+    getActiveEditor: () => editor,
+    getEntityRects: vi.fn(() => []),
+    navigateTo: vi.fn(async () => true),
+  };
+  const superdoc: SuperDocLike = {
+    activeEditor: editor as never,
+    config: { documentMode: 'editing' },
+    on: sd.on as never,
+    off: sd.off as never,
+  };
+  return { superdoc, emitSuperdoc: sd.emit, emitPresentation: pres.emit };
+}
+
+describe('ui.viewport.observe — repaint reason (SD-3311 regression)', () => {
+  const nextFrame = () => new Promise((resolve) => setTimeout(resolve, 30));
+
+  it('reports "zoom" for a zoom repaint, not "mixed" (layoutUpdated + paginationUpdate are one paint)', async () => {
+    const { superdoc, emitSuperdoc, emitPresentation } = makeGeometryStub();
+    const ui = createSuperDocUI({ superdoc });
+    const events: Array<{ reason: string }> = [];
+    ui.viewport.observe((e) => events.push(e));
+
+    // zoomChange (pre-paint), then the paired post-paint repaint events.
+    emitSuperdoc('zoomChange');
+    emitPresentation('layoutUpdated');
+    emitPresentation('paginationUpdate'); // same paint / payload — must not double-count
+    await nextFrame();
+
+    expect(events).toEqual([{ reason: 'zoom' }]);
+    ui.destroy();
+  });
+
+  it('reports "layout" for a plain repaint (the paginationUpdate alias does not make it "mixed")', async () => {
+    const { superdoc, emitPresentation } = makeGeometryStub();
+    const ui = createSuperDocUI({ superdoc });
+    const events: Array<{ reason: string }> = [];
+    ui.viewport.observe((e) => events.push(e));
+
+    emitPresentation('layoutUpdated');
+    emitPresentation('paginationUpdate');
+    await nextFrame();
+
+    expect(events).toEqual([{ reason: 'layout' }]);
+    ui.destroy();
+  });
+});