Commit 55b8d8d89 for llama.cpp

commit 55b8d8d8980065eefb353b8d5ddff3caa077164d
Author: Aleksander Grygier <aleksander.grygier@gmail.com>
Date:   Fri Nov 20 09:57:44 2026 +0100

    ui: full-screen diagram preview that zooms around what is on screen, inert diagrams (#32591)

    * ui: keep Pele diagrams inert

    Pele turns a node with `click ... href` into a live link, where Mermaid's
    strict security level left diagrams without links. Unwrap every link in
    Pele's output, keeping its children, so the inline block, the live-preview
    editor, the preview dialog and the downloaded svg stay inert. The Diagrams
    story's flowchart now carries click directives and its play test checks
    that no link or href is left.

    Assisted-by: Claude (Opus 5.5 Medium)

    * ui: open diagrams full screen, zoom around what is on screen

    The diagram preview dialog fills the window on every device. The preview
    places the diagram from its top left corner, so a zoom keeps a screen point
    fixed: the wheel and a trackpad pinch zoom around the pointer, the buttons
    and +/- keys around the middle of the screen, wherever the diagram has been
    panned to. Two-finger pinch, double-click and arrow keys work too. The
    diagram opens fitted and keeps fitting until panned or zoomed; Reset view
    fits it again.

    Adds MermaidPreview and DialogMermaidPreview stories with play tests and a
    unit test for the zoom math.

    Assisted-by: Claude (Opus 5.5 Medium)

    * ui: add a diagrams trace to the demo fixtures

    Assisted-by: Claude (Opus 5.5 Medium)

diff --git a/ui/apps/chat/demo/fixtures/traces.ts b/ui/apps/chat/demo/fixtures/traces.ts
index cc7ed8979..dc766458e 100644
--- a/ui/apps/chat/demo/fixtures/traces.ts
+++ b/ui/apps/chat/demo/fixtures/traces.ts
@@ -301,9 +301,39 @@ function agenticDebugging(): Trace {
 	return trace;
 }

+/** A reply with a diagram, for diagram preview demos. */
+function diagrams(): Trace {
+	const trace = new Trace('How a request flows through llama-server');
+
+	trace.user('Can you draw how a chat request flows through llama-server?');
+	trace.assistant(
+		[
+			'Here is the path a request takes:',
+			'',
+			'```mermaid',
+			'flowchart LR',
+			'    U[Browser] -->|POST /v1/chat/completions| S(llama-server)',
+			'    S --> Q{Slot free?}',
+			'    Q -->|yes| P[Prompt processing]',
+			'    Q -->|no| W[Queue]',
+			'    W --> P',
+			'    P --> G[Sample token]',
+			'    G -->|more| G',
+			'    G -->|SSE tokens| U',
+			'    click S href "https://github.com/ggml-org/llama.cpp" "llama.cpp on GitHub" _blank',
+			'```',
+			'',
+			'Requests wait in the queue until a slot is free, then tokens stream back as they are sampled.'
+		].join('\n')
+	);
+
+	return trace;
+}
+
 /** Built-in traces, by name. */
 export const DEMO_TRACES: Record<string, () => Trace> = {
 	'agentic-debugging': agenticDebugging,
+	diagrams,
 	'long-chat': longChat
 };

diff --git a/ui/apps/chat/src/lib/components/app/content/MarkdownContent/markdown-diagrams.ts b/ui/apps/chat/src/lib/components/app/content/MarkdownContent/markdown-diagrams.ts
index ba607bfbc..ec3e35dd9 100644
--- a/ui/apps/chat/src/lib/components/app/content/MarkdownContent/markdown-diagrams.ts
+++ b/ui/apps/chat/src/lib/components/app/content/MarkdownContent/markdown-diagrams.ts
@@ -43,6 +43,13 @@ function diagramWidth(node: HTMLElement): number | undefined {
 	return width > 0 ? width : undefined;
 }

+// Pele wraps a node with a `click ... href` directive in a link. Diagrams come from model
+// output, so they stay inert, as they were under Mermaid's strict security level: each link
+// gives way to its children. The preview dialog and the downloaded file copy this svg.
+function unwrapLinks(root: HTMLElement) {
+	for (const link of root.querySelectorAll('a')) link.replaceWith(...link.childNodes);
+}
+
 /**
  * Renders the mermaid diagrams in `container` that haven't been rendered yet, with Pele.
  * Marks nodes immediately to prevent duplicate renders during streaming. Colors come
@@ -77,6 +84,7 @@ export async function renderMermaidDiagrams(container: HTMLElement) {
 			});

 			node.innerHTML = svg;
+			unwrapLinks(node);
 		} catch (error) {
 			// the message quotes the diagram source, so it goes in as text
 			const message = document.createElement('div');
diff --git a/ui/apps/chat/src/lib/components/app/content/MermaidPreview.svelte b/ui/apps/chat/src/lib/components/app/content/MermaidPreview.svelte
index d981f67d1..934802581 100644
--- a/ui/apps/chat/src/lib/components/app/content/MermaidPreview.svelte
+++ b/ui/apps/chat/src/lib/components/app/content/MermaidPreview.svelte
@@ -1,7 +1,16 @@
 <script lang="ts">
 	import MermaidPreviewControls from './MermaidPreviewControls.svelte';
 	import { SVG } from '#lib/constants/index.ts';
+	import {
+		DIAGRAM_ZOOM_FACTOR,
+		type DiagramView,
+		fitView,
+		wheelZoomFactor,
+		zoomAt,
+		zoomAtCenter
+	} from '#lib/utils/diagram-viewport.ts';
 	import { mountSvgShadow } from '#lib/utils/svg-shadow.ts';
+	import { SvelteMap } from 'svelte/reactivity';

 	interface Props {
 		svgHtml: string;
@@ -9,61 +18,105 @@

 	let { svgHtml }: Props = $props();

+	// room kept clear around a fitted diagram, and below it for the controls
+	const FIT_PADDING_PX = 24;
+	const CONTROLS_SPACE_PX = 96;
+	// how far an arrow key pans, and with Shift held
+	const PAN_STEP_PX = 48;
+	const PAN_STEP_LARGE_PX = 192;
+
+	let viewport = $state<HTMLDivElement | null>(null);
+	let diagram = $state<HTMLDivElement | null>(null);
 	let svgHost = $state<HTMLDivElement | null>(null);

+	let view = $state<DiagramView>({ scale: 1, x: 0, y: 0 });
+	// Until the user pans or zooms, the diagram keeps fitting the viewport: as the window
+	// resizes, and as a streaming svg grows
+	let touched = $state(false);
+	let fitted = $state(false);
+
+	// Pointers down on the viewport: one pans, two pinch
+	const pointers = new SvelteMap<number, { x: number; y: number }>();
+	let isDragging = $state(false);
+
 	// Re-mount on every svgHtml change so a live streaming svg keeps rendering while zoomed
 	$effect(() => {
 		if (svgHost) mountSvgShadow(svgHost, svgHtml, SVG.DIALOG_SHADOW_STYLE);
 	});

-	// Zoom and pan state
-	let scale = $state(1);
-	let translateX = $state(0);
-	let translateY = $state(0);
-	let isDragging = $state(false);
-	const containerRef = { current: null as HTMLDivElement | null };
+	function viewportSize() {
+		return { height: viewport?.clientHeight ?? 0, width: viewport?.clientWidth ?? 0 };
+	}

-	// Drag start position
-	let dragStartX = 0;
-	let dragStartY = 0;
-	let dragStartTranslateX = 0;
-	let dragStartTranslateY = 0;
+	function fit() {
+		if (!viewport || !diagram) return;

-	const MIN_SCALE = 0.1;
-	const MAX_SCALE = 10;
-	const ZOOM_STEP = 0.15;
+		const { height, width } = viewportSize();
+		const content = { height: diagram.offsetHeight, width: diagram.offsetWidth };

-	function resetView() {
-		scale = 1;
-		translateX = 0;
-		translateY = 0;
+		if (!width || !height || !content.width || !content.height) return;
+
+		view = fitView(
+			content,
+			{ height: Math.max(height - CONTROLS_SPACE_PX, 0), width },
+			FIT_PADDING_PX
+		);
+		fitted = true;
+	}
+
+	$effect(() => {
+		if (!viewport || !diagram) return;
+
+		const observer = new ResizeObserver(() => {
+			if (!touched) fit();
+		});
+
+		observer.observe(viewport);
+		observer.observe(diagram);
+
+		return () => observer.disconnect();
+	});
+
+	function setView(next: DiagramView) {
+		view = next;
+		touched = true;
 	}

-	function zoomIn() {
-		scale = Math.min(scale + ZOOM_STEP, MAX_SCALE);
+	function resetView() {
+		touched = false;
+		fit();
 	}

-	function zoomOut() {
-		scale = Math.max(scale - ZOOM_STEP, MIN_SCALE);
+	function zoomBy(factor: number) {
+		setView(zoomAtCenter(view, factor, viewportSize()));
 	}

-	function handleWheel(event: WheelEvent) {
-		event.preventDefault();
+	// a point of the page in the viewport's own coordinates
+	function localPoint(clientX: number, clientY: number) {
+		const rect = viewport!.getBoundingClientRect();

-		const delta = event.deltaY > 0 ? -ZOOM_STEP : ZOOM_STEP;
+		return { x: clientX - rect.left, y: clientY - rect.top };
+	}

-		scale = Math.min(Math.max(scale + delta, MIN_SCALE), MAX_SCALE);
+	function isOnControls(target: EventTarget | null) {
+		return target instanceof Element && Boolean(target.closest('.mermaid-preview-controls'));
 	}

-	// Imperatively attach a non-passive wheel listener so preventDefault() actually works
-	// (Svelte 5 wheel listeners are passive by default, making preventDefault() a no-op)
+	// Attached imperatively: Svelte's wheel listeners are passive, so preventDefault() would
+	// not stop the page (or a pinch, the browser) from zooming
 	$effect(() => {
-		const el = containerRef.current;
+		const el = viewport;

 		if (!el) return;

-		function onWheel(e: WheelEvent) {
-			handleWheel(e);
+		function onWheel(event: WheelEvent) {
+			if (isOnControls(event.target)) return;
+
+			event.preventDefault();
+
+			const point = localPoint(event.clientX, event.clientY);
+
+			setView(zoomAt(view, wheelZoomFactor(event), point.x, point.y));
 		}

 		el.addEventListener('wheel', onWheel, { passive: false });
@@ -72,53 +125,137 @@
 	});

 	function handlePointerDown(event: PointerEvent) {
-		if (event.button !== 0 && event.pointerType === 'mouse') return;
+		if (event.pointerType === 'mouse' && event.button !== 0) return;

-		isDragging = true;
-		dragStartX = event.clientX;
-		dragStartY = event.clientY;
-		dragStartTranslateX = translateX;
-		dragStartTranslateY = translateY;
+		if (isOnControls(event.target)) return;

-		(event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
+		pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
+		isDragging = true;
+		viewport?.setPointerCapture(event.pointerId);
 	}

 	function handlePointerMove(event: PointerEvent) {
-		if (!isDragging) return;
+		const last = pointers.get(event.pointerId);
+
+		if (!last) return;
+
+		if (pointers.size === 1) {
+			pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
+			setView({
+				...view,
+				x: view.x + event.clientX - last.x,
+				y: view.y + event.clientY - last.y
+			});

-		translateX = dragStartTranslateX + (event.clientX - dragStartX);
-		translateY = dragStartTranslateY + (event.clientY - dragStartY);
+			return;
+		}
+
+		// Two fingers: zoom around their midpoint by how much they spread, and move with it
+		const [a, b] = [...pointers.values()];
+		const before = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+		const spreadBefore = Math.hypot(a.x - b.x, a.y - b.y);
+
+		pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
+
+		const [c, d] = [...pointers.values()];
+		const after = { x: (c.x + d.x) / 2, y: (c.y + d.y) / 2 };
+		const spreadAfter = Math.hypot(c.x - d.x, c.y - d.y);
+
+		if (!spreadBefore) return;
+
+		const point = localPoint(before.x, before.y);
+		const zoomed = zoomAt(view, spreadAfter / spreadBefore, point.x, point.y);
+
+		setView({ ...zoomed, x: zoomed.x + after.x - before.x, y: zoomed.y + after.y - before.y });
+	}
+
+	function handlePointerUp(event: PointerEvent) {
+		pointers.delete(event.pointerId);
+		isDragging = pointers.size > 0;
+	}
+
+	function handleDoubleClick(event: MouseEvent) {
+		if (isOnControls(event.target)) return;
+
+		const point = localPoint(event.clientX, event.clientY);
+
+		setView(zoomAt(view, 2, point.x, point.y));
 	}

-	function handlePointerUp() {
-		isDragging = false;
+	function handleKeydown(event: KeyboardEvent) {
+		if (event.ctrlKey || event.metaKey || event.altKey) return;
+
+		const step = event.shiftKey ? PAN_STEP_LARGE_PX : PAN_STEP_PX;
+
+		switch (event.key) {
+			case '+':
+			case '=':
+				zoomBy(DIAGRAM_ZOOM_FACTOR);
+
+				break;
+			case '-':
+			case '_':
+				zoomBy(1 / DIAGRAM_ZOOM_FACTOR);
+
+				break;
+			case '0':
+				resetView();
+
+				break;
+			case 'ArrowLeft':
+				setView({ ...view, x: view.x + step });
+
+				break;
+			case 'ArrowRight':
+				setView({ ...view, x: view.x - step });
+
+				break;
+			case 'ArrowUp':
+				setView({ ...view, y: view.y + step });
+
+				break;
+			case 'ArrowDown':
+				setView({ ...view, y: view.y - step });
+
+				break;
+			default:
+				return;
+		}
+
+		event.preventDefault();
 	}
 </script>

+<svelte:window onkeydown={handleKeydown} />
+
+<!-- svelte-ignore a11y_no_static_element_interactions -->
 <div
-	bind:this={containerRef.current}
-	class="mermaid-preview relative flex items-center justify-center overflow-hidden bg-muted/20"
+	bind:this={viewport}
+	class="mermaid-preview relative size-full touch-none overflow-hidden bg-muted/20 select-none {isDragging
+		? 'cursor-grabbing'
+		: 'cursor-grab'}"
+	ondblclick={handleDoubleClick}
+	onlostpointercapture={handlePointerUp}
+	onpointercancel={handlePointerUp}
+	onpointerdown={handlePointerDown}
+	onpointermove={handlePointerMove}
+	onpointerup={handlePointerUp}
 >
-	<!-- svelte-ignore a11y_no_static_element_interactions -->
 	<div
-		class="mermaid-preview-diagram transform-origin-center inline-block min-h-fit min-w-fit will-change-transform {isDragging &&
-			'select-none'}"
-		onpointerdown={handlePointerDown}
-		onpointerleave={handlePointerUp}
-		onpointermove={handlePointerMove}
-		onpointerup={handlePointerUp}
-		style="transform: translate({translateX}px, {translateY}px) scale({scale}); cursor: {isDragging
-			? 'grabbing'
-			: 'grab'};"
+		bind:this={diagram}
+		class="mermaid-preview-diagram absolute top-0 left-0 w-max origin-top-left will-change-transform {fitted
+			? ''
+			: 'invisible'}"
+		style="transform: translate({view.x}px, {view.y}px) scale({view.scale});"
 	>
 		<div bind:this={svgHost}></div>
 	</div>

 	<MermaidPreviewControls
 		onResetView={resetView}
-		onZoomIn={zoomIn}
-		onZoomOut={zoomOut}
-		{scale}
+		onZoomIn={() => zoomBy(DIAGRAM_ZOOM_FACTOR)}
+		onZoomOut={() => zoomBy(1 / DIAGRAM_ZOOM_FACTOR)}
+		scale={view.scale}
 		{svgHtml}
 	/>
 </div>
diff --git a/ui/apps/chat/src/lib/components/app/content/MermaidPreviewControls.svelte b/ui/apps/chat/src/lib/components/app/content/MermaidPreviewControls.svelte
index 1899db389..18f96c529 100644
--- a/ui/apps/chat/src/lib/components/app/content/MermaidPreviewControls.svelte
+++ b/ui/apps/chat/src/lib/components/app/content/MermaidPreviewControls.svelte
@@ -31,7 +31,7 @@
 </script>

 <div
-	class="mermaid-preview-controls absolute bottom-8 flex shrink-0 items-center justify-center p-3"
+	class="mermaid-preview-controls absolute bottom-8 left-1/2 flex shrink-0 -translate-x-1/2 cursor-auto items-center justify-center p-3"
 >
 	<div class="mermaid-preview-controls-inner flex items-center gap-1 rounded-lg bg-muted p-1">
 		<button
diff --git a/ui/apps/chat/src/lib/components/app/content/index.ts b/ui/apps/chat/src/lib/components/app/content/index.ts
index 80ecfa936..62ad69780 100644
--- a/ui/apps/chat/src/lib/components/app/content/index.ts
+++ b/ui/apps/chat/src/lib/components/app/content/index.ts
@@ -123,16 +123,18 @@ export { default as CollapsibleContentBlock } from './CollapsibleContentBlock.sv
 export { default as CollapsibleTerminalBlock } from './CollapsibleTerminalBlock.svelte';

 /**
- * **MermaidPreview** - Interactive Mermaid diagram viewer
+ * **MermaidPreview** - Pan and zoom viewer for a diagram's svg
  *
- * Renders Mermaid-generated SVG diagrams with zoom, pan, and fit-to-view controls.
+ * Shows a diagram (a Pele-drawn Mermaid block or an svg block) fitted to its box, with
+ * zoom, pan and download controls.
  *
  * **Features:**
- * - Mouse wheel zoom in/out
- * - Click-drag panning with pointer capture
- * - Fit to view and reset view controls
- * - Download as SVG
- * - Responsive scaling with viewBox detection
+ * - Fits the diagram until the user pans or zooms, also as the box resizes
+ * - Wheel and trackpad pinch zoom around the pointer; zoom buttons and +/- keys zoom
+ *   around the middle of the box, wherever the diagram has been panned to
+ * - Drag to pan, two-finger pinch on touch, double-click to zoom in, arrow keys to pan
+ * - Reset view (0) fits the diagram again
+ * - Download as SVG with the theme colors written in
  *
  * @example
  * ```svelte
diff --git a/ui/apps/chat/src/lib/components/app/dialogs/DialogMermaidPreview.svelte b/ui/apps/chat/src/lib/components/app/dialogs/DialogMermaidPreview.svelte
index 9c6d8abf9..fedd84600 100644
--- a/ui/apps/chat/src/lib/components/app/dialogs/DialogMermaidPreview.svelte
+++ b/ui/apps/chat/src/lib/components/app/dialogs/DialogMermaidPreview.svelte
@@ -11,9 +11,10 @@
 	let { onOpenChange, open = $bindable(), svgHtml }: Props = $props();
 </script>

+<!-- Full screen on every device, so a large diagram has the whole window to pan and zoom in -->
 <Dialog.Root bind:open {onOpenChange}>
 	<Dialog.Content
-		class="z-999999 grid max-h-full max-w-full! grid-rows-[1fr_auto] overflow-hidden p-0 md:h-[90vh] md:max-w-[90vw]!"
+		class="top-0! left-0! z-999999 block h-dvh! max-h-none! w-screen! max-w-none! translate-x-0! translate-y-0! overflow-hidden rounded-none! border-x-0! border-t-(length:--safe-area-top)! border-b-(length:--safe-area-bottom)! border-transparent! p-0 data-[state=closed]:zoom-out-100 data-[state=open]:zoom-in-100"
 		showCloseButton
 	>
 		<MermaidPreview {svgHtml} />
diff --git a/ui/apps/chat/src/lib/components/app/dialogs/index.ts b/ui/apps/chat/src/lib/components/app/dialogs/index.ts
index 5b3ca761d..e0c1e454e 100644
--- a/ui/apps/chat/src/lib/components/app/dialogs/index.ts
+++ b/ui/apps/chat/src/lib/components/app/dialogs/index.ts
@@ -502,26 +502,16 @@ export { default as DialogMcpResourcesBrowser } from './DialogMcpResourcesBrowse
 export { default as DialogMcpResourcePreview } from './DialogMcpResourcePreview.svelte';

 /**
- * **DialogMermaidPreview** - Full-screen Mermaid diagram preview with zoom and pan
+ * **DialogMermaidPreview** - Full-screen diagram preview with zoom and pan
  *
- * Full-screen dialog for previewing Mermaid diagrams with interactive controls.
- * Supports mouse wheel zoom, drag-to-pan, and toolbar buttons for zoom in/out,
- * fit to view, and reset.
- *
- * **Architecture:**
- * - Uses UI dialog components (`Dialog.Root`, `Dialog.Overlay`, `Dialog.Content`)
- *   for consistent styling, animations, and accessibility
- * - CSS transform-based zoom and pan (no external dependencies)
- * - Pointer events for cross-device drag support (mouse + touch)
- * - Wheel events for zoom-to-cursor functionality
+ * Opens a diagram in a dialog that fills the window on every device, with
+ * `MermaidPreview` inside it for zooming and panning.
  *
  * **Features:**
- * - Scroll wheel zoom centered on cursor position
- * - Click and drag to pan the diagram
- * - Toolbar with zoom in, zoom out, fit to view, reset controls
- * - Zoom percentage indicator
- * - Keyboard accessible close button
- * - Dark/light theme support
+ * - Full screen, keeping clear of the status bar and home indicator on phones
+ * - Zoom around the pointer or the middle of the screen, pan by drag or pinch
+ * - Zoom percentage, reset (fit) and download controls
+ * - Keyboard accessible close button, Escape closes
  *
  * @example
  * ```svelte
diff --git a/ui/apps/chat/src/lib/utils/diagram-viewport.ts b/ui/apps/chat/src/lib/utils/diagram-viewport.ts
new file mode 100644
index 000000000..a4f2fd200
--- /dev/null
+++ b/ui/apps/chat/src/lib/utils/diagram-viewport.ts
@@ -0,0 +1,75 @@
+// Pan and zoom for the diagram preview. The diagram sits at the top left of its viewport
+// with `transform-origin: 0 0`, so a point (x, y) of the diagram shows on screen at
+// (x * scale + x0, y * scale + y0), and every zoom keeps one screen point fixed.
+
+export interface DiagramView {
+	scale: number;
+	x: number;
+	y: number;
+}
+
+export interface Size {
+	width: number;
+	height: number;
+}
+
+export const DIAGRAM_MIN_SCALE = 0.1;
+export const DIAGRAM_MAX_SCALE = 10;
+// a fitted diagram may grow, but not so much that a two-node flowchart fills the screen
+export const DIAGRAM_MAX_FIT_SCALE = 2;
+// one click of a zoom button, or one key press
+export const DIAGRAM_ZOOM_FACTOR = 1.25;
+
+function clampScale(scale: number): number {
+	return Math.min(Math.max(scale, DIAGRAM_MIN_SCALE), DIAGRAM_MAX_SCALE);
+}
+
+/**
+ * Scales the view by `factor` around the viewport point (`px`, `py`): what is under that
+ * point stays there. The scale is clamped, and the point stays fixed at the clamped scale.
+ */
+export function zoomAt(view: DiagramView, factor: number, px: number, py: number): DiagramView {
+	const scale = clampScale(view.scale * factor);
+	const ratio = scale / view.scale;
+
+	return { scale, x: px - (px - view.x) * ratio, y: py - (py - view.y) * ratio };
+}
+
+/** Scales the view by `factor` around the middle of the viewport. */
+export function zoomAtCenter(view: DiagramView, factor: number, viewport: Size): DiagramView {
+	return zoomAt(view, factor, viewport.width / 2, viewport.height / 2);
+}
+
+/**
+ * The view that shows the whole diagram centered in the viewport, less `padding` on every
+ * side. A small diagram grows up to DIAGRAM_MAX_FIT_SCALE.
+ */
+export function fitView(content: Size, viewport: Size, padding = 0): DiagramView {
+	if (content.width <= 0 || content.height <= 0) return { scale: 1, x: 0, y: 0 };
+
+	const scale = clampScale(
+		Math.min(
+			(viewport.width - 2 * padding) / content.width,
+			(viewport.height - 2 * padding) / content.height,
+			DIAGRAM_MAX_FIT_SCALE
+		)
+	);
+
+	return {
+		scale,
+		x: (viewport.width - content.width * scale) / 2,
+		y: (viewport.height - content.height * scale) / 2
+	};
+}
+
+/**
+ * How much a wheel event zooms by. A trackpad pinch arrives as a wheel event with ctrlKey
+ * and small deltas, so it is scaled up to feel like the fingers; line and page deltas
+ * (mouse wheels on some systems) are turned into pixels first.
+ */
+export function wheelZoomFactor(event: Pick<WheelEvent, 'ctrlKey' | 'deltaMode' | 'deltaY'>) {
+	const unit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? 400 : 1;
+	const speed = event.ctrlKey ? 0.01 : 0.002;
+
+	return Math.exp(-event.deltaY * unit * speed);
+}
diff --git a/ui/apps/chat/tests/stories/content/MarkdownContent.stories.svelte b/ui/apps/chat/tests/stories/content/MarkdownContent.stories.svelte
index dbc8481c5..5cbd5697c 100644
--- a/ui/apps/chat/tests/stories/content/MarkdownContent.stories.svelte
+++ b/ui/apps/chat/tests/stories/content/MarkdownContent.stories.svelte
@@ -3,7 +3,7 @@
 	import { MERMAID_DIAGRAMS_MD } from '../fixtures/mermaid-diagrams.js';
 	import { defineMeta } from '@storybook/addon-svelte-csf';
 	import { MarkdownContent } from '#lib/components/app/index.ts';
-	import { expect, waitFor } from 'storybook/test';
+	import { expect, userEvent, waitFor } from 'storybook/test';

 	const { Story } = defineMeta({
 		component: MarkdownContent,
@@ -36,5 +36,31 @@

 		await expect(error?.textContent).toContain('line 2');
 		await expect(error?.closest('pre')).toBeVisible();
+
+		// `click ... href` must not turn a node into a live link, as under Mermaid's strict mode
+		const flowchart = canvasElement.querySelector('pre.mermaid svg.pele');
+
+		await expect(flowchart?.textContent).toContain('llama-server');
+		await expect(canvasElement.querySelector('pre.mermaid a')).toBeNull();
+		await expect(
+			canvasElement.querySelector('pre.mermaid [href], pre.mermaid [*|href]')
+		).toBeNull();
+
+		// The preview button opens the diagram in a dialog that fills the window
+		await userEvent.click(canvasElement.querySelector<HTMLElement>('.preview-code-btn')!);
+
+		const preview = await waitFor(() => {
+			const el = document.querySelector<HTMLElement>('.mermaid-preview');
+
+			expect(el).not.toBeNull();
+
+			return el!;
+		});
+
+		await expect(preview.getBoundingClientRect().width).toBeCloseTo(window.innerWidth, 0);
+		await expect(preview.getBoundingClientRect().height).toBeCloseTo(window.innerHeight, 0);
+
+		await userEvent.keyboard('{Escape}');
+		await waitFor(() => expect(document.querySelector('.mermaid-preview')).toBeNull());
 	}}
 />
diff --git a/ui/apps/chat/tests/stories/content/MermaidPreview.stories.svelte b/ui/apps/chat/tests/stories/content/MermaidPreview.stories.svelte
new file mode 100644
index 000000000..3d670d4ac
--- /dev/null
+++ b/ui/apps/chat/tests/stories/content/MermaidPreview.stories.svelte
@@ -0,0 +1,132 @@
+<script lang="ts" module>
+	import {
+		FLOWCHART_SVG,
+		PIPELINE_SVG,
+		SEQUENCE_SVG,
+		SMALL_SVG
+	} from '../fixtures/mermaid-preview.js';
+	import { defineMeta } from '@storybook/addon-svelte-csf';
+	import { MermaidPreview } from '#lib/components/app/index.ts';
+	import { expect, userEvent, waitFor } from 'storybook/test';
+
+	// the pan and zoom viewer of the diagram preview dialog, here in a box of its own
+	const { Story } = defineMeta({
+		component: MermaidPreview,
+		parameters: {
+			layout: 'fullscreen'
+		},
+		title: 'Llama Chat/Content/MermaidPreview'
+	});
+
+	// the diagram's transform: where its top left corner is, and its scale
+	function readView(canvas: HTMLElement) {
+		const diagram = canvas.querySelector<HTMLElement>('.mermaid-preview-diagram')!;
+		const m = new DOMMatrix(getComputedStyle(diagram).transform);
+
+		return { scale: m.a, x: m.e, y: m.f };
+	}
+
+	// which point of the diagram is under the viewport point (x, y), and where it is now
+	function pointUnder(view: ReturnType<typeof readView>, x: number, y: number) {
+		return { x: (x - view.x) / view.scale, y: (y - view.y) / view.scale };
+	}
+
+	function screenOf(view: ReturnType<typeof readView>, p: { x: number; y: number }) {
+		return { x: p.x * view.scale + view.x, y: p.y * view.scale + view.y };
+	}
+</script>
+
+<Story
+	asChild
+	name="Flowchart"
+	play={async ({ canvasElement }) => {
+		const viewport = await waitFor(() => {
+			const el = canvasElement.querySelector<HTMLElement>('.mermaid-preview');
+
+			expect(el?.querySelector('.mermaid-preview-diagram')).toBeVisible();
+
+			return el!;
+		});
+		const rect = viewport.getBoundingClientRect();
+		const middle = { x: rect.width / 2, y: rect.height / 2 };
+		const fitted = readView(canvasElement);
+		// the wheel zooms around the pointer
+		const pointer = { x: rect.width * 0.7, y: rect.height * 0.35 };
+		const underPointer = pointUnder(fitted, pointer.x, pointer.y);
+
+		viewport.dispatchEvent(
+			new WheelEvent('wheel', {
+				bubbles: true,
+				cancelable: true,
+				clientX: rect.left + pointer.x,
+				clientY: rect.top + pointer.y,
+				deltaY: -200
+			})
+		);
+		await waitFor(() => expect(readView(canvasElement).scale).toBeGreaterThan(fitted.scale));
+		await expect(screenOf(readView(canvasElement), underPointer).x).toBeCloseTo(pointer.x, 0);
+		await expect(screenOf(readView(canvasElement), underPointer).y).toBeCloseTo(pointer.y, 0);
+
+		// after a pan, the zoom buttons zoom around the middle of the viewport
+		const zoomed = readView(canvasElement);
+		const drag = (type: string, x: number, y: number) =>
+			viewport.dispatchEvent(
+				new PointerEvent(type, {
+					bubbles: true,
+					button: 0,
+					clientX: rect.left + x,
+					clientY: rect.top + y,
+					pointerId: 1
+				})
+			);
+
+		drag('pointerdown', 100, 100);
+		drag('pointermove', 260, 180);
+		drag('pointerup', 260, 180);
+		await waitFor(() => expect(readView(canvasElement).x).toBeCloseTo(zoomed.x + 160, 0));
+
+		const panned = readView(canvasElement);
+		const underMiddle = pointUnder(panned, middle.x, middle.y);
+
+		await userEvent.click(canvasElement.querySelector<HTMLElement>('[aria-label="Zoom out"]')!);
+		await waitFor(() => expect(readView(canvasElement).scale).toBeLessThan(panned.scale));
+		await expect(screenOf(readView(canvasElement), underMiddle).x).toBeCloseTo(middle.x, 0);
+		await expect(screenOf(readView(canvasElement), underMiddle).y).toBeCloseTo(middle.y, 0);
+
+		// reset fits the diagram again
+		await userEvent.click(canvasElement.querySelector<HTMLElement>('[aria-label="Reset view"]')!);
+		await waitFor(() => expect(readView(canvasElement)).toEqual(fitted));
+		await expect(canvasElement.querySelector('.mermaid-preview-zoom-label')?.textContent).toBe(
+			`${Math.round(fitted.scale * 100)}%`
+		);
+	}}
+>
+	<div class="h-dvh w-screen">
+		<MermaidPreview svgHtml={FLOWCHART_SVG} />
+	</div>
+</Story>
+
+<Story
+	asChild
+	name="Wide diagram"
+	play={async ({ canvasElement }) => {
+		// fitting shrinks a diagram wider than the screen so all of it shows
+		await waitFor(() => expect(readView(canvasElement).scale).toBeLessThan(1));
+	}}
+>
+	<div class="h-dvh w-screen">
+		<MermaidPreview svgHtml={PIPELINE_SVG} />
+	</div>
+</Story>
+
+<Story asChild name="Small diagram">
+	<div class="h-dvh w-screen">
+		<MermaidPreview svgHtml={SMALL_SVG} />
+	</div>
+</Story>
+
+<Story asChild name="Sequence diagram">
+	<div class="h-dvh w-screen">
+		<MermaidPreview svgHtml={SEQUENCE_SVG} />
+	</div>
+</Story>
diff --git a/ui/apps/chat/tests/stories/dialogs/DialogMermaidPreview.stories.svelte b/ui/apps/chat/tests/stories/dialogs/DialogMermaidPreview.stories.svelte
new file mode 100644
index 000000000..a49b14304
--- /dev/null
+++ b/ui/apps/chat/tests/stories/dialogs/DialogMermaidPreview.stories.svelte
@@ -0,0 +1,41 @@
+<script lang="ts" module>
+	import { FLOWCHART_SVG } from '../fixtures/mermaid-preview.js';
+	import { defineMeta } from '@storybook/addon-svelte-csf';
+	import { DialogMermaidPreview } from '#lib/components/app/index.ts';
+	import { expect, waitFor } from 'storybook/test';
+
+	// the preview a diagram block's preview button opens; it fills the window on every device
+	const { Story } = defineMeta({
+		component: DialogMermaidPreview,
+		parameters: {
+			layout: 'fullscreen'
+		},
+		title: 'Llama Chat/Dialogs/DialogMermaidPreview'
+	});
+</script>
+
+<script lang="ts">
+	let open = $state(true);
+</script>
+
+<Story
+	asChild
+	name="Default"
+	play={async () => {
+		const content = await waitFor(() => {
+			const el = document.querySelector<HTMLElement>('[data-slot="dialog-content"]');
+
+			expect(el?.querySelector('.mermaid-preview')).not.toBeNull();
+
+			return el!;
+		});
+		const rect = content.getBoundingClientRect();
+
+		await expect(rect.left).toBe(0);
+		await expect(rect.top).toBe(0);
+		await expect(rect.width).toBeCloseTo(window.innerWidth, 0);
+		await expect(rect.height).toBeCloseTo(window.innerHeight, 0);
+	}}
+>
+	<DialogMermaidPreview bind:open svgHtml={FLOWCHART_SVG} />
+</Story>
diff --git a/ui/apps/chat/tests/stories/fixtures/mermaid-diagrams.ts b/ui/apps/chat/tests/stories/fixtures/mermaid-diagrams.ts
index 40798c5b8..bb1e2f39f 100644
--- a/ui/apps/chat/tests/stories/fixtures/mermaid-diagrams.ts
+++ b/ui/apps/chat/tests/stories/fixtures/mermaid-diagrams.ts
@@ -1,4 +1,5 @@
-// Mermaid blocks of several diagram types, and one that can't be drawn
+// Mermaid blocks of several diagram types, and one that can't be drawn. The flowchart's
+// click directives must leave it inert.
 const fence = '```';

 export const MERMAID_DIAGRAMS_MD = String.raw`
@@ -12,6 +13,8 @@ flowchart LR
     Q -->|no| W[Queue]
     W --> D
     D -->|SSE tokens| U
+    click S href "https://github.com/ggml-org/llama.cpp" "llama.cpp on GitHub" _blank
+    click D call alert(1)
 ${fence}

 The same exchange over time:
diff --git a/ui/apps/chat/tests/stories/fixtures/mermaid-preview.ts b/ui/apps/chat/tests/stories/fixtures/mermaid-preview.ts
new file mode 100644
index 000000000..136d28d69
--- /dev/null
+++ b/ui/apps/chat/tests/stories/fixtures/mermaid-preview.ts
@@ -0,0 +1,30 @@
+// Diagrams drawn with Pele, as renderMermaidDiagrams() draws them, for the preview stories
+import { render } from 'pele';
+
+export const FLOWCHART_SVG = render(`flowchart LR
+    U[Browser] -->|POST /v1/chat/completions| S(llama-server)
+    S --> Q{Slot free?}
+    Q -->|yes| D[Decode]
+    Q -->|no| W[Queue]
+    W --> D
+    D -->|SSE tokens| U`).svg;
+
+// wider than any screen, so fitting it shrinks it
+export const PIPELINE_SVG = render(`flowchart LR
+    A[Download GGUF] --> B[Read metadata] --> C[Load tensors] --> D[Build graph]
+    D --> E[Tokenize prompt] --> F[Prompt processing] --> G[Sample token]
+    G --> H[Detokenize] --> I[Stream to client] --> J{Stop?}
+    J -->|no| G
+    J -->|yes| K[Free slot]`).svg;
+
+// small enough that fitting it grows it, up to the fit cap
+export const SMALL_SVG = render(`flowchart TD
+    A[Prompt] --> B[Answer]`).svg;
+
+export const SEQUENCE_SVG = render(`sequenceDiagram
+    participant C as Llama Chat
+    participant S as llama-server
+    C->>S: POST /v1/chat/completions
+    S-->>C: data: {"choices":[...]}
+    S-->>C: data: [DONE]
+    Note over C,S: the stream ends with DONE`).svg;
diff --git a/ui/apps/chat/tests/unit/diagram-viewport.test.ts b/ui/apps/chat/tests/unit/diagram-viewport.test.ts
new file mode 100644
index 000000000..cace3f1fe
--- /dev/null
+++ b/ui/apps/chat/tests/unit/diagram-viewport.test.ts
@@ -0,0 +1,111 @@
+import {
+	DIAGRAM_MAX_FIT_SCALE,
+	DIAGRAM_MAX_SCALE,
+	DIAGRAM_MIN_SCALE,
+	type DiagramView,
+	fitView,
+	wheelZoomFactor,
+	zoomAt,
+	zoomAtCenter
+} from '#lib/utils/diagram-viewport.ts';
+import { describe, expect, it } from 'vitest';
+
+// where the diagram point (x, y) shows on screen
+function onScreen(view: DiagramView, x: number, y: number) {
+	return { x: x * view.scale + view.x, y: y * view.scale + view.y };
+}
+
+// the diagram point under the screen point (x, y)
+function underScreen(view: DiagramView, x: number, y: number) {
+	return { x: (x - view.x) / view.scale, y: (y - view.y) / view.scale };
+}
+
+describe('zoomAt', () => {
+	it('keeps the diagram point under the zoom point in place', () => {
+		const view = { scale: 1.5, x: -120, y: 40 };
+		const under = underScreen(view, 300, 200);
+		const zoomed = zoomAt(view, 2, 300, 200);
+
+		expect(zoomed.scale).toBe(3);
+		expect(onScreen(zoomed, under.x, under.y).x).toBeCloseTo(300);
+		expect(onScreen(zoomed, under.x, under.y).y).toBeCloseTo(200);
+	});
+
+	it('clamps the scale and still keeps the point in place', () => {
+		const view = { scale: 8, x: 10, y: 10 };
+		const under = underScreen(view, 50, 60);
+		const zoomed = zoomAt(view, 4, 50, 60);
+
+		expect(zoomed.scale).toBe(DIAGRAM_MAX_SCALE);
+		expect(onScreen(zoomed, under.x, under.y).x).toBeCloseTo(50);
+		expect(zoomAt({ scale: 0.2, x: 0, y: 0 }, 0.1, 0, 0).scale).toBe(DIAGRAM_MIN_SCALE);
+	});
+});
+
+describe('zoomAtCenter', () => {
+	it('zooms around the middle of the viewport after a pan, not the diagram origin', () => {
+		const viewport = { height: 600, width: 800 };
+		// zoomed in and panned away from where the diagram started
+		const panned = { scale: 2, x: -500, y: -300 };
+		const under = underScreen(panned, 400, 300);
+		const out = zoomAtCenter(panned, 0.5, viewport);
+
+		expect(out.scale).toBe(1);
+		expect(onScreen(out, under.x, under.y).x).toBeCloseTo(400);
+		expect(onScreen(out, under.x, under.y).y).toBeCloseTo(300);
+	});
+
+	it('zooming in and out again returns to the same view', () => {
+		const viewport = { height: 600, width: 800 };
+		const view = { scale: 1.3, x: 25, y: -70 };
+		const back = zoomAtCenter(zoomAtCenter(view, 1.25, viewport), 1 / 1.25, viewport);
+
+		expect(back.scale).toBeCloseTo(view.scale);
+		expect(back.x).toBeCloseTo(view.x);
+		expect(back.y).toBeCloseTo(view.y);
+	});
+});
+
+describe('fitView', () => {
+	it('shrinks a large diagram to fit and centers it', () => {
+		const view = fitView({ height: 500, width: 2000 }, { height: 800, width: 1000 }, 50);
+
+		expect(view.scale).toBeCloseTo(0.45);
+		expect(view.x).toBeCloseTo(50);
+		expect(view.y).toBeCloseTo((800 - 500 * 0.45) / 2);
+	});
+
+	it('grows a small diagram no more than the fit cap', () => {
+		expect(fitView({ height: 50, width: 100 }, { height: 800, width: 1000 }).scale).toBe(
+			DIAGRAM_MAX_FIT_SCALE
+		);
+	});
+
+	it('leaves an unmeasured diagram at its own size', () => {
+		expect(fitView({ height: 0, width: 0 }, { height: 800, width: 1000 })).toEqual({
+			scale: 1,
+			x: 0,
+			y: 0
+		});
+	});
+});
+
+describe('wheelZoomFactor', () => {
+	it('zooms in on a wheel up and out on a wheel down', () => {
+		expect(wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: -100 })).toBeGreaterThan(1);
+		expect(wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: 100 })).toBeLessThan(1);
+	});
+
+	it('a wheel step up and back down cancel out', () => {
+		const up = wheelZoomFactor({ ctrlKey: false, deltaMode: 1, deltaY: -3 });
+		const down = wheelZoomFactor({ ctrlKey: false, deltaMode: 1, deltaY: 3 });
+
+		expect(up * down).toBeCloseTo(1);
+	});
+
+	it('a trackpad pinch zooms faster per pixel than a wheel', () => {
+		expect(wheelZoomFactor({ ctrlKey: true, deltaMode: 0, deltaY: -10 })).toBeGreaterThan(
+			wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: -10 })
+		);
+	});
+});