@workflow/web-shared 5.0.0-beta.27 → 5.0.0-beta.29

package/dist/components/new-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 '../../trace-viewer/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/new-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 {\n  formatDurationPrecise,\n  getHighResInMs,\n} from '../../trace-viewer/util/timing';\nimport type { Span } from '../types';\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/new-trace-viewer/components/split-pane.d.ts

@@ -2,9 +2,7 @@ import { type ReactNode, type RefObject } from 'react';
 export interface SplitPaneProps {
     children: ReactNode;
     className?: string;
-    /** Fixed (non-scrolling) header rendered above the start pane. */
     startHeader?: ReactNode;
-    /** Fixed (non-scrolling) header rendered above the end pane. */
     endHeader?: ReactNode;
     scrollContainerRef?: RefObject<HTMLDivElement | null>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"split-pane.d.ts","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/split-pane.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,SAAS,EAKf,MAAM,OAAO,CAAC;AAUf,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kEAAkE;IAClE,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,gEAAgE;IAChE,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,kBAAkB,CAAC,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;CACvD;AAED,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,SAAS,EACT,WAAW,EACX,SAAS,EACT,kBAAkB,GACnB,EAAE,cAAc,2CAqJhB"}
+{"version":3,"file":"split-pane.d.ts","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/split-pane.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAaf,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,kBAAkB,CAAC,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;CACvD;AAED,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,SAAS,EACT,WAAW,EACX,SAAS,EACT,kBAAkB,GACnB,EAAE,cAAc,2CA8FhB"}

package/dist/components/new-trace-viewer/components/split-pane.js

@@ -1,33 +1,21 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Children, useCallback, useEffect, useRef, useState, } from 'react';
+import { Children, useCallback, useRef, useState, } from 'react';
 import { cn } from '../../../lib/cn';
+import { DraggableBorder } from './draggable-border';
 import { DEFAULT_START_PX, GUTTER_PX, MIN_PX, paneColTemplate, } from './pane-constants';
 import { useElementWidth } from './use-element-width';
+const SPLIT_PANE_START_ID = 'trace-split-start';
 export function SplitPane({ children, className, startHeader, endHeader, scrollContainerRef, }) {
     const parts = Children.toArray(children);
     if (parts.length !== 2) {
         throw new Error('SplitPane expects exactly two children');
     }
     const [start, end] = parts;
-    // `startPx` is the user's preferred width; the rendered width is derived by
-    // clamping against the live container width (same model as the detail
-    // panel), so shrinking the container compresses the pane without destroying
-    // the preference, and re-growing restores it.
     const [startPx, setStartPx] = useState(DEFAULT_START_PX);
-    const [isDragging, setIsDragging] = useState(false);
     const containerRef = useRef(null);
-    const gutterRef = useRef(null);
-    const rafRef = useRef(null);
-    const pendingPx = useRef(DEFAULT_START_PX);
-    const pointerIdRef = useRef(null);
+    const startRef = useRef(null);
     const containerWidth = useElementWidth(containerRef);
-    useEffect(() => {
-        return () => {
-            if (rafRef.current)
-                cancelAnimationFrame(rafRef.current);
-        };
-    }, []);
     const setContainerRef = useCallback((node) => {
         containerRef.current = node;
         if (scrollContainerRef) {
@@ -41,67 +29,13 @@ export function SplitPane({ children, className, startHeader, endHeader, scrollC
         const maxPx = el.getBoundingClientRect().width - MIN_PX - GUTTER_PX;
         return Math.min(maxPx, Math.max(MIN_PX, px));
     }, []);
-    useEffect(() => {
-        if (!isDragging)
-            return;
-        const onPointerMove = (e) => {
-            if (e.pointerId !== pointerIdRef.current)
-                return;
-            const container = containerRef.current;
-            if (!container)
-                return;
-            const rect = container.getBoundingClientRect();
-            pendingPx.current = clampPx(e.clientX - rect.left);
-            if (!rafRef.current) {
-                rafRef.current = requestAnimationFrame(() => {
-                    rafRef.current = null;
-                    setStartPx(pendingPx.current);
-                });
-            }
-        };
-        const onPointerUp = (e) => {
-            if (e.pointerId !== pointerIdRef.current)
-                return;
-            const gutter = gutterRef.current;
-            if (gutter?.hasPointerCapture(e.pointerId)) {
-                gutter.releasePointerCapture(e.pointerId);
-            }
-            if (rafRef.current) {
-                cancelAnimationFrame(rafRef.current);
-                rafRef.current = null;
-            }
-            pointerIdRef.current = null;
-            setIsDragging(false);
-        };
-        document.addEventListener('pointermove', onPointerMove);
-        document.addEventListener('pointerup', onPointerUp);
-        document.addEventListener('pointercancel', onPointerUp);
-        return () => {
-            document.removeEventListener('pointermove', onPointerMove);
-            document.removeEventListener('pointerup', onPointerUp);
-            document.removeEventListener('pointercancel', onPointerUp);
-        };
-    }, [isDragging, clampPx]);
-    const handlePointerDown = (e) => {
-        e.currentTarget.setPointerCapture(e.pointerId);
-        pointerIdRef.current = e.pointerId;
-        setIsDragging(true);
-    };
-    const handleLostPointerCapture = () => {
-        pointerIdRef.current = null;
-        setIsDragging(false);
-        if (rafRef.current) {
-            cancelAnimationFrame(rafRef.current);
-            rafRef.current = null;
-        }
-    };
-    // Floor applied last so the start column can never collapse below MIN_PX
-    // (which would produce an invalid negative grid track on tiny containers).
+    const handleWidthChange = useCallback((next) => setStartPx(clampPx(next)), [clampPx]);
+    const handleReset = useCallback(() => setStartPx(clampPx(DEFAULT_START_PX)), [clampPx]);
     const effectiveStartPx = containerWidth > 0
         ? Math.max(MIN_PX, Math.min(containerWidth - MIN_PX - GUTTER_PX, startPx))
         : startPx;
     const colTemplate = paneColTemplate(effectiveStartPx);
-    const gutter = (_jsx("div", { ref: gutterRef, className: "relative z-20 isolate flex shrink-0 cursor-col-resize justify-center", onPointerDown: handlePointerDown, onLostPointerCapture: handleLostPointerCapture, children: _jsx("span", { className: "pointer-events-none relative z-10 h-full w-px shrink-0 bg-gray-alpha-400", "aria-hidden": true }) }));
-    return (_jsxs("div", { className: cn('flex flex-col h-full min-h-0', className), children: [_jsxs("div", { className: "shrink-0 grid", style: { gridTemplateColumns: colTemplate }, children: [_jsx("div", { children: startHeader }), _jsx("div", { className: "flex justify-center", children: _jsx("span", { className: "h-full w-px bg-gray-alpha-400", "aria-hidden": true }) }), _jsx("div", { children: endHeader })] }), _jsxs("div", { ref: setContainerRef, className: cn('grid flex-1 min-h-0 overflow-x-hidden overflow-y-auto', isDragging && 'select-none'), style: { gridTemplateColumns: colTemplate }, children: [start, gutter, end] })] }));
+    const maxStartPx = Math.max(MIN_PX, containerWidth > 0 ? containerWidth - MIN_PX - GUTTER_PX : startPx);
+    return (_jsxs("div", { className: cn('flex flex-col h-full min-h-0', className), children: [_jsxs("div", { className: "shrink-0 grid", style: { gridTemplateColumns: colTemplate }, children: [_jsx("div", { children: startHeader }), _jsx("div", { className: "flex justify-center", children: _jsx("span", { className: "h-full w-px bg-gray-alpha-400", "aria-hidden": true }) }), _jsx("div", { children: endHeader })] }), _jsxs("div", { ref: setContainerRef, className: "grid flex-1 min-h-0 overflow-x-hidden overflow-y-auto", style: { gridTemplateColumns: colTemplate }, children: [_jsx("div", { ref: startRef, id: SPLIT_PANE_START_ID, className: "min-w-0", children: start }), _jsxs("div", { className: "relative z-20 isolate flex shrink-0 justify-center", children: [_jsx("span", { className: "pointer-events-none relative z-10 h-full w-px shrink-0 bg-gray-alpha-400", "aria-hidden": true }), _jsx(DraggableBorder, { element: startRef, position: "right", onWidthChange: handleWidthChange, onReset: handleReset, "aria-label": "Resize event list", "aria-controls": SPLIT_PANE_START_ID, "aria-valuemin": MIN_PX, "aria-valuemax": maxStartPx, "aria-valuenow": Math.min(Math.max(Math.round(effectiveStartPx), MIN_PX), maxStartPx) })] }), end] })] }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"split-pane.js","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/split-pane.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport {\n  Children,\n  type ReactNode,\n  type PointerEvent as ReactPointerEvent,\n  type RefObject,\n  useCallback,\n  useEffect,\n  useRef,\n  useState,\n} from 'react';\nimport { cn } from '../../../lib/cn';\nimport {\n  DEFAULT_START_PX,\n  GUTTER_PX,\n  MIN_PX,\n  paneColTemplate,\n} from './pane-constants';\nimport { useElementWidth } from './use-element-width';\n\nexport interface SplitPaneProps {\n  children: ReactNode;\n  className?: string;\n  /** Fixed (non-scrolling) header rendered above the start pane. */\n  startHeader?: ReactNode;\n  /** Fixed (non-scrolling) header rendered above the end pane. */\n  endHeader?: ReactNode;\n  scrollContainerRef?: RefObject<HTMLDivElement | null>;\n}\n\nexport function SplitPane({\n  children,\n  className,\n  startHeader,\n  endHeader,\n  scrollContainerRef,\n}: SplitPaneProps) {\n  const parts = Children.toArray(children);\n  if (parts.length !== 2) {\n    throw new Error('SplitPane expects exactly two children');\n  }\n  const [start, end] = parts;\n\n  // `startPx` is the user's preferred width; the rendered width is derived by\n  // clamping against the live container width (same model as the detail\n  // panel), so shrinking the container compresses the pane without destroying\n  // the preference, and re-growing restores it.\n  const [startPx, setStartPx] = useState(DEFAULT_START_PX);\n  const [isDragging, setIsDragging] = useState(false);\n  const containerRef = useRef<HTMLDivElement>(null);\n  const gutterRef = useRef<HTMLDivElement>(null);\n  const rafRef = useRef<number | null>(null);\n  const pendingPx = useRef(DEFAULT_START_PX);\n  const pointerIdRef = useRef<number | null>(null);\n  const containerWidth = useElementWidth(containerRef);\n\n  useEffect(() => {\n    return () => {\n      if (rafRef.current) cancelAnimationFrame(rafRef.current);\n    };\n  }, []);\n\n  const setContainerRef = useCallback(\n    (node: HTMLDivElement | null) => {\n      containerRef.current = node;\n      if (scrollContainerRef) {\n        scrollContainerRef.current = node;\n      }\n    },\n    [scrollContainerRef]\n  );\n\n  const clampPx = useCallback((px: number) => {\n    const el = containerRef.current;\n    if (!el) return px;\n    const maxPx = el.getBoundingClientRect().width - MIN_PX - GUTTER_PX;\n    return Math.min(maxPx, Math.max(MIN_PX, px));\n  }, []);\n\n  useEffect(() => {\n    if (!isDragging) return;\n\n    const onPointerMove = (e: globalThis.PointerEvent) => {\n      if (e.pointerId !== pointerIdRef.current) return;\n      const container = containerRef.current;\n      if (!container) return;\n      const rect = container.getBoundingClientRect();\n      pendingPx.current = clampPx(e.clientX - rect.left);\n      if (!rafRef.current) {\n        rafRef.current = requestAnimationFrame(() => {\n          rafRef.current = null;\n          setStartPx(pendingPx.current);\n        });\n      }\n    };\n\n    const onPointerUp = (e: globalThis.PointerEvent) => {\n      if (e.pointerId !== pointerIdRef.current) return;\n      const gutter = gutterRef.current;\n      if (gutter?.hasPointerCapture(e.pointerId)) {\n        gutter.releasePointerCapture(e.pointerId);\n      }\n      if (rafRef.current) {\n        cancelAnimationFrame(rafRef.current);\n        rafRef.current = null;\n      }\n      pointerIdRef.current = null;\n      setIsDragging(false);\n    };\n\n    document.addEventListener('pointermove', onPointerMove);\n    document.addEventListener('pointerup', onPointerUp);\n    document.addEventListener('pointercancel', onPointerUp);\n\n    return () => {\n      document.removeEventListener('pointermove', onPointerMove);\n      document.removeEventListener('pointerup', onPointerUp);\n      document.removeEventListener('pointercancel', onPointerUp);\n    };\n  }, [isDragging, clampPx]);\n\n  const handlePointerDown = (e: ReactPointerEvent<HTMLDivElement>) => {\n    e.currentTarget.setPointerCapture(e.pointerId);\n    pointerIdRef.current = e.pointerId;\n    setIsDragging(true);\n  };\n\n  const handleLostPointerCapture = () => {\n    pointerIdRef.current = null;\n    setIsDragging(false);\n    if (rafRef.current) {\n      cancelAnimationFrame(rafRef.current);\n      rafRef.current = null;\n    }\n  };\n\n  // Floor applied last so the start column can never collapse below MIN_PX\n  // (which would produce an invalid negative grid track on tiny containers).\n  const effectiveStartPx =\n    containerWidth > 0\n      ? Math.max(MIN_PX, Math.min(containerWidth - MIN_PX - GUTTER_PX, startPx))\n      : startPx;\n\n  const colTemplate = paneColTemplate(effectiveStartPx);\n\n  const gutter = (\n    <div\n      ref={gutterRef}\n      className=\"relative z-20 isolate flex shrink-0 cursor-col-resize justify-center\"\n      onPointerDown={handlePointerDown}\n      onLostPointerCapture={handleLostPointerCapture}\n    >\n      <span\n        className=\"pointer-events-none relative z-10 h-full w-px shrink-0 bg-gray-alpha-400\"\n        aria-hidden\n      />\n    </div>\n  );\n\n  return (\n    <div className={cn('flex flex-col h-full min-h-0', className)}>\n      <div\n        className=\"shrink-0 grid\"\n        style={{ gridTemplateColumns: colTemplate }}\n      >\n        <div>{startHeader}</div>\n        <div className=\"flex justify-center\">\n          <span className=\"h-full w-px bg-gray-alpha-400\" aria-hidden />\n        </div>\n        <div>{endHeader}</div>\n      </div>\n      <div\n        ref={setContainerRef}\n        className={cn(\n          'grid flex-1 min-h-0 overflow-x-hidden overflow-y-auto',\n          isDragging && 'select-none'\n        )}\n        style={{ gridTemplateColumns: colTemplate }}\n      >\n        {start}\n        {gutter}\n        {end}\n      </div>\n    </div>\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"split-pane.js","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/split-pane.tsx"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport {\n  Children,\n  type ReactNode,\n  type RefObject,\n  useCallback,\n  useRef,\n  useState,\n} from 'react';\nimport { cn } from '../../../lib/cn';\nimport { DraggableBorder } from './draggable-border';\nimport {\n  DEFAULT_START_PX,\n  GUTTER_PX,\n  MIN_PX,\n  paneColTemplate,\n} from './pane-constants';\nimport { useElementWidth } from './use-element-width';\n\nconst SPLIT_PANE_START_ID = 'trace-split-start';\n\nexport interface SplitPaneProps {\n  children: ReactNode;\n  className?: string;\n  startHeader?: ReactNode;\n  endHeader?: ReactNode;\n  scrollContainerRef?: RefObject<HTMLDivElement | null>;\n}\n\nexport function SplitPane({\n  children,\n  className,\n  startHeader,\n  endHeader,\n  scrollContainerRef,\n}: SplitPaneProps) {\n  const parts = Children.toArray(children);\n  if (parts.length !== 2) {\n    throw new Error('SplitPane expects exactly two children');\n  }\n  const [start, end] = parts;\n\n  const [startPx, setStartPx] = useState(DEFAULT_START_PX);\n  const containerRef = useRef<HTMLDivElement>(null);\n  const startRef = useRef<HTMLDivElement>(null);\n  const containerWidth = useElementWidth(containerRef);\n\n  const setContainerRef = useCallback(\n    (node: HTMLDivElement | null) => {\n      containerRef.current = node;\n      if (scrollContainerRef) {\n        scrollContainerRef.current = node;\n      }\n    },\n    [scrollContainerRef]\n  );\n\n  const clampPx = useCallback((px: number) => {\n    const el = containerRef.current;\n    if (!el) return px;\n    const maxPx = el.getBoundingClientRect().width - MIN_PX - GUTTER_PX;\n    return Math.min(maxPx, Math.max(MIN_PX, px));\n  }, []);\n\n  const handleWidthChange = useCallback(\n    (next: number) => setStartPx(clampPx(next)),\n    [clampPx]\n  );\n  const handleReset = useCallback(\n    () => setStartPx(clampPx(DEFAULT_START_PX)),\n    [clampPx]\n  );\n\n  const effectiveStartPx =\n    containerWidth > 0\n      ? Math.max(MIN_PX, Math.min(containerWidth - MIN_PX - GUTTER_PX, startPx))\n      : startPx;\n\n  const colTemplate = paneColTemplate(effectiveStartPx);\n\n  const maxStartPx = Math.max(\n    MIN_PX,\n    containerWidth > 0 ? containerWidth - MIN_PX - GUTTER_PX : startPx\n  );\n\n  return (\n    <div className={cn('flex flex-col h-full min-h-0', className)}>\n      <div\n        className=\"shrink-0 grid\"\n        style={{ gridTemplateColumns: colTemplate }}\n      >\n        <div>{startHeader}</div>\n        <div className=\"flex justify-center\">\n          <span className=\"h-full w-px bg-gray-alpha-400\" aria-hidden />\n        </div>\n        <div>{endHeader}</div>\n      </div>\n      <div\n        ref={setContainerRef}\n        className=\"grid flex-1 min-h-0 overflow-x-hidden overflow-y-auto\"\n        style={{ gridTemplateColumns: colTemplate }}\n      >\n        <div ref={startRef} id={SPLIT_PANE_START_ID} className=\"min-w-0\">\n          {start}\n        </div>\n        <div className=\"relative z-20 isolate flex shrink-0 justify-center\">\n          <span\n            className=\"pointer-events-none relative z-10 h-full w-px shrink-0 bg-gray-alpha-400\"\n            aria-hidden\n          />\n          <DraggableBorder\n            element={startRef}\n            position=\"right\"\n            onWidthChange={handleWidthChange}\n            onReset={handleReset}\n            aria-label=\"Resize event list\"\n            aria-controls={SPLIT_PANE_START_ID}\n            aria-valuemin={MIN_PX}\n            aria-valuemax={maxStartPx}\n            aria-valuenow={Math.min(\n              Math.max(Math.round(effectiveStartPx), MIN_PX),\n              maxStartPx\n            )}\n          />\n        </div>\n        {end}\n      </div>\n    </div>\n  );\n}\n"]}

package/dist/components/new-trace-viewer/components/timeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/timeline.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAgBtD,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,UAAU,CAAC;AAwBlB,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAoUtC,QAAA,MAAM,WAAW,yIASd;IACD,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC,KAAG,SAAS,CAqJX,CAAC;AAEH,OAAO,EAAE,WAAW,EAAE,CAAC;AAiDvB,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,SAAS,GACV,EAAE;IACD,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACxD,GAAG,SAAS,CAwBZ;AAMD,wBAAgB,QAAQ,CAAC,EACvB,KAAK,EACL,SAAS,EACT,OAAO,EACP,OAAO,EACP,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,OAAe,GAChB,EAAE;IACD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,SAAS,CA6FZ"}
+{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../../../../src/components/new-trace-viewer/components/timeline.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAetD,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACxE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,UAAU,CAAC;AAyBlB,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAoUtC,QAAA,MAAM,WAAW,yIASd;IACD,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC,KAAG,SAAS,CAmJX,CAAC;AAEH,OAAO,EAAE,WAAW,EAAE,CAAC;AAiDvB,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,SAAS,GACV,EAAE;IACD,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACxD,GAAG,SAAS,CAwBZ;AAMD,wBAAgB,QAAQ,CAAC,EACvB,KAAK,EACL,SAAS,EACT,OAAO,EACP,OAAO,EACP,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,OAAe,GAChB,EAAE;IACD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,SAAS,CA6FZ"}