@workflow/web-shared 5.0.0-beta.2 → 5.0.0-beta.20

package/dist/components/new-trace-viewer/components/middle-truncate/use-middle-truncate.js

@@ -0,0 +1,114 @@
+'use client';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
+import { middleTruncate, toGraphemes } from './truncate';
+const useIsomorphicLayoutEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect;
+function createFullState(value, graphemes) {
+    return {
+        displayText: value,
+        isTruncated: false,
+        prefixGraphemeCount: graphemes.length,
+        prefixText: value,
+        suffixGraphemeCount: 0,
+        suffixText: '',
+    };
+}
+/**
+ * Middle-truncation logic. Returns refs to attach to the container and measurement elements, plus the truncated display text. Recalculates on resize, font loading, and value changes.
+ * Powers the `<MiddleTruncate>` (`<span>`) component.
+ *
+ * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)
+ *
+ * @param value - Full text string to truncate.
+ */
+function useMiddleTruncate(value) {
+    const graphemes = useMemo(() => toGraphemes(value), [value]);
+    const fullState = useMemo(() => createFullState(value, graphemes), [graphemes, value]);
+    const ref = useRef(null);
+    const measureRef = useRef(null);
+    const [state, setState] = useState(() => fullState);
+    const rafRef = useRef(0);
+    const updateState = useCallback((nextState) => {
+        setState((currentState) => {
+            if (currentState.displayText === nextState.displayText &&
+                currentState.isTruncated === nextState.isTruncated &&
+                currentState.prefixText === nextState.prefixText &&
+                currentState.prefixGraphemeCount === nextState.prefixGraphemeCount &&
+                currentState.suffixText === nextState.suffixText &&
+                currentState.suffixGraphemeCount === nextState.suffixGraphemeCount) {
+                return currentState;
+            }
+            return nextState;
+        });
+    }, []);
+    const recalculate = useCallback(() => {
+        const el = ref.current;
+        const measureEl = measureRef.current;
+        if (!el || !measureEl)
+            return;
+        const available = el.clientWidth;
+        if (available <= 0) {
+            updateState(fullState);
+            return;
+        }
+        const measure = (text) => {
+            measureEl.textContent = text;
+            return measureEl.scrollWidth;
+        };
+        const fullWidth = measure(value);
+        if (fullWidth <= available) {
+            updateState(fullState);
+            return;
+        }
+        const result = middleTruncate(graphemes, available, measure, fullWidth);
+        updateState({
+            displayText: result.text,
+            isTruncated: result.truncated,
+            prefixGraphemeCount: result.prefixGraphemeCount,
+            prefixText: result.prefixText,
+            suffixGraphemeCount: result.suffixGraphemeCount,
+            suffixText: result.suffixText,
+        });
+    }, [fullState, graphemes, updateState, value]);
+    // Measure on mount and when value changes - before paint
+    useIsomorphicLayoutEffect(() => {
+        recalculate();
+    }, [recalculate]);
+    // ResizeObserver + font loading for ongoing responsiveness
+    useEffect(() => {
+        const el = ref.current;
+        if (!el)
+            return;
+        const debouncedRecalc = () => {
+            cancelAnimationFrame(rafRef.current);
+            rafRef.current = requestAnimationFrame(recalculate);
+        };
+        const ro = typeof ResizeObserver !== 'undefined'
+            ? new ResizeObserver(debouncedRecalc)
+            : null;
+        ro?.observe(el);
+        window.addEventListener('resize', debouncedRecalc);
+        const onFontsLoaded = () => {
+            debouncedRecalc();
+        };
+        const fontSet = 'fonts' in document ? document.fonts : null;
+        fontSet?.addEventListener?.('loadingdone', onFontsLoaded);
+        return () => {
+            ro?.disconnect();
+            window.removeEventListener('resize', debouncedRecalc);
+            cancelAnimationFrame(rafRef.current);
+            fontSet?.removeEventListener?.('loadingdone', onFontsLoaded);
+        };
+    }, [recalculate]);
+    return {
+        ref,
+        measureRef,
+        displayText: state.displayText,
+        isTruncated: state.isTruncated,
+        prefixGraphemeCount: state.prefixGraphemeCount,
+        prefixText: state.prefixText,
+        suffixGraphemeCount: state.suffixGraphemeCount,
+        suffixText: state.suffixText,
+    };
+}
+export { useMiddleTruncate };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"use-middle-truncate.js","sourceRoot":"","sources":["../../../../../src/components/new-trace-viewer/components/middle-truncate/use-middle-truncate.ts"],"names":[],"mappings":"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","sourcesContent":["'use client';\n\nimport {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { middleTruncate, toGraphemes } from './truncate';\n\nconst useIsomorphicLayoutEffect =\n  typeof window === 'undefined' ? useEffect : useLayoutEffect;\n\ninterface MiddleTruncateState {\n  displayText: string;\n  isTruncated: boolean;\n  prefixGraphemeCount: number;\n  prefixText: string;\n  suffixGraphemeCount: number;\n  suffixText: string;\n}\n\nfunction createFullState(\n  value: string,\n  graphemes: string[]\n): MiddleTruncateState {\n  return {\n    displayText: value,\n    isTruncated: false,\n    prefixGraphemeCount: graphemes.length,\n    prefixText: value,\n    suffixGraphemeCount: 0,\n    suffixText: '',\n  };\n}\n\n/**\n * Middle-truncation logic. Returns refs to attach to the container and measurement elements, plus the truncated display text. Recalculates on resize, font loading, and value changes.\n * Powers the `<MiddleTruncate>` (`<span>`) component.\n *\n * Documentation: [Geist Middle Truncate](https://vercel.com/geist/middle-truncate)\n *\n * @param value - Full text string to truncate.\n */\nfunction useMiddleTruncate(value: string): {\n  ref: React.RefObject<HTMLSpanElement | null>;\n  measureRef: React.RefObject<HTMLSpanElement | null>;\n  displayText: string;\n  isTruncated: boolean;\n  prefixGraphemeCount: number;\n  prefixText: string;\n  suffixGraphemeCount: number;\n  suffixText: string;\n} {\n  const graphemes = useMemo(() => toGraphemes(value), [value]);\n  const fullState = useMemo(\n    () => createFullState(value, graphemes),\n    [graphemes, value]\n  );\n  const ref = useRef<HTMLSpanElement | null>(null);\n  const measureRef = useRef<HTMLSpanElement | null>(null);\n  const [state, setState] = useState<MiddleTruncateState>(() => fullState);\n  const rafRef = useRef<number>(0);\n\n  const updateState = useCallback((nextState: MiddleTruncateState) => {\n    setState((currentState) => {\n      if (\n        currentState.displayText === nextState.displayText &&\n        currentState.isTruncated === nextState.isTruncated &&\n        currentState.prefixText === nextState.prefixText &&\n        currentState.prefixGraphemeCount === nextState.prefixGraphemeCount &&\n        currentState.suffixText === nextState.suffixText &&\n        currentState.suffixGraphemeCount === nextState.suffixGraphemeCount\n      ) {\n        return currentState;\n      }\n\n      return nextState;\n    });\n  }, []);\n\n  const recalculate = useCallback(() => {\n    const el = ref.current;\n    const measureEl = measureRef.current;\n    if (!el || !measureEl) return;\n\n    const available = el.clientWidth;\n\n    if (available <= 0) {\n      updateState(fullState);\n      return;\n    }\n\n    const measure = (text: string): number => {\n      measureEl.textContent = text;\n      return measureEl.scrollWidth;\n    };\n\n    const fullWidth = measure(value);\n\n    if (fullWidth <= available) {\n      updateState(fullState);\n      return;\n    }\n\n    const result = middleTruncate(graphemes, available, measure, fullWidth);\n    updateState({\n      displayText: result.text,\n      isTruncated: result.truncated,\n      prefixGraphemeCount: result.prefixGraphemeCount,\n      prefixText: result.prefixText,\n      suffixGraphemeCount: result.suffixGraphemeCount,\n      suffixText: result.suffixText,\n    });\n  }, [fullState, graphemes, updateState, value]);\n\n  // Measure on mount and when value changes - before paint\n  useIsomorphicLayoutEffect(() => {\n    recalculate();\n  }, [recalculate]);\n\n  // ResizeObserver + font loading for ongoing responsiveness\n  useEffect(() => {\n    const el = ref.current;\n    if (!el) return;\n\n    const debouncedRecalc = (): void => {\n      cancelAnimationFrame(rafRef.current);\n      rafRef.current = requestAnimationFrame(recalculate);\n    };\n\n    const ro =\n      typeof ResizeObserver !== 'undefined'\n        ? new ResizeObserver(debouncedRecalc)\n        : null;\n    ro?.observe(el);\n    window.addEventListener('resize', debouncedRecalc);\n\n    const onFontsLoaded = (): void => {\n      debouncedRecalc();\n    };\n    const fontSet = 'fonts' in document ? document.fonts : null;\n    fontSet?.addEventListener?.('loadingdone', onFontsLoaded);\n\n    return () => {\n      ro?.disconnect();\n      window.removeEventListener('resize', debouncedRecalc);\n      cancelAnimationFrame(rafRef.current);\n      fontSet?.removeEventListener?.('loadingdone', onFontsLoaded);\n    };\n  }, [recalculate]);\n\n  return {\n    ref,\n    measureRef,\n    displayText: state.displayText,\n    isTruncated: state.isTruncated,\n    prefixGraphemeCount: state.prefixGraphemeCount,\n    prefixText: state.prefixText,\n    suffixGraphemeCount: state.suffixGraphemeCount,\n    suffixText: state.suffixText,\n  };\n}\n\nexport { useMiddleTruncate };\n"]}

package/dist/components/new-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/new-trace-viewer/components/span-markers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-markers.d.ts","sourceRoot":"","sources":["../../../../src/components/new-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/new-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/utils';
+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 shadow-sm 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/new-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/utils';\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 shadow-sm 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"]}

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

@@ -0,0 +1,15 @@
+import { type ReactNode, type RefObject } from 'react';
+export declare function Divider(): import("react/jsx-runtime").JSX.Element;
+export interface SplitPaneProps {
+    children: ReactNode;
+    className?: string;
+    /** Fixed pixel width for the start (left) pane. Default 220. */
+    defaultStartWidth?: number;
+    /** 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>;
+}
+export declare function SplitPane({ children, className, defaultStartWidth, startHeader, endHeader, scrollContainerRef, }: SplitPaneProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=split-pane.d.ts.map

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

@@ -0,0 +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;AAOf,wBAAgB,OAAO,4CAEtB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,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,iBAAoC,EACpC,WAAW,EACX,SAAS,EACT,kBAAkB,GACnB,EAAE,cAAc,2CA4JhB"}

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

@@ -0,0 +1,105 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Children, useCallback, useEffect, useRef, useState, } from 'react';
+import { cn } from '../../../lib/utils';
+const GUTTER_PX = 1;
+const MIN_PX = 50;
+const DEFAULT_START_PX = 340;
+export function Divider() {
+    return _jsx("div", { "aria-hidden": true, className: "h-full w-px shrink-0 bg-gray-alpha-400" });
+}
+export function SplitPane({ children, className, defaultStartWidth = DEFAULT_START_PX, startHeader, endHeader, scrollContainerRef, }) {
+    const parts = Children.toArray(children);
+    if (parts.length !== 2) {
+        throw new Error('SplitPane expects exactly two children');
+    }
+    const [start, end] = parts;
+    const [startPx, setStartPx] = useState(defaultStartWidth);
+    const [isDragging, setIsDragging] = useState(false);
+    const containerRef = useRef(null);
+    const gutterRef = useRef(null);
+    const rafRef = useRef(null);
+    const pendingPx = useRef(defaultStartWidth);
+    const pointerIdRef = useRef(null);
+    useEffect(() => {
+        return () => {
+            if (rafRef.current)
+                cancelAnimationFrame(rafRef.current);
+        };
+    }, []);
+    const setContainerRef = useCallback((node) => {
+        containerRef.current = node;
+        if (scrollContainerRef) {
+            scrollContainerRef.current = node;
+        }
+    }, [scrollContainerRef]);
+    const clampPx = useCallback((px) => {
+        const el = containerRef.current;
+        if (!el)
+            return px;
+        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;
+        }
+    };
+    const colTemplate = `${startPx}px ${GUTTER_PX}px minmax(${MIN_PX}px, 1fr)`;
+    const hasHeaders = startHeader != null || endHeader != null;
+    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 }) }));
+    if (hasHeaders) {
+        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] })] }));
+    }
+    return (_jsxs("div", { ref: setContainerRef, className: cn('grid h-full min-h-0 content-start overflow-x-hidden overflow-y-auto', isDragging && 'select-none', className), style: { gridTemplateColumns: colTemplate, height: '100%' }, children: [start, gutter, 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/utils';\n\nconst GUTTER_PX = 1;\nconst MIN_PX = 50;\nconst DEFAULT_START_PX = 340;\n\nexport function Divider() {\n  return <div aria-hidden className=\"h-full w-px shrink-0 bg-gray-alpha-400\" />;\n}\n\nexport interface SplitPaneProps {\n  children: ReactNode;\n  className?: string;\n  /** Fixed pixel width for the start (left) pane. Default 220. */\n  defaultStartWidth?: number;\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  defaultStartWidth = DEFAULT_START_PX,\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(defaultStartWidth);\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(defaultStartWidth);\n  const pointerIdRef = useRef<number | null>(null);\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  const colTemplate = `${startPx}px ${GUTTER_PX}px minmax(${MIN_PX}px, 1fr)`;\n  const hasHeaders = startHeader != null || endHeader != null;\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  if (hasHeaders) {\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\n  return (\n    <div\n      ref={setContainerRef}\n      className={cn(\n        'grid h-full min-h-0 content-start overflow-x-hidden overflow-y-auto',\n        isDragging && 'select-none',\n        className\n      )}\n      style={{ gridTemplateColumns: colTemplate, height: '100%' }}\n    >\n      {start}\n      {gutter}\n      {end}\n    </div>\n  );\n}\n"]}

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

@@ -0,0 +1,36 @@
+import type { ReactNode } from 'react';
+import { type SpanSearchResult } from '../search';
+import type { Span } from '../types';
+import type { TimeMarker } from '../utils';
+export declare const TIMELINE_PADDING_PX = 16;
+declare const TimelineBar: import("react").NamedExoticComponent<{
+    span: Span;
+    viewStart: number;
+    viewDuration: number;
+    containerWidth: number;
+    isSelected: boolean;
+    isDimmed?: boolean;
+    onSelect: (spanId: string) => void;
+    onRevealTime?: (timeMs: number) => void;
+}>;
+export { TimelineBar };
+export declare function TimelineHeader({ markers, hoverInfo, }: {
+    markers: TimeMarker[];
+    hoverInfo?: {
+        fraction: number;
+        label: string;
+    } | null;
+}): ReactNode;
+export declare function Timeline({ spans, viewStart, viewEnd, markers, selectedId, searchResult, onSelect, onRevealTime, hoverFraction, altHeld, }: {
+    spans: Span[];
+    viewStart: number;
+    viewEnd: number;
+    markers: TimeMarker[];
+    selectedId: string | null;
+    searchResult: SpanSearchResult;
+    onSelect: (spanId: string) => void;
+    onRevealTime?: (timeMs: number) => void;
+    hoverFraction?: number | null;
+    altHeld?: boolean;
+}): ReactNode;
+//# sourceMappingURL=timeline.d.ts.map

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

@@ -0,0 +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;UAUT,IAAI;eACC,MAAM;kBACH,MAAM;oBACJ,MAAM;gBACV,OAAO;eACR,OAAO;cACR,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;mBACnB,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;EAsJvC,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"}