@workflow/web-shared 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/components/trace-viewer/components/minimap.js

@@ -0,0 +1,337 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useCallback, useEffect, useLayoutEffect, useRef, useState, } from 'react';
+import { cn } from '../../../lib/cn';
+import { formatDurationPrecise, getHighResInMs } from '../util/timing';
+import { clampViewportToRoot, isSpanErrored, wheelDeltaToPixels, wheelZoomScaleFactor, } from '../utils';
+import { TIMELINE_PADDING_PX } from './timeline';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const CANVAS_PAD_Y_PX = 6;
+const MIN_LINE_HEIGHT_PX = 1.5;
+const MAX_LINE_HEIGHT_PX = 3;
+const MIN_LINE_WIDTH_PX = 2;
+/** Pointer travel below this is treated as a click rather than a drag. */
+const CLICK_DRAG_THRESHOLD_PX = 3;
+const MIN_BRUSH_WIDTH_PX = 6;
+/** Fraction of the current window that arrow keys pan by. */
+const KEYBOARD_PAN_FRACTION = 0.1;
+/**
+ * Line colors resolved from the design-system tokens on the container, so the
+ * canvas follows the active theme. Runs and steps carry the accent hues;
+ * passive spans (hooks, sleeps) stay gray like their event-list icons.
+ */
+const RESOURCE_LINE_TOKENS = {
+    run: '--ds-blue-400',
+    step: '--ds-green-400',
+    hook: '--ds-gray-400',
+    sleep: '--ds-gray-400',
+};
+const DEFAULT_LINE_TOKEN = '--ds-gray-400';
+const ERROR_LINE_TOKEN = '--ds-red-400';
+function computeDensityLayout(spans, rootStartMs, rootDurationMs, contentWidth, contentHeight) {
+    const count = spans.length;
+    const lineHeight = Math.max(MIN_LINE_HEIGHT_PX, Math.min(MAX_LINE_HEIGHT_PX, contentHeight / count));
+    // Distribute rows across the strip; never spread a handful of spans further
+    // apart than one line + 1px gap.
+    const rowStep = count > 1
+        ? Math.min((contentHeight - lineHeight) / (count - 1), lineHeight + 1)
+        : 0;
+    const rectsByToken = new Map();
+    spans.forEach((span, index) => {
+        const token = isSpanErrored(span)
+            ? ERROR_LINE_TOKEN
+            : (RESOURCE_LINE_TOKENS[span.resource] ?? DEFAULT_LINE_TOKEN);
+        const startMs = getHighResInMs(span.startTime);
+        const endMs = getHighResInMs(span.endTime);
+        const x = TIMELINE_PADDING_PX +
+            ((startMs - rootStartMs) / rootDurationMs) * contentWidth;
+        const w = Math.max(MIN_LINE_WIDTH_PX, ((endMs - startMs) / rootDurationMs) * contentWidth);
+        const y = CANVAS_PAD_Y_PX + index * rowStep;
+        const rects = rectsByToken.get(token) ?? [];
+        rects.push([x, y, w]);
+        rectsByToken.set(token, rects);
+    });
+    return { lineHeight, rectsByToken };
+}
+// ---------------------------------------------------------------------------
+// Hooks
+// ---------------------------------------------------------------------------
+/** Track the display's device pixel ratio (changes when moving monitors). */
+function useDpr() {
+    const [dpr, setDpr] = useState(1);
+    useLayoutEffect(() => {
+        const onChange = () => setDpr(window.devicePixelRatio || 1);
+        const media = matchMedia(`(resolution: ${dpr}dppx)`);
+        media.addEventListener('change', onChange);
+        onChange();
+        return () => media.removeEventListener('change', onChange);
+    }, [dpr]);
+    return dpr;
+}
+/** Bump a counter when the theme (html class/data-theme) changes. */
+function useThemeVersion() {
+    const [version, setVersion] = useState(0);
+    useEffect(() => {
+        const observer = new MutationObserver(() => setVersion((v) => v + 1));
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: ['class', 'data-theme', 'style'],
+        });
+        return () => observer.disconnect();
+    }, []);
+    return version;
+}
+export const Minimap = memo(function Minimap({ spans, root, viewport, minViewportMs, onViewportChange, onAnimateTo, }) {
+    const { startTime: rootStartMs, endTime: rootEndMs, duration: rootDurationMs, } = root;
+    const containerRef = useRef(null);
+    const canvasRef = useRef(null);
+    const dpr = useDpr();
+    const themeVersion = useThemeVersion();
+    // Latest viewport for pointer handlers, without re-binding them per frame.
+    const viewportRef = useRef(viewport);
+    viewportRef.current = viewport;
+    const [drag, setDrag] = useState(null);
+    const [selection, setSelection] = useState(null);
+    const xToTime = useCallback((x, contentWidth) => {
+        if (contentWidth <= 0)
+            return rootStartMs;
+        const fraction = (x - TIMELINE_PADDING_PX) / contentWidth;
+        return Math.min(Math.max(rootStartMs + fraction * rootDurationMs, rootStartMs), rootEndMs);
+    }, [rootStartMs, rootDurationMs, rootEndMs]);
+    const clamp = useCallback((next) => clampViewportToRoot(next, rootStartMs, rootEndMs, minViewportMs), [rootStartMs, rootEndMs, minViewportMs]);
+    // Density canvas: one thin line per span across the full run. Sizing is
+    // read live and redraws run straight from the ResizeObserver (which fires
+    // before paint), so layout changes — e.g. the detail panel opening — never
+    // paint a frame with a stale, stretched bitmap.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: themeVersion is a redraw trigger — the canvas re-resolves its token colors when the theme flips
+    useLayoutEffect(() => {
+        const canvas = canvasRef.current;
+        const container = containerRef.current;
+        const ctx = canvas?.getContext('2d');
+        if (!canvas || !container || !ctx)
+            return;
+        const draw = () => {
+            const width = canvas.clientWidth;
+            const height = canvas.clientHeight;
+            const contentWidth = width - TIMELINE_PADDING_PX * 2;
+            if (width <= 0 || height <= 0 || contentWidth <= 0)
+                return;
+            canvas.width = Math.round(width * dpr);
+            canvas.height = Math.round(height * dpr);
+            ctx.scale(dpr, dpr);
+            ctx.clearRect(0, 0, width, height);
+            if (spans.length === 0 || rootDurationMs <= 0)
+                return;
+            const { lineHeight, rectsByToken } = computeDensityLayout(spans, rootStartMs, rootDurationMs, contentWidth, height - CANVAS_PAD_Y_PX * 2);
+            const style = getComputedStyle(container);
+            const drawToken = (token) => {
+                const rects = rectsByToken.get(token);
+                if (!rects)
+                    return;
+                ctx.fillStyle =
+                    style.getPropertyValue(token).trim() || 'rgb(160,160,160)';
+                ctx.beginPath();
+                for (const [x, y, w] of rects) {
+                    ctx.roundRect(x, y, w, lineHeight, lineHeight / 2);
+                }
+                ctx.fill();
+            };
+            // Errored spans are drawn last so red never disappears under neighbors.
+            for (const token of rectsByToken.keys()) {
+                if (token !== ERROR_LINE_TOKEN)
+                    drawToken(token);
+            }
+            drawToken(ERROR_LINE_TOKEN);
+        };
+        draw();
+        const observer = new ResizeObserver(draw);
+        observer.observe(container);
+        return () => observer.disconnect();
+    }, [spans, rootStartMs, rootDurationMs, dpr, themeVersion]);
+    // Content width is read from the live rect at event time, so pointer math
+    // stays exact while the strip is being resized mid-gesture.
+    const pointerFrame = useCallback((e) => {
+        const rect = e.currentTarget.getBoundingClientRect();
+        return {
+            x: e.clientX - rect.left,
+            cw: rect.width - TIMELINE_PADDING_PX * 2,
+        };
+    }, []);
+    const resolveDragState = useCallback((target, x, cw) => {
+        if (target.closest('[data-minimap-handle="left"]')) {
+            return { mode: 'resize-left' };
+        }
+        if (target.closest('[data-minimap-handle="right"]')) {
+            return { mode: 'resize-right' };
+        }
+        // Panning a full-extent window is a no-op, so let a drag on the brush
+        // start a selection instead — the natural first gesture on the map.
+        const { start, end } = viewportRef.current;
+        const isFullExtent = start - rootStartMs < rootDurationMs * 0.001 &&
+            rootEndMs - end < rootDurationMs * 0.001;
+        if (target.closest('[data-minimap-brush]') && !isFullExtent) {
+            return { mode: 'pan', grabOffsetMs: xToTime(x, cw) - start };
+        }
+        return { mode: 'select', originX: x, originMs: xToTime(x, cw) };
+    }, [xToTime, rootStartMs, rootDurationMs, rootEndMs]);
+    const handlePointerDown = useCallback((e) => {
+        if (e.button !== 0)
+            return;
+        const { x, cw } = pointerFrame(e);
+        if (cw <= 0)
+            return;
+        e.currentTarget.setPointerCapture(e.pointerId);
+        setDrag(resolveDragState(e.target, x, cw));
+    }, [pointerFrame, resolveDragState]);
+    const handlePointerMove = useCallback((e) => {
+        if (!drag)
+            return;
+        const { x, cw } = pointerFrame(e);
+        const t = xToTime(x, cw);
+        const { start, end } = viewportRef.current;
+        if (drag.mode === 'pan') {
+            const duration = end - start;
+            onViewportChange(clamp({
+                start: t - drag.grabOffsetMs,
+                end: t - drag.grabOffsetMs + duration,
+            }));
+        }
+        else if (drag.mode === 'resize-left') {
+            onViewportChange({ start: Math.min(t, end - minViewportMs), end });
+        }
+        else if (drag.mode === 'resize-right') {
+            onViewportChange({ start, end: Math.max(t, start + minViewportMs) });
+        }
+        else if (selection ||
+            Math.abs(x - drag.originX) > CLICK_DRAG_THRESHOLD_PX) {
+            setSelection({
+                x0: Math.min(drag.originX, x),
+                x1: Math.max(drag.originX, x),
+            });
+        }
+    }, [
+        drag,
+        selection,
+        pointerFrame,
+        xToTime,
+        onViewportChange,
+        clamp,
+        minViewportMs,
+    ]);
+    const endDrag = useCallback((e) => {
+        if (!drag)
+            return;
+        if (drag.mode === 'select') {
+            const { x, cw } = pointerFrame(e);
+            const t = xToTime(x, cw);
+            if (selection) {
+                onAnimateTo(clamp({
+                    start: Math.min(drag.originMs, t),
+                    end: Math.max(drag.originMs, t),
+                }));
+            }
+            else {
+                // Plain click: keep the current zoom, center the window there.
+                const { start, end } = viewportRef.current;
+                const duration = end - start;
+                onAnimateTo(clamp({ start: t - duration / 2, end: t + duration / 2 }));
+            }
+        }
+        setSelection(null);
+        setDrag(null);
+    }, [drag, selection, pointerFrame, xToTime, onAnimateTo, clamp]);
+    const handleLostPointerCapture = useCallback(() => {
+        setSelection(null);
+        setDrag(null);
+    }, []);
+    const handleDoubleClick = useCallback(() => {
+        onAnimateTo({ start: rootStartMs, end: rootEndMs });
+    }, [onAnimateTo, rootStartMs, rootEndMs]);
+    // Wheel: same gestures as the timeline, mapped through the full extent.
+    useEffect(() => {
+        const el = containerRef.current;
+        if (!el || rootDurationMs <= 0)
+            return;
+        // The minimap's x axis is the full run, so zoom around the absolute time
+        // under the cursor rather than a viewport fraction.
+        const zoomAtCursor = (e, cw, left) => {
+            const scaleFactor = wheelZoomScaleFactor(e);
+            const { start, end } = viewportRef.current;
+            const duration = end - start;
+            const cursorFraction = Math.min(Math.max((e.clientX - left - TIMELINE_PADDING_PX) / cw, 0), 1);
+            const cursorMs = rootStartMs + cursorFraction * rootDurationMs;
+            const anchor = Math.min(Math.max(duration > 0 ? (cursorMs - start) / duration : 0.5, 0), 1);
+            const newDuration = duration * scaleFactor;
+            onViewportChange(clamp({
+                start: cursorMs - anchor * newDuration,
+                end: cursorMs + (1 - anchor) * newDuration,
+            }));
+        };
+        // Pan in map coordinates: one map pixel is one full-extent fraction.
+        const panByMapPixels = (e, cw) => {
+            const dx = wheelDeltaToPixels(e.deltaX, e.deltaMode);
+            const panMs = (dx / cw) * rootDurationMs;
+            const { start, end } = viewportRef.current;
+            onViewportChange(clamp({ start: start + panMs, end: end + panMs }));
+        };
+        const onWheel = (e) => {
+            const isZoomGesture = e.ctrlKey || e.metaKey;
+            const hasDeltaX = Math.abs(e.deltaX) > Math.abs(e.deltaY);
+            if (!isZoomGesture && !hasDeltaX)
+                return;
+            e.preventDefault();
+            const rect = el.getBoundingClientRect();
+            const cw = rect.width - TIMELINE_PADDING_PX * 2;
+            if (cw <= 0)
+                return;
+            if (isZoomGesture)
+                zoomAtCursor(e, cw, rect.left);
+            else
+                panByMapPixels(e, cw);
+        };
+        el.addEventListener('wheel', onWheel, { passive: false });
+        return () => el.removeEventListener('wheel', onWheel);
+    }, [rootStartMs, rootDurationMs, onViewportChange, clamp]);
+    // Arrow keys pan the focused brush; Home/End jump to the ends.
+    const handleKeyDown = useCallback((e) => {
+        const { start, end } = viewportRef.current;
+        const duration = end - start;
+        const pan = duration * KEYBOARD_PAN_FRACTION;
+        if (e.key === 'ArrowLeft') {
+            onViewportChange(clamp({ start: start - pan, end: end - pan }));
+        }
+        else if (e.key === 'ArrowRight') {
+            onViewportChange(clamp({ start: start + pan, end: end + pan }));
+        }
+        else if (e.key === 'Home') {
+            onViewportChange(clamp({ start: rootStartMs, end: rootStartMs + duration }));
+        }
+        else if (e.key === 'End') {
+            onViewportChange(clamp({ start: rootEndMs - duration, end: rootEndMs }));
+        }
+        else {
+            return;
+        }
+        e.preventDefault();
+    }, [onViewportChange, clamp, rootStartMs, rootEndMs]);
+    // Brush geometry in CSS calc() from time fractions, so the thumb reflows in
+    // the same frame as any container resize instead of lagging a state update.
+    const startFraction = (viewport.start - rootStartMs) / rootDurationMs;
+    const endFraction = (viewport.end - rootStartMs) / rootDurationMs;
+    const trackWidth = `(100% - ${TIMELINE_PADDING_PX * 2}px)`;
+    const brushStyle = {
+        left: `calc(${TIMELINE_PADDING_PX}px + ${startFraction} * ${trackWidth})`,
+        width: `max(${MIN_BRUSH_WIDTH_PX}px, calc(${endFraction - startFraction} * ${trackWidth}))`,
+    };
+    const viewDuration = viewport.end - viewport.start;
+    const scrollableMs = Math.max(rootDurationMs - viewDuration, 0);
+    const scrollPercent = scrollableMs > 0
+        ? Math.round(((viewport.start - rootStartMs) / scrollableMs) * 100)
+        : 0;
+    return (_jsxs("div", { ref: containerRef, className: cn('relative h-10 min-h-10 w-full border-b border-gray-alpha-400 bg-background-100 select-none overflow-hidden touch-none', drag?.mode === 'select' && 'cursor-crosshair'), onPointerDown: handlePointerDown, onPointerMove: handlePointerMove, onPointerUp: endDrag, onPointerCancel: endDrag, onLostPointerCapture: handleLostPointerCapture, onDoubleClick: handleDoubleClick, children: [_jsx("canvas", { ref: canvasRef, "aria-hidden": true, className: "pointer-events-none absolute inset-0 h-full w-full mix-blend-multiply [.dark-theme_&]:mix-blend-screen [.dark_&]:mix-blend-screen [[data-theme=dark]_&]:mix-blend-screen" }), selection ? (_jsx("div", { "aria-hidden": true, className: "pointer-events-none absolute inset-y-0 border border-blue-500 bg-blue-300 opacity-40", style: { left: selection.x0, width: selection.x1 - selection.x0 } })) : null, _jsxs("div", { "data-minimap-brush": true, role: "scrollbar", "aria-controls": "trace-timeline", "aria-orientation": "horizontal", "aria-valuemin": 0, "aria-valuemax": 100, "aria-valuenow": scrollPercent, "aria-valuetext": `Viewing ${formatDurationPrecise(viewport.start - rootStartMs)} to ${formatDurationPrecise(viewport.end - rootStartMs)} of ${formatDurationPrecise(rootDurationMs)}`, "aria-label": "Timeline overview", tabIndex: 0, onKeyDown: handleKeyDown, className: cn(
+                // Glass thumb, matching the legacy trace viewer's map window.
+                'group/minimap-brush absolute top-0.5 bottom-0.5 rounded-[3px] border border-gray-alpha-400 bg-gray-alpha-200 shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-[var(--ds-focus-color)]', drag?.mode === 'pan' ? 'cursor-grabbing' : 'cursor-grab'), style: brushStyle, children: [_jsx("div", { "data-minimap-handle": "left", className: "absolute inset-y-0 -left-1 flex w-2.5 cursor-ew-resize items-center justify-center", children: _jsx("span", { className: cn('h-3.5 w-[3px] rounded-full bg-gray-600 opacity-0 transition-opacity group-hover/minimap-brush:opacity-100 group-focus-visible/minimap-brush:opacity-100', drag && 'opacity-100') }) }), _jsx("div", { "data-minimap-handle": "right", className: "absolute inset-y-0 -right-1 flex w-2.5 cursor-ew-resize items-center justify-center", children: _jsx("span", { className: cn('h-3.5 w-[3px] rounded-full bg-gray-600 opacity-0 transition-opacity group-hover/minimap-brush:opacity-100 group-focus-visible/minimap-brush:opacity-100', drag && 'opacity-100') }) })] })] }));
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"minimap.js","sourceRoot":"","sources":["../../../../src/components/trace-viewer/components/minimap.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport type { ReactNode } from 'react';\nimport {\n  memo,\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useState,\n} from 'react';\nimport { cn } from '../../../lib/cn';\nimport type { Span } from '../types';\nimport { formatDurationPrecise, getHighResInMs } from '../util/timing';\nimport {\n  clampViewportToRoot,\n  isSpanErrored,\n  type RootBounds,\n  type ViewportRange,\n  wheelDeltaToPixels,\n  wheelZoomScaleFactor,\n} from '../utils';\nimport { TIMELINE_PADDING_PX } from './timeline';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\nconst CANVAS_PAD_Y_PX = 6;\nconst MIN_LINE_HEIGHT_PX = 1.5;\nconst MAX_LINE_HEIGHT_PX = 3;\nconst MIN_LINE_WIDTH_PX = 2;\n/** Pointer travel below this is treated as a click rather than a drag. */\nconst CLICK_DRAG_THRESHOLD_PX = 3;\nconst MIN_BRUSH_WIDTH_PX = 6;\n/** Fraction of the current window that arrow keys pan by. */\nconst KEYBOARD_PAN_FRACTION = 0.1;\n\n/**\n * Line colors resolved from the design-system tokens on the container, so the\n * canvas follows the active theme. Runs and steps carry the accent hues;\n * passive spans (hooks, sleeps) stay gray like their event-list icons.\n */\nconst RESOURCE_LINE_TOKENS: Record<string, string> = {\n  run: '--ds-blue-400',\n  step: '--ds-green-400',\n  hook: '--ds-gray-400',\n  sleep: '--ds-gray-400',\n};\nconst DEFAULT_LINE_TOKEN = '--ds-gray-400';\nconst ERROR_LINE_TOKEN = '--ds-red-400';\n\n// ---------------------------------------------------------------------------\n// Density layer geometry\n// ---------------------------------------------------------------------------\n\ninterface DensityLayout {\n  lineHeight: number;\n  /** [x, y, width] rects grouped by color token, one fill pass per color. */\n  rectsByToken: Map<string, [number, number, number][]>;\n}\n\nfunction computeDensityLayout(\n  spans: Span[],\n  rootStartMs: number,\n  rootDurationMs: number,\n  contentWidth: number,\n  contentHeight: number\n): DensityLayout {\n  const count = spans.length;\n  const lineHeight = Math.max(\n    MIN_LINE_HEIGHT_PX,\n    Math.min(MAX_LINE_HEIGHT_PX, contentHeight / count)\n  );\n  // Distribute rows across the strip; never spread a handful of spans further\n  // apart than one line + 1px gap.\n  const rowStep =\n    count > 1\n      ? Math.min((contentHeight - lineHeight) / (count - 1), lineHeight + 1)\n      : 0;\n\n  const rectsByToken = new Map<string, [number, number, number][]>();\n  spans.forEach((span, index) => {\n    const token = isSpanErrored(span)\n      ? ERROR_LINE_TOKEN\n      : (RESOURCE_LINE_TOKENS[span.resource] ?? DEFAULT_LINE_TOKEN);\n    const startMs = getHighResInMs(span.startTime);\n    const endMs = getHighResInMs(span.endTime);\n    const x =\n      TIMELINE_PADDING_PX +\n      ((startMs - rootStartMs) / rootDurationMs) * contentWidth;\n    const w = Math.max(\n      MIN_LINE_WIDTH_PX,\n      ((endMs - startMs) / rootDurationMs) * contentWidth\n    );\n    const y = CANVAS_PAD_Y_PX + index * rowStep;\n    const rects = rectsByToken.get(token) ?? [];\n    rects.push([x, y, w]);\n    rectsByToken.set(token, rects);\n  });\n\n  return { lineHeight, rectsByToken };\n}\n\n// ---------------------------------------------------------------------------\n// Hooks\n// ---------------------------------------------------------------------------\n\n/** Track the display's device pixel ratio (changes when moving monitors). */\nfunction useDpr(): number {\n  const [dpr, setDpr] = useState(1);\n  useLayoutEffect(() => {\n    const onChange = (): void => setDpr(window.devicePixelRatio || 1);\n    const media = matchMedia(`(resolution: ${dpr}dppx)`);\n    media.addEventListener('change', onChange);\n    onChange();\n    return () => media.removeEventListener('change', onChange);\n  }, [dpr]);\n  return dpr;\n}\n\n/** Bump a counter when the theme (html class/data-theme) changes. */\nfunction useThemeVersion(): number {\n  const [version, setVersion] = useState(0);\n  useEffect(() => {\n    const observer = new MutationObserver(() => setVersion((v) => v + 1));\n    observer.observe(document.documentElement, {\n      attributes: true,\n      attributeFilter: ['class', 'data-theme', 'style'],\n    });\n    return () => observer.disconnect();\n  }, []);\n  return version;\n}\n\n// ---------------------------------------------------------------------------\n// Minimap\n// ---------------------------------------------------------------------------\n\ntype DragState =\n  | { mode: 'pan'; grabOffsetMs: number }\n  | { mode: 'resize-left' }\n  | { mode: 'resize-right' }\n  | { mode: 'select'; originX: number; originMs: number };\n\nexport const Minimap = memo(function Minimap({\n  spans,\n  root,\n  viewport,\n  minViewportMs,\n  onViewportChange,\n  onAnimateTo,\n}: {\n  spans: Span[];\n  root: RootBounds;\n  viewport: ViewportRange;\n  minViewportMs: number;\n  /** Immediate viewport update (used while dragging). */\n  onViewportChange: (viewport: ViewportRange) => void;\n  /** Eased viewport transition (used for click-to-jump and selections). */\n  onAnimateTo: (viewport: ViewportRange) => void;\n}): ReactNode {\n  const {\n    startTime: rootStartMs,\n    endTime: rootEndMs,\n    duration: rootDurationMs,\n  } = root;\n\n  const containerRef = useRef<HTMLDivElement>(null);\n  const canvasRef = useRef<HTMLCanvasElement>(null);\n  const dpr = useDpr();\n  const themeVersion = useThemeVersion();\n\n  // Latest viewport for pointer handlers, without re-binding them per frame.\n  const viewportRef = useRef<ViewportRange>(viewport);\n  viewportRef.current = viewport;\n\n  const [drag, setDrag] = useState<DragState | null>(null);\n  const [selection, setSelection] = useState<{ x0: number; x1: number } | null>(\n    null\n  );\n\n  const xToTime = useCallback(\n    (x: number, contentWidth: number): number => {\n      if (contentWidth <= 0) return rootStartMs;\n      const fraction = (x - TIMELINE_PADDING_PX) / contentWidth;\n      return Math.min(\n        Math.max(rootStartMs + fraction * rootDurationMs, rootStartMs),\n        rootEndMs\n      );\n    },\n    [rootStartMs, rootDurationMs, rootEndMs]\n  );\n\n  const clamp = useCallback(\n    (next: ViewportRange): ViewportRange =>\n      clampViewportToRoot(next, rootStartMs, rootEndMs, minViewportMs),\n    [rootStartMs, rootEndMs, minViewportMs]\n  );\n\n  // Density canvas: one thin line per span across the full run. Sizing is\n  // read live and redraws run straight from the ResizeObserver (which fires\n  // before paint), so layout changes — e.g. the detail panel opening — never\n  // paint a frame with a stale, stretched bitmap.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: themeVersion is a redraw trigger — the canvas re-resolves its token colors when the theme flips\n  useLayoutEffect(() => {\n    const canvas = canvasRef.current;\n    const container = containerRef.current;\n    const ctx = canvas?.getContext('2d');\n    if (!canvas || !container || !ctx) return;\n\n    const draw = (): void => {\n      const width = canvas.clientWidth;\n      const height = canvas.clientHeight;\n      const contentWidth = width - TIMELINE_PADDING_PX * 2;\n      if (width <= 0 || height <= 0 || contentWidth <= 0) return;\n\n      canvas.width = Math.round(width * dpr);\n      canvas.height = Math.round(height * dpr);\n      ctx.scale(dpr, dpr);\n      ctx.clearRect(0, 0, width, height);\n      if (spans.length === 0 || rootDurationMs <= 0) return;\n\n      const { lineHeight, rectsByToken } = computeDensityLayout(\n        spans,\n        rootStartMs,\n        rootDurationMs,\n        contentWidth,\n        height - CANVAS_PAD_Y_PX * 2\n      );\n\n      const style = getComputedStyle(container);\n      const drawToken = (token: string): void => {\n        const rects = rectsByToken.get(token);\n        if (!rects) return;\n        ctx.fillStyle =\n          style.getPropertyValue(token).trim() || 'rgb(160,160,160)';\n        ctx.beginPath();\n        for (const [x, y, w] of rects) {\n          ctx.roundRect(x, y, w, lineHeight, lineHeight / 2);\n        }\n        ctx.fill();\n      };\n      // Errored spans are drawn last so red never disappears under neighbors.\n      for (const token of rectsByToken.keys()) {\n        if (token !== ERROR_LINE_TOKEN) drawToken(token);\n      }\n      drawToken(ERROR_LINE_TOKEN);\n    };\n\n    draw();\n    const observer = new ResizeObserver(draw);\n    observer.observe(container);\n    return () => observer.disconnect();\n  }, [spans, rootStartMs, rootDurationMs, dpr, themeVersion]);\n\n  // Content width is read from the live rect at event time, so pointer math\n  // stays exact while the strip is being resized mid-gesture.\n  const pointerFrame = useCallback(\n    (e: React.PointerEvent<HTMLDivElement>): { x: number; cw: number } => {\n      const rect = e.currentTarget.getBoundingClientRect();\n      return {\n        x: e.clientX - rect.left,\n        cw: rect.width - TIMELINE_PADDING_PX * 2,\n      };\n    },\n    []\n  );\n\n  const resolveDragState = useCallback(\n    (target: HTMLElement, x: number, cw: number): DragState => {\n      if (target.closest('[data-minimap-handle=\"left\"]')) {\n        return { mode: 'resize-left' };\n      }\n      if (target.closest('[data-minimap-handle=\"right\"]')) {\n        return { mode: 'resize-right' };\n      }\n      // Panning a full-extent window is a no-op, so let a drag on the brush\n      // start a selection instead — the natural first gesture on the map.\n      const { start, end } = viewportRef.current;\n      const isFullExtent =\n        start - rootStartMs < rootDurationMs * 0.001 &&\n        rootEndMs - end < rootDurationMs * 0.001;\n      if (target.closest('[data-minimap-brush]') && !isFullExtent) {\n        return { mode: 'pan', grabOffsetMs: xToTime(x, cw) - start };\n      }\n      return { mode: 'select', originX: x, originMs: xToTime(x, cw) };\n    },\n    [xToTime, rootStartMs, rootDurationMs, rootEndMs]\n  );\n\n  const handlePointerDown = useCallback(\n    (e: React.PointerEvent<HTMLDivElement>) => {\n      if (e.button !== 0) return;\n      const { x, cw } = pointerFrame(e);\n      if (cw <= 0) return;\n      e.currentTarget.setPointerCapture(e.pointerId);\n      setDrag(resolveDragState(e.target as HTMLElement, x, cw));\n    },\n    [pointerFrame, resolveDragState]\n  );\n\n  const handlePointerMove = useCallback(\n    (e: React.PointerEvent<HTMLDivElement>) => {\n      if (!drag) return;\n      const { x, cw } = pointerFrame(e);\n      const t = xToTime(x, cw);\n      const { start, end } = viewportRef.current;\n\n      if (drag.mode === 'pan') {\n        const duration = end - start;\n        onViewportChange(\n          clamp({\n            start: t - drag.grabOffsetMs,\n            end: t - drag.grabOffsetMs + duration,\n          })\n        );\n      } else if (drag.mode === 'resize-left') {\n        onViewportChange({ start: Math.min(t, end - minViewportMs), end });\n      } else if (drag.mode === 'resize-right') {\n        onViewportChange({ start, end: Math.max(t, start + minViewportMs) });\n      } else if (\n        selection ||\n        Math.abs(x - drag.originX) > CLICK_DRAG_THRESHOLD_PX\n      ) {\n        setSelection({\n          x0: Math.min(drag.originX, x),\n          x1: Math.max(drag.originX, x),\n        });\n      }\n    },\n    [\n      drag,\n      selection,\n      pointerFrame,\n      xToTime,\n      onViewportChange,\n      clamp,\n      minViewportMs,\n    ]\n  );\n\n  const endDrag = useCallback(\n    (e: React.PointerEvent<HTMLDivElement>) => {\n      if (!drag) return;\n      if (drag.mode === 'select') {\n        const { x, cw } = pointerFrame(e);\n        const t = xToTime(x, cw);\n        if (selection) {\n          onAnimateTo(\n            clamp({\n              start: Math.min(drag.originMs, t),\n              end: Math.max(drag.originMs, t),\n            })\n          );\n        } else {\n          // Plain click: keep the current zoom, center the window there.\n          const { start, end } = viewportRef.current;\n          const duration = end - start;\n          onAnimateTo(\n            clamp({ start: t - duration / 2, end: t + duration / 2 })\n          );\n        }\n      }\n      setSelection(null);\n      setDrag(null);\n    },\n    [drag, selection, pointerFrame, xToTime, onAnimateTo, clamp]\n  );\n\n  const handleLostPointerCapture = useCallback(() => {\n    setSelection(null);\n    setDrag(null);\n  }, []);\n\n  const handleDoubleClick = useCallback(() => {\n    onAnimateTo({ start: rootStartMs, end: rootEndMs });\n  }, [onAnimateTo, rootStartMs, rootEndMs]);\n\n  // Wheel: same gestures as the timeline, mapped through the full extent.\n  useEffect(() => {\n    const el = containerRef.current;\n    if (!el || rootDurationMs <= 0) return;\n\n    // The minimap's x axis is the full run, so zoom around the absolute time\n    // under the cursor rather than a viewport fraction.\n    const zoomAtCursor = (e: WheelEvent, cw: number, left: number): void => {\n      const scaleFactor = wheelZoomScaleFactor(e);\n      const { start, end } = viewportRef.current;\n      const duration = end - start;\n      const cursorFraction = Math.min(\n        Math.max((e.clientX - left - TIMELINE_PADDING_PX) / cw, 0),\n        1\n      );\n      const cursorMs = rootStartMs + cursorFraction * rootDurationMs;\n      const anchor = Math.min(\n        Math.max(duration > 0 ? (cursorMs - start) / duration : 0.5, 0),\n        1\n      );\n      const newDuration = duration * scaleFactor;\n      onViewportChange(\n        clamp({\n          start: cursorMs - anchor * newDuration,\n          end: cursorMs + (1 - anchor) * newDuration,\n        })\n      );\n    };\n\n    // Pan in map coordinates: one map pixel is one full-extent fraction.\n    const panByMapPixels = (e: WheelEvent, cw: number): void => {\n      const dx = wheelDeltaToPixels(e.deltaX, e.deltaMode);\n      const panMs = (dx / cw) * rootDurationMs;\n      const { start, end } = viewportRef.current;\n      onViewportChange(clamp({ start: start + panMs, end: end + panMs }));\n    };\n\n    const onWheel = (e: WheelEvent): void => {\n      const isZoomGesture = e.ctrlKey || e.metaKey;\n      const hasDeltaX = Math.abs(e.deltaX) > Math.abs(e.deltaY);\n      if (!isZoomGesture && !hasDeltaX) return;\n      e.preventDefault();\n\n      const rect = el.getBoundingClientRect();\n      const cw = rect.width - TIMELINE_PADDING_PX * 2;\n      if (cw <= 0) return;\n      if (isZoomGesture) zoomAtCursor(e, cw, rect.left);\n      else panByMapPixels(e, cw);\n    };\n\n    el.addEventListener('wheel', onWheel, { passive: false });\n    return () => el.removeEventListener('wheel', onWheel);\n  }, [rootStartMs, rootDurationMs, onViewportChange, clamp]);\n\n  // Arrow keys pan the focused brush; Home/End jump to the ends.\n  const handleKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLDivElement>) => {\n      const { start, end } = viewportRef.current;\n      const duration = end - start;\n      const pan = duration * KEYBOARD_PAN_FRACTION;\n      if (e.key === 'ArrowLeft') {\n        onViewportChange(clamp({ start: start - pan, end: end - pan }));\n      } else if (e.key === 'ArrowRight') {\n        onViewportChange(clamp({ start: start + pan, end: end + pan }));\n      } else if (e.key === 'Home') {\n        onViewportChange(\n          clamp({ start: rootStartMs, end: rootStartMs + duration })\n        );\n      } else if (e.key === 'End') {\n        onViewportChange(\n          clamp({ start: rootEndMs - duration, end: rootEndMs })\n        );\n      } else {\n        return;\n      }\n      e.preventDefault();\n    },\n    [onViewportChange, clamp, rootStartMs, rootEndMs]\n  );\n\n  // Brush geometry in CSS calc() from time fractions, so the thumb reflows in\n  // the same frame as any container resize instead of lagging a state update.\n  const startFraction = (viewport.start - rootStartMs) / rootDurationMs;\n  const endFraction = (viewport.end - rootStartMs) / rootDurationMs;\n  const trackWidth = `(100% - ${TIMELINE_PADDING_PX * 2}px)`;\n  const brushStyle = {\n    left: `calc(${TIMELINE_PADDING_PX}px + ${startFraction} * ${trackWidth})`,\n    width: `max(${MIN_BRUSH_WIDTH_PX}px, calc(${\n      endFraction - startFraction\n    } * ${trackWidth}))`,\n  };\n\n  const viewDuration = viewport.end - viewport.start;\n  const scrollableMs = Math.max(rootDurationMs - viewDuration, 0);\n  const scrollPercent =\n    scrollableMs > 0\n      ? Math.round(((viewport.start - rootStartMs) / scrollableMs) * 100)\n      : 0;\n\n  return (\n    // biome-ignore lint/a11y/noStaticElementInteractions: pointer gestures are a mouse-only enhancement; the brush inside is keyboard-operable\n    <div\n      ref={containerRef}\n      className={cn(\n        'relative h-10 min-h-10 w-full border-b border-gray-alpha-400 bg-background-100 select-none overflow-hidden touch-none',\n        drag?.mode === 'select' && 'cursor-crosshair'\n      )}\n      onPointerDown={handlePointerDown}\n      onPointerMove={handlePointerMove}\n      onPointerUp={endDrag}\n      onPointerCancel={endDrag}\n      onLostPointerCapture={handleLostPointerCapture}\n      onDoubleClick={handleDoubleClick}\n    >\n      {/* Multiply on light themes / screen on dark, so overlapping span lines\n          deepen instead of occluding and the glass thumb reads through them. */}\n      <canvas\n        ref={canvasRef}\n        aria-hidden\n        className=\"pointer-events-none absolute inset-0 h-full w-full mix-blend-multiply [.dark-theme_&]:mix-blend-screen [.dark_&]:mix-blend-screen [[data-theme=dark]_&]:mix-blend-screen\"\n      />\n      {selection ? (\n        <div\n          aria-hidden\n          className=\"pointer-events-none absolute inset-y-0 border border-blue-500 bg-blue-300 opacity-40\"\n          style={{ left: selection.x0, width: selection.x1 - selection.x0 }}\n        />\n      ) : null}\n      <div\n        data-minimap-brush\n        role=\"scrollbar\"\n        aria-controls=\"trace-timeline\"\n        aria-orientation=\"horizontal\"\n        aria-valuemin={0}\n        aria-valuemax={100}\n        aria-valuenow={scrollPercent}\n        aria-valuetext={`Viewing ${formatDurationPrecise(\n          viewport.start - rootStartMs\n        )} to ${formatDurationPrecise(\n          viewport.end - rootStartMs\n        )} of ${formatDurationPrecise(rootDurationMs)}`}\n        aria-label=\"Timeline overview\"\n        tabIndex={0}\n        onKeyDown={handleKeyDown}\n        className={cn(\n          // Glass thumb, matching the legacy trace viewer's map window.\n          'group/minimap-brush absolute top-0.5 bottom-0.5 rounded-[3px] border border-gray-alpha-400 bg-gray-alpha-200 shadow-sm focus-visible:outline focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-[var(--ds-focus-color)]',\n          drag?.mode === 'pan' ? 'cursor-grabbing' : 'cursor-grab'\n        )}\n        style={brushStyle}\n      >\n        <div\n          data-minimap-handle=\"left\"\n          className=\"absolute inset-y-0 -left-1 flex w-2.5 cursor-ew-resize items-center justify-center\"\n        >\n          <span\n            className={cn(\n              'h-3.5 w-[3px] rounded-full bg-gray-600 opacity-0 transition-opacity group-hover/minimap-brush:opacity-100 group-focus-visible/minimap-brush:opacity-100',\n              drag && 'opacity-100'\n            )}\n          />\n        </div>\n        <div\n          data-minimap-handle=\"right\"\n          className=\"absolute inset-y-0 -right-1 flex w-2.5 cursor-ew-resize items-center justify-center\"\n        >\n          <span\n            className={cn(\n              'h-3.5 w-[3px] rounded-full bg-gray-600 opacity-0 transition-opacity group-hover/minimap-brush:opacity-100 group-focus-visible/minimap-brush:opacity-100',\n              drag && 'opacity-100'\n            )}\n          />\n        </div>\n      </div>\n    </div>\n  );\n});\n"]}

package/dist/components/trace-viewer/components/pane-constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Layout constants shared by SplitPane and TraceViewerSkeleton. Kept in a
+ * module without 'use client' so the skeleton's import chain stays
+ * server-component-safe for external consumers.
+ */
+/** Width (px) of the draggable gutter column between the list and timeline. */
+export declare const GUTTER_PX = 1;
+/** Minimum width (px) of either SplitPane pane. */
+export declare const MIN_PX = 50;
+/** Default width (px) of the start (event list) pane. */
+export declare const DEFAULT_START_PX = 340;
+/** Grid column template for the [list | gutter | timeline] split. */
+export declare function paneColTemplate(startPx: number): string;
+//# sourceMappingURL=pane-constants.d.ts.map

package/dist/components/trace-viewer/components/pane-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pane-constants.d.ts","sourceRoot":"","sources":["../../../../src/components/trace-viewer/components/pane-constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,SAAS,IAAI,CAAC;AAE3B,mDAAmD;AACnD,eAAO,MAAM,MAAM,KAAK,CAAC;AAEzB,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/components/trace-viewer/components/pane-constants.js

@@ -0,0 +1,16 @@
+/**
+ * Layout constants shared by SplitPane and TraceViewerSkeleton. Kept in a
+ * module without 'use client' so the skeleton's import chain stays
+ * server-component-safe for external consumers.
+ */
+/** Width (px) of the draggable gutter column between the list and timeline. */
+export const GUTTER_PX = 1;
+/** Minimum width (px) of either SplitPane pane. */
+export const MIN_PX = 50;
+/** Default width (px) of the start (event list) pane. */
+export const DEFAULT_START_PX = 340;
+/** Grid column template for the [list | gutter | timeline] split. */
+export function paneColTemplate(startPx) {
+    return `${startPx}px ${GUTTER_PX}px minmax(${MIN_PX}px, 1fr)`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuZS1jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy90cmFjZS12aWV3ZXIvY29tcG9uZW50cy9wYW5lLWNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsK0VBQStFO0FBQy9FLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLENBQUM7QUFFM0IsbURBQW1EO0FBQ25ELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxFQUFFLENBQUM7QUFFekIseURBQXlEO0FBQ3pELE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLEdBQUcsQ0FBQztBQUVwQyxxRUFBcUU7QUFDckUsTUFBTSxVQUFVLGVBQWUsQ0FBQyxPQUFlO0lBQzdDLE9BQU8sR0FBRyxPQUFPLE1BQU0sU0FBUyxhQUFhLE1BQU0sVUFBVSxDQUFDO0FBQ2hFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIExheW91dCBjb25zdGFudHMgc2hhcmVkIGJ5IFNwbGl0UGFuZSBhbmQgVHJhY2VWaWV3ZXJTa2VsZXRvbi4gS2VwdCBpbiBhXG4gKiBtb2R1bGUgd2l0aG91dCAndXNlIGNsaWVudCcgc28gdGhlIHNrZWxldG9uJ3MgaW1wb3J0IGNoYWluIHN0YXlzXG4gKiBzZXJ2ZXItY29tcG9uZW50LXNhZmUgZm9yIGV4dGVybmFsIGNvbnN1bWVycy5cbiAqL1xuXG4vKiogV2lkdGggKHB4KSBvZiB0aGUgZHJhZ2dhYmxlIGd1dHRlciBjb2x1bW4gYmV0d2VlbiB0aGUgbGlzdCBhbmQgdGltZWxpbmUuICovXG5leHBvcnQgY29uc3QgR1VUVEVSX1BYID0gMTtcblxuLyoqIE1pbmltdW0gd2lkdGggKHB4KSBvZiBlaXRoZXIgU3BsaXRQYW5lIHBhbmUuICovXG5leHBvcnQgY29uc3QgTUlOX1BYID0gNTA7XG5cbi8qKiBEZWZhdWx0IHdpZHRoIChweCkgb2YgdGhlIHN0YXJ0IChldmVudCBsaXN0KSBwYW5lLiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfU1RBUlRfUFggPSAzNDA7XG5cbi8qKiBHcmlkIGNvbHVtbiB0ZW1wbGF0ZSBmb3IgdGhlIFtsaXN0IHwgZ3V0dGVyIHwgdGltZWxpbmVdIHNwbGl0LiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHBhbmVDb2xUZW1wbGF0ZShzdGFydFB4OiBudW1iZXIpOiBzdHJpbmcge1xuICByZXR1cm4gYCR7c3RhcnRQeH1weCAke0dVVFRFUl9QWH1weCBtaW5tYXgoJHtNSU5fUFh9cHgsIDFmcilgO1xufVxuIl19

package/dist/components/trace-viewer/components/span-markers.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from 'react';
+import type { SpanMarker } from '../utils';
+export interface VisibleMarker {
+    leftPct: number;
+    /** Absolute (epoch) timestamp in ms — for the tooltip. */
+    timeMs: number;
+}
+/**
+ * Project point-in-time markers onto the visible window `[visibleStartMs,
+ * visibleEndMs]` of a bar, as percentages of that window. Markers outside the
+ * window are dropped.
+ */
+export declare function projectMarkers(markers: SpanMarker[], visibleStartMs: number, visibleEndMs: number): VisibleMarker[];
+/**
+ * Thin out ticks that would visually collide: walk left-to-right and keep each
+ * one unless it sits within MARKER_MIN_GAP_PX of the last kept tick. Well-spaced
+ * markers survive even when a tight cluster elsewhere on the bar gets thinned —
+ * zoom in to resolve a cluster.
+ */
+export declare function cullCollidingMarkers(projected: VisibleMarker[], pixelWidth: number): VisibleMarker[];
+/**
+ * Point-in-time markers overlaid on a bar — one vertical tick per event (hook
+ * resumptions and attribute writes), centered on the bar. Each tick sits inside
+ * a larger hit target and, on hover, shows the shared `TimestampTooltip` card
+ * (the same light Geist card used for every other timestamp in the app, e.g. the
+ * attribute panel and event list) so the time reads consistently with the rest
+ * of the product. The position is clamped a hair inside the bar so an edge
+ * marker never jams the rounded corner.
+ */
+export declare function MarkerLayer({ markers, }: {
+    markers: VisibleMarker[];
+}): ReactNode;
+/**
+ * Edge indicator for markers that have scrolled out of view while zoomed in.
+ * Pinned flush to the corresponding edge of the visible bar, it shows the marker
+ * glyph plus a chevron pointing the way to scroll. The chevron always sits on
+ * the outer (off-screen) side, in a box that lines up with the bare
+ * BoundaryArrow on adjacent rows.
+ */
+export declare function OffscreenMarkerIndicator({ direction, count, targetMs, onReveal, }: {
+    direction: 'left' | 'right';
+    count: number;
+    targetMs: number;
+    onReveal?: (timeMs: number) => void;
+}): ReactNode;
+//# sourceMappingURL=span-markers.d.ts.map

package/dist/components/trace-viewer/components/span-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-markers.d.ts","sourceRoot":"","sources":["../../../../src/components/trace-viewer/components/span-markers.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAM3C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EAAE,EACrB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,GACnB,aAAa,EAAE,CAejB;AAKD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,aAAa,EAAE,EAC1B,UAAU,EAAE,MAAM,GACjB,aAAa,EAAE,CAUjB;AAeD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EAC1B,OAAO,GACR,EAAE;IACD,OAAO,EAAE,aAAa,EAAE,CAAC;CAC1B,GAAG,SAAS,CAkBZ;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,SAAS,EACT,KAAK,EACL,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC,GAAG,SAAS,CAyCZ"}

package/dist/components/trace-viewer/components/span-markers.js

@@ -0,0 +1,85 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { ArrowLeft, ArrowRight } from 'lucide-react';
+import { cn } from '../../../lib/cn';
+import { TimestampTooltip } from '../../ui/timestamp-tooltip';
+/**
+ * Project point-in-time markers onto the visible window `[visibleStartMs,
+ * visibleEndMs]` of a bar, as percentages of that window. Markers outside the
+ * window are dropped.
+ */
+export function projectMarkers(markers, visibleStartMs, visibleEndMs) {
+    const visibleDurationMs = visibleEndMs - visibleStartMs;
+    if (visibleDurationMs <= 0)
+        return [];
+    return markers.flatMap((m) => {
+        if (m.timeMs < visibleStartMs || m.timeMs > visibleEndMs) {
+            return [];
+        }
+        return [
+            {
+                leftPct: ((m.timeMs - visibleStartMs) / visibleDurationMs) * 100,
+                timeMs: m.timeMs,
+            },
+        ];
+    });
+}
+/** Min pixel gap a tick needs from the last-kept one, else it's culled. */
+const MARKER_MIN_GAP_PX = 16;
+/**
+ * Thin out ticks that would visually collide: walk left-to-right and keep each
+ * one unless it sits within MARKER_MIN_GAP_PX of the last kept tick. Well-spaced
+ * markers survive even when a tight cluster elsewhere on the bar gets thinned —
+ * zoom in to resolve a cluster.
+ */
+export function cullCollidingMarkers(projected, pixelWidth) {
+    const kept = [];
+    let lastKeptPct = Number.NEGATIVE_INFINITY;
+    for (const m of projected) {
+        const gapPx = ((m.leftPct - lastKeptPct) / 100) * pixelWidth;
+        if (gapPx < MARKER_MIN_GAP_PX)
+            continue;
+        kept.push(m);
+        lastKeptPct = m.leftPct;
+    }
+    return kept;
+}
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+/** Marker glyph: a rounded vertical tick (3px wide). */
+function MarkerTick({ className }) {
+    return (_jsx("span", { className: cn('block w-[3px] rounded-full bg-gray-1000', className) }));
+}
+/**
+ * Point-in-time markers overlaid on a bar — one vertical tick per event (hook
+ * resumptions and attribute writes), centered on the bar. Each tick sits inside
+ * a larger hit target and, on hover, shows the shared `TimestampTooltip` card
+ * (the same light Geist card used for every other timestamp in the app, e.g. the
+ * attribute panel and event list) so the time reads consistently with the rest
+ * of the product. The position is clamped a hair inside the bar so an edge
+ * marker never jams the rounded corner.
+ */
+export function MarkerLayer({ markers, }) {
+    return (_jsx(_Fragment, { children: markers.map((m) => (_jsx("span", { className: "pointer-events-auto absolute top-0 bottom-0 z-10 flex w-8 -translate-x-1/2 items-center justify-center", style: { left: `clamp(8px, ${m.leftPct}%, calc(100% - 8px))` }, children: _jsx(TimestampTooltip, { date: m.timeMs, children: _jsx("span", { className: "flex h-6 w-8 items-center justify-center", children: _jsx(MarkerTick, { className: "h-3" }) }) }) }, m.timeMs))) }));
+}
+/**
+ * Edge indicator for markers that have scrolled out of view while zoomed in.
+ * Pinned flush to the corresponding edge of the visible bar, it shows the marker
+ * glyph plus a chevron pointing the way to scroll. The chevron always sits on
+ * the outer (off-screen) side, in a box that lines up with the bare
+ * BoundaryArrow on adjacent rows.
+ */
+export function OffscreenMarkerIndicator({ direction, count, targetMs, onReveal, }) {
+    const Chevron = direction === 'right' ? ArrowRight : ArrowLeft;
+    const label = `${count} marker${count === 1 ? '' : 's'} ${direction === 'right' ? 'ahead' : 'behind'} — click to scroll to ${count === 1 ? 'it' : 'the nearest'}`;
+    const chevron = (_jsx("span", { className: "flex h-6 w-6 shrink-0 items-center justify-center", children: _jsx(Chevron, { className: "size-3 text-gray-900" }) }));
+    const tick = _jsx(MarkerTick, { className: "h-3.5 shrink-0" });
+    return (_jsx("button", { type: "button", "aria-label": label, title: label, onClick: (e) => {
+            // Don't let the row's onClick fire — revealing shouldn't also
+            // change the span selection.
+            e.stopPropagation();
+            onReveal?.(targetMs);
+        }, className: cn('pointer-events-auto absolute top-1/2 z-20 flex h-6 -translate-y-1/2 cursor-pointer items-center rounded-[0.25rem] border border-gray-alpha-400 bg-background-100 hover:bg-gray-100', direction === 'right' ? 'right-0 pl-1.5' : 'left-0 pr-1.5'), children: direction === 'left' ? (_jsxs(_Fragment, { children: [chevron, tick] })) : (_jsxs(_Fragment, { children: [tick, chevron] })) }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"span-markers.js","sourceRoot":"","sources":["../../../../src/components/trace-viewer/components/span-markers.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport { ArrowLeft, ArrowRight } from 'lucide-react';\nimport type { ReactNode } from 'react';\nimport { cn } from '../../../lib/cn';\nimport { TimestampTooltip } from '../../ui/timestamp-tooltip';\nimport type { SpanMarker } from '../utils';\n\n// ---------------------------------------------------------------------------\n// Marker projection\n// ---------------------------------------------------------------------------\n\nexport interface VisibleMarker {\n  leftPct: number;\n  /** Absolute (epoch) timestamp in ms — for the tooltip. */\n  timeMs: number;\n}\n\n/**\n * Project point-in-time markers onto the visible window `[visibleStartMs,\n * visibleEndMs]` of a bar, as percentages of that window. Markers outside the\n * window are dropped.\n */\nexport function projectMarkers(\n  markers: SpanMarker[],\n  visibleStartMs: number,\n  visibleEndMs: number\n): VisibleMarker[] {\n  const visibleDurationMs = visibleEndMs - visibleStartMs;\n  if (visibleDurationMs <= 0) return [];\n\n  return markers.flatMap((m) => {\n    if (m.timeMs < visibleStartMs || m.timeMs > visibleEndMs) {\n      return [];\n    }\n    return [\n      {\n        leftPct: ((m.timeMs - visibleStartMs) / visibleDurationMs) * 100,\n        timeMs: m.timeMs,\n      },\n    ];\n  });\n}\n\n/** Min pixel gap a tick needs from the last-kept one, else it's culled. */\nconst MARKER_MIN_GAP_PX = 16;\n\n/**\n * Thin out ticks that would visually collide: walk left-to-right and keep each\n * one unless it sits within MARKER_MIN_GAP_PX of the last kept tick. Well-spaced\n * markers survive even when a tight cluster elsewhere on the bar gets thinned —\n * zoom in to resolve a cluster.\n */\nexport function cullCollidingMarkers(\n  projected: VisibleMarker[],\n  pixelWidth: number\n): VisibleMarker[] {\n  const kept: VisibleMarker[] = [];\n  let lastKeptPct = Number.NEGATIVE_INFINITY;\n  for (const m of projected) {\n    const gapPx = ((m.leftPct - lastKeptPct) / 100) * pixelWidth;\n    if (gapPx < MARKER_MIN_GAP_PX) continue;\n    kept.push(m);\n    lastKeptPct = m.leftPct;\n  }\n  return kept;\n}\n\n// ---------------------------------------------------------------------------\n// Rendering\n// ---------------------------------------------------------------------------\n\n/** Marker glyph: a rounded vertical tick (3px wide). */\nfunction MarkerTick({ className }: { className?: string }): ReactNode {\n  return (\n    <span\n      className={cn('block w-[3px] rounded-full bg-gray-1000', className)}\n    />\n  );\n}\n\n/**\n * Point-in-time markers overlaid on a bar — one vertical tick per event (hook\n * resumptions and attribute writes), centered on the bar. Each tick sits inside\n * a larger hit target and, on hover, shows the shared `TimestampTooltip` card\n * (the same light Geist card used for every other timestamp in the app, e.g. the\n * attribute panel and event list) so the time reads consistently with the rest\n * of the product. The position is clamped a hair inside the bar so an edge\n * marker never jams the rounded corner.\n */\nexport function MarkerLayer({\n  markers,\n}: {\n  markers: VisibleMarker[];\n}): ReactNode {\n  return (\n    <>\n      {markers.map((m) => (\n        <span\n          key={m.timeMs}\n          className=\"pointer-events-auto absolute top-0 bottom-0 z-10 flex w-8 -translate-x-1/2 items-center justify-center\"\n          style={{ left: `clamp(8px, ${m.leftPct}%, calc(100% - 8px))` }}\n        >\n          <TimestampTooltip date={m.timeMs}>\n            <span className=\"flex h-6 w-8 items-center justify-center\">\n              <MarkerTick className=\"h-3\" />\n            </span>\n          </TimestampTooltip>\n        </span>\n      ))}\n    </>\n  );\n}\n\n/**\n * Edge indicator for markers that have scrolled out of view while zoomed in.\n * Pinned flush to the corresponding edge of the visible bar, it shows the marker\n * glyph plus a chevron pointing the way to scroll. The chevron always sits on\n * the outer (off-screen) side, in a box that lines up with the bare\n * BoundaryArrow on adjacent rows.\n */\nexport function OffscreenMarkerIndicator({\n  direction,\n  count,\n  targetMs,\n  onReveal,\n}: {\n  direction: 'left' | 'right';\n  count: number;\n  targetMs: number;\n  onReveal?: (timeMs: number) => void;\n}): ReactNode {\n  const Chevron = direction === 'right' ? ArrowRight : ArrowLeft;\n  const label = `${count} marker${count === 1 ? '' : 's'} ${\n    direction === 'right' ? 'ahead' : 'behind'\n  } — click to scroll to ${count === 1 ? 'it' : 'the nearest'}`;\n  const chevron = (\n    <span className=\"flex h-6 w-6 shrink-0 items-center justify-center\">\n      <Chevron className=\"size-3 text-gray-900\" />\n    </span>\n  );\n  const tick = <MarkerTick className=\"h-3.5 shrink-0\" />;\n\n  return (\n    <button\n      type=\"button\"\n      aria-label={label}\n      title={label}\n      onClick={(e) => {\n        // Don't let the row's onClick fire — revealing shouldn't also\n        // change the span selection.\n        e.stopPropagation();\n        onReveal?.(targetMs);\n      }}\n      className={cn(\n        'pointer-events-auto absolute top-1/2 z-20 flex h-6 -translate-y-1/2 cursor-pointer items-center rounded-[0.25rem] border border-gray-alpha-400 bg-background-100 hover:bg-gray-100',\n        direction === 'right' ? 'right-0 pl-1.5' : 'left-0 pr-1.5'\n      )}\n    >\n      {direction === 'left' ? (\n        <>\n          {chevron}\n          {tick}\n        </>\n      ) : (\n        <>\n          {tick}\n          {chevron}\n        </>\n      )}\n    </button>\n  );\n}\n"]}