waveform-analysis 0.1.75 → 0.1.76

package/src/components/interaction/integerZoom.ts

@@ -1,4 +1,5 @@
-import { scaleLinear } from 'd3'
+import { resolveXAxisTicks } from '../core/xAxisTicks'
+import { formatPlainNumber } from '../../utils/formatters'
 
 export interface IntegerZoomOptions {
   integerZoom?: boolean
@@ -10,17 +11,20 @@ export function integerZoomTicks(
   count: number,
   options: IntegerZoomOptions,
 ) {
-  if (!options.integerZoom) return scaleLinear().domain(domain).ticks(count)
+  if (!options.integerZoom) return resolveXAxisTicks(domain, count)
   const factor = options.timeUnit === 's' ? 1 : 1000
-  return scaleLinear()
-    .domain(domain.map((value) => value * factor))
-    .ticks(count)
-    .filter(Number.isInteger)
+  const fractional = hasFractionalZoomDomain(domain, options)
+  return resolveXAxisTicks(
+    domain.map((value) => value * factor) as [number, number],
+    count,
+    fractional ? 0 : 1,
+  )
+    .filter((value) => fractional || Number.isInteger(value))
     .map((value) => value / factor)
 }
 
 export function formatIntegerZoomLabel(value: number): string {
-  return String(Math.round(value))
+  return formatPlainNumber(Number(stableInteger(value).toPrecision(15)))
 }
 
 function stableInteger(value: number): number {
@@ -30,7 +34,17 @@ function stableInteger(value: number): number {
     : value
 }
 
-/** Align outwards in display units; all returned coordinates remain in seconds. */
+function displayDomain(domain: [number, number], options: IntegerZoomOptions): [number, number] {
+  const factor = options.timeUnit === 's' ? 1 : 1000
+  return [stableInteger(domain[0] * factor), stableInteger(domain[1] * factor)]
+}
+
+/** Fractional viewports, including those panned across an integer, need decimal ticks. */
+function hasFractionalZoomDomain(domain: [number, number], options: IntegerZoomOptions): boolean {
+  return displayDomain(domain, options).some((value) => !Number.isInteger(value))
+}
+
+/** Align outwards only when the displayed span reaches one unit. */
 export function alignIntegerZoomDomain(
   domain: [number, number],
   options: IntegerZoomOptions,
@@ -41,24 +55,29 @@ export function alignIntegerZoomDomain(
   const end = stableInteger(Math.max(domain[0], domain[1]) * factor)
   if (!Number.isSafeInteger(Math.floor(start)) || !Number.isSafeInteger(Math.ceil(end)))
     return domain
+  if (end > start && end - start < 1) return [start / factor, end / factor]
   const left = Math.floor(start)
   return [left / factor, Math.max(left + 1, Math.ceil(end)) / factor]
 }
 
-/** Recover aligned endpoints after a D3 transform, tolerating floating-point round-off. */
+/** Recover endpoints after a D3 transform without applying a new zoom or changing pan span. */
 export function normalizeIntegerZoomDomain(
   domain: [number, number],
   options: IntegerZoomOptions,
 ): [number, number] {
-  return alignIntegerZoomDomain(domain, options)
+  if (!options.integerZoom) return domain
+  const factor = options.timeUnit === 's' ? 1 : 1000
+  return displayDomain(domain, options).map((value) => value / factor) as [number, number]
 }
 
-/** Translation snaps to the nearest unit so panning preserves the visible span. */
+/** Integer viewports snap translation; sub-unit viewports pan freely across integers. */
 export function alignIntegerPanDomain(
   domain: [number, number],
   options: IntegerZoomOptions,
 ): [number, number] {
   if (!options.integerZoom) return domain
   const factor = options.timeUnit === 's' ? 1 : 1000
-  return [Math.round(domain[0] * factor) / factor, Math.round(domain[1] * factor) / factor]
+  if (Math.abs(domain[1] - domain[0]) * factor < 1) return domain
+  const start = Math.round(domain[0] * factor) / factor
+  return [start, start + (domain[1] - domain[0])]
 }

package/src/components/interaction/remoteViewport.ts

@@ -1,4 +1,6 @@
 import type { ResolvedWaveformChartProps } from '../core/waveformChartTypes'
+import { hasMinimumVisibleXValues } from '../../core/rendering'
+import { normalizeIntegerZoomDomain } from './integerZoom'
 import {
   constrainZoomDomain,
   resolveMinimumZoomSpan,
@@ -32,7 +34,13 @@ export function restoreViewportDomain(
   const boundary = remotePanBoundary(props)
   return boundary
     ? clampViewportDomain(domain, boundary)
-    : constrainZoomDomain(domain, baseDomain, groups, props)
+    : normalizeIntegerZoomDomain(
+        constrainZoomDomain(domain, baseDomain, groups, {
+          ...props,
+          integerZoom: false,
+        }),
+        props,
+      )
 }
 
 /** Wheel/box zoom keeps the remote position and uses loaded data for scale limits. */
@@ -44,10 +52,24 @@ export function constrainViewportZoom(
 ) {
   const boundary = remotePanBoundary(props)
   if (!boundary) return constrainZoomDomain(domain, baseDomain, groups, props)
-  return constrainZoomDomain(domain, boundary, [], {
+  const availableGroups = groups.filter((group) =>
+    hasMinimumVisibleXValues(group, boundary, props.minVisiblePoints),
+  )
+  // Only constrain against loaded groups that overlap the requested window. An
+  // unloaded remote window must remain free to move beyond the cached samples.
+  const loadedGroups = availableGroups.filter((group) =>
+    group.some((series) => {
+      const source = series.source
+      const length = source?.length ?? series.points.length
+      if (!length) return false
+      const first = source ? source.pointAt(0)! : series.points[0]
+      const last = source ? source.pointAt(length - 1)! : series.points[length - 1]
+      return first.x <= Math.max(...domain) && last.x >= Math.min(...domain)
+    }),
+  )
+  return constrainZoomDomain(domain, boundary, loadedGroups, {
     ...props,
-    minVisiblePoints: 0,
     maxZoomScale: null,
-    minZoomSpan: resolveMinimumZoomSpan(baseDomain, groups, props),
+    minZoomSpan: resolveMinimumZoomSpan(baseDomain, availableGroups, props),
   })
 }

package/src/components/interaction/stepZoom.ts

@@ -0,0 +1,33 @@
+import type { ResolvedWaveformChartProps } from '../core/waveformChartTypes'
+import { normalizeIntegerZoomDomain } from './integerZoom'
+import { constrainViewportZoom } from './remoteViewport'
+import type { ZoomSeriesGroup } from './zoomConstraints'
+
+export const sameZoomDomain = (a: [number, number], b: [number, number]) =>
+  a.every((value, index) => Math.abs(value - b[index]!) < 1e-12)
+
+/** Toolbar and wheel steps share their scale factor and constraints. */
+export function resolveStepZoomDomain(
+  current: [number, number],
+  action: 'zoom-in' | 'zoom-out',
+  boundary: [number, number],
+  groups: readonly ZoomSeriesGroup[],
+  props: ResolvedWaveformChartProps,
+  anchorRatio = 0.5,
+): [number, number] {
+  const [start, end] = current
+  const ratio = Math.max(0, Math.min(1, anchorRatio))
+  const anchor = start + (end - start) * ratio
+  const span = (end - start) * (action === 'zoom-in' ? 0.5 : 2)
+  const constrained = constrainViewportZoom(
+    normalizeIntegerZoomDomain([anchor - span * ratio, anchor + span * (1 - ratio)], props),
+    boundary,
+    groups,
+    props,
+  )
+  // An unsatisfiable point constraint may expand to the entire boundary.
+  // A zoom-in step must not turn into a zoom-out operation.
+  return action === 'zoom-in' && constrained[1] - constrained[0] > end - start
+    ? [...current]
+    : constrained
+}

package/src/components/interaction/useWaveformViewport.ts

@@ -12,6 +12,7 @@ import { constrainViewportZoom } from './remoteViewport'
 import { createViewportPan } from './viewportPan'
 import { transformForDomain } from './zoomConstraints'
 import { emitBoxZoomIntent } from './zoomEventPayload'
+import { sameZoomDomain } from './stepZoom'
 export interface ViewportContext {
   clearBoundaries?: (trackIndex?: number) => void
   props: ResolvedWaveformChartProps
@@ -32,8 +33,6 @@ export interface ViewportContext {
   isPresentationMode: ComputedRef<boolean>
   editorSeriesOptions: Ref<AnnotationSeriesCandidate[]>
   resolveInitialTrackDomain: (track: TrackLayout) => [number, number]
-  canZoomTrack: (track: TrackLayout) => boolean
-  canZoomSharedTracks: () => boolean
   configureZoom: () => void
   cancelPendingZoom: () => void
   clearHover: () => void
@@ -59,8 +58,6 @@ export function useWaveformViewport(context: ViewportContext) {
     isPresentationMode,
     editorSeriesOptions,
     resolveInitialTrackDomain,
-    canZoomTrack,
-    canZoomSharedTracks,
     configureZoom,
     cancelPendingZoom,
     clearHover,
@@ -184,7 +181,7 @@ export function useWaveformViewport(context: ViewportContext) {
   }
   const applyBoxZoom = (active: ViewportSelectionState) => {
     const track = trackLayouts.value.find((item) => item.index === active.trackIndex)
-    if (!track || (active.independent ? !canZoomTrack(track) : !canZoomSharedTracks())) return
+    if (!track) return
     const offsetX = active.independent ? 0 : track.left
     const left = Math.max(
       0,
@@ -205,6 +202,7 @@ export function useWaveformViewport(context: ViewportContext) {
       groups,
       props,
     )
+    if (sameZoomDomain(track.xScale.domain() as [number, number], xDomain)) return
     if (active.independent) {
       const next = [...independentTransforms.value]
       next[track.index] = transformForDomain(xDomain, baseXDomain, track.width)
@@ -333,26 +331,6 @@ export function useWaveformViewport(context: ViewportContext) {
     editorSeriesOptions,
     configureZoom,
   })
-  const requestViewportReset = (event: MouseEvent) => {
-    if (isPresentationMode.value || !props.zoomable || !isZoomMode.value) return
-    if (props.displayMode === 'independent') {
-      const target = event.target instanceof Element ? event.target : null
-      const overlay = target?.closest('[data-independent-overlay-index]')
-      const trackIndex = Number(overlay?.getAttribute('data-independent-overlay-index'))
-      const track = trackLayouts.value.find((item) => item.index === trackIndex)
-      if (!track) return
-      event.preventDefault()
-      resetViewport(trackIndex)
-      emit('zoom-reset', {
-        trackIndex,
-        seriesIds: track.legendSeries.map((series) => series.id),
-      })
-      return
-    }
-    event.preventDefault()
-    resetViewport()
-    emit('zoom-reset', {})
-  }
   return {
     selectionBox,
     beginViewportDrag,
@@ -362,6 +340,5 @@ export function useWaveformViewport(context: ViewportContext) {
     cancelViewportDrag,
     resetViewport,
     setViewportDomain,
-    requestViewportReset,
   }
 }

package/src/components/interaction/useWaveformZoom.ts

@@ -1,23 +1,13 @@
-import {
-  scaleLinear,
-  select,
-  zoom,
-  zoomIdentity,
-  zoomTransform,
-  type D3ZoomEvent,
-  type ZoomBehavior,
-  type ZoomTransform,
-} from 'd3'
+import { pointer, scaleLinear, select, zoomIdentity, zoomTransform, type ZoomTransform } from 'd3'
 import type { ComputedRef, ShallowRef } from 'vue'
 
-import { hasMinimumVisibleXValues } from '../../core/rendering'
-import { WHEEL_ZOOM_DEBOUNCE_MS, ZOOM_CONSTRAINTS } from '../core/constants'
+import { WHEEL_ZOOM_DEBOUNCE_MS } from '../core/constants'
 import type { TrackLayout } from '../core/types'
 import type { ResolvedWaveformChartProps, WaveformChartEmit } from '../core/waveformChartTypes'
 import { useAnimationFrameThrottle } from '../utils/useAnimationFrameThrottle'
-import { constrainViewportZoom, remotePanBoundary } from './remoteViewport'
+import { resolveStepZoomDomain, sameZoomDomain } from './stepZoom'
 import { normalizeIntegerZoomDomain } from './integerZoom'
-import { resolveMinimumZoomSpan, transformForDomain, type ZoomSeriesGroup } from './zoomConstraints'
+import { transformForDomain, type ZoomSeriesGroup } from './zoomConstraints'
 import {
   emitIndependentWheelZoomEnds,
   emitSharedWheelZoomEnd,
@@ -57,16 +47,13 @@ export function useWaveformZoom(context: ZoomContext) {
     initialXDomain,
     sharedZoomDomain,
     innerWidth,
-    innerHeight,
     hasChartArea,
     isZoomMode,
     isPresentationMode,
     resolveInitialTrackDomain,
     cancelPendingHover,
   } = context
-  const zoomBehaviors = new Map<number | 'shared', ZoomBehavior<SVGRectElement, unknown>>()
   const zoomThrottle = useAnimationFrameThrottle()
-  let synchronizingZoomTransform = false
   let pendingSharedZoomTransform: ZoomTransform | null = null
   let pendingSharedZoomGesture: ZoomGestureKind | null = null
   let lastSharedZoomGesture: ZoomGestureKind | null = null
@@ -75,11 +62,10 @@ export function useWaveformZoom(context: ZoomContext) {
   const lastIndependentWheelSeriesIds = new Map<string, string[]>()
   let wheelZoomEndTimer: ReturnType<typeof setTimeout> | undefined
   let preservePendingWheelDuringDataRebind = false
-  let zoomBindingEpoch = 0
 
   const scheduleZoomCommit = () => zoomThrottle.schedule(commitPendingZoom)
-  const handleSharedZoom = (event: D3ZoomEvent<SVGRectElement, unknown>) => {
-    if (synchronizingZoomTransform || isPresentationMode.value) return
+  const handleSharedZoom = (event: { transform: ZoomTransform }) => {
+    if (isPresentationMode.value) return
     cancelPendingHover()
     pendingSharedZoomTransform = event.transform
     pendingSharedZoomGesture = 'wheel'
@@ -91,11 +77,8 @@ export function useWaveformZoom(context: ZoomContext) {
     emit('zoom-intent', { start, end, gesture: 'wheel' })
     scheduleZoomCommit()
   }
-  const handleIndependentZoom = (
-    event: D3ZoomEvent<SVGRectElement, unknown>,
-    trackIndex: number,
-  ) => {
-    if (synchronizingZoomTransform || isPresentationMode.value) return
+  const handleIndependentZoom = (event: { transform: ZoomTransform }, trackIndex: number) => {
+    if (isPresentationMode.value) return
     cancelPendingHover()
     pendingIndependentZoomTransforms.set(trackIndex, event.transform)
     pendingIndependentZoomGestures.set(trackIndex, 'wheel')
@@ -166,16 +149,6 @@ export function useWaveformZoom(context: ZoomContext) {
     emitSharedWheelZoomEnd(emit, sharedZoomDomain.value, trackLayouts.value)
     lastSharedZoomGesture = null
   }
-  const flushPendingZoom = () => {
-    zoomThrottle.flush()
-    commitPendingZoom()
-    if (lastSharedZoomGesture === 'wheel' || lastIndependentWheelSeriesIds.size) return
-    emitZoomEnd()
-  }
-  const handleD3ZoomEnd = (bindingEpoch: number) => {
-    if (bindingEpoch !== zoomBindingEpoch) return
-    flushPendingZoom()
-  }
   function scheduleWheelZoomEnd() {
     if (wheelZoomEndTimer !== undefined) clearTimeout(wheelZoomEndTimer)
     wheelZoomEndTimer = setTimeout(() => {
@@ -207,81 +180,50 @@ export function useWaveformZoom(context: ZoomContext) {
     }
   }
   const clearZoomBindings = (preservePendingWheel = false) => {
-    zoomBindingEpoch += 1
     if (!preservePendingWheel) cancelPendingZoom()
     svgElement.value
       ?.querySelectorAll<SVGRectElement>('.waveform-chart__overlay')
       .forEach((overlay) => select(overlay).on('.zoom', null))
-    zoomBehaviors.clear()
   }
-  const resolveMaximumZoomScale = (
-    domain: [number, number],
-    groups: readonly ZoomSeriesGroup[],
-  ): number => {
-    const domainSpan = Math.abs(domain[1] - domain[0])
-    if (!Number.isFinite(domainSpan) || domainSpan <= 0) return ZOOM_CONSTRAINTS.MIN_SCALE
-    const minimumSpan = resolveMinimumZoomSpan(domain, groups, props)
-    return Math.max(
-      ZOOM_CONSTRAINTS.MIN_SCALE,
-      minimumSpan > 0 ? domainSpan / minimumSpan : Number.POSITIVE_INFINITY,
-    )
-  }
-  const constrainTransform = (
-    transform: ZoomTransform,
-    domain: [number, number],
+  const bindWheelZoom = (
+    overlay: SVGRectElement,
+    baseDomain: [number, number],
     width: number,
     groups: readonly ZoomSeriesGroup[],
-  ): ZoomTransform => {
-    const requested = transform.rescaleX(scaleLinear(domain, [0, width])).domain() as [
-      number,
-      number,
-    ]
-    return transformForDomain(
-      constrainViewportZoom(requested, domain, groups, props),
-      domain,
-      width,
-    )
-  }
-  const canZoomTrack = (track: TrackLayout): boolean => {
-    const minimum = Number(props.minVisiblePoints)
-    return hasMinimumVisibleXValues(
-      track.seriesList,
-      track.xScale.domain() as [number, number],
-      Number.isFinite(minimum) && minimum > 0 ? Math.ceil(minimum) + 1 : minimum,
-    )
-  }
-  const canZoomSharedTracks = (): boolean => {
-    const tracks = trackLayouts.value.filter((track) => track.hasVisibleSeries)
-    return tracks.length > 0 && tracks.every(canZoomTrack)
-  }
-  const resolveMinimumZoomScale = (domain: [number, number]): number => {
-    const boundary = remotePanBoundary(props)
-    return boundary
-      ? Math.min(1, (domain[1] - domain[0]) / (boundary[1] - boundary[0]))
-      : ZOOM_CONSTRAINTS.MIN_SCALE
-  }
-  const canHandleWheelZoom = (event: Event, canZoomIn: boolean, minimumScale: number): boolean => {
-    if (event.type !== 'wheel') return false
-    const deltaY = (event as WheelEvent).deltaY
-    const currentScale = zoomTransform(event.currentTarget as Element).k
-
-    // 放大操作：需要检查是否还有足够的数据点支持继续放大
-    if (deltaY < 0) return canZoomIn
-
-    // 缩小操作：只要当前缩放级别大于最小比例就允许
-    // 即使已达到最小可见点数限制，用户也应该能够缩小视图
-    if (deltaY > 0) {
-      // 使用小的容差避免浮点精度问题导致无法缩小到边界
-      const scaleTolerance = 1e-6
-      return currentScale > minimumScale * (1 + scaleTolerance)
-    }
-
-    return false
+    transform: ZoomTransform,
+    trackIndex?: number,
+  ) => {
+    select(overlay)
+      .property('__zoom', transform)
+      .on(
+        'wheel.zoom',
+        (event: WheelEvent) => {
+          if (!Number.isFinite(event.deltaY) || event.deltaY === 0) return
+          const current = zoomTransform(overlay)
+            .rescaleX(scaleLinear(baseDomain, [0, width]))
+            .domain() as [number, number]
+          const next = resolveStepZoomDomain(
+            current,
+            event.deltaY < 0 ? 'zoom-in' : 'zoom-out',
+            baseDomain,
+            groups,
+            props,
+            pointer(event, overlay)[0] / width,
+          )
+          if (sameZoomDomain(current, next)) return
+          event.preventDefault()
+          event.stopImmediatePropagation()
+          const transform = transformForDomain(next, baseDomain, width)
+          select(overlay).property('__zoom', transform)
+          if (trackIndex === undefined) handleSharedZoom({ transform })
+          else handleIndependentZoom({ transform }, trackIndex)
+        },
+        { passive: false },
+      )
   }
   const configureZoom = () => {
     const preservePendingWheel = preservePendingWheelDuringDataRebind
     clearZoomBindings(preservePendingWheel)
-    const bindingEpoch = zoomBindingEpoch
     if (
       isPresentationMode.value ||
       !props.zoomable ||
@@ -299,35 +241,14 @@ export function useWaveformZoom(context: ZoomContext) {
         if (!overlay) return
         const dataDomain = resolveInitialTrackDomain(track)
         const groups = [track.seriesList]
-        const minimumScale = resolveMinimumZoomScale(dataDomain)
-        const behavior = zoom<SVGRectElement, unknown>()
-          .filter((event) => {
-            const currentTrack =
-              trackLayouts.value.find((item) => item.index === track.index) ?? track
-            return canHandleWheelZoom(event, canZoomTrack(currentTrack), minimumScale)
-          })
-          .scaleExtent([minimumScale, resolveMaximumZoomScale(dataDomain, groups)])
-          .constrain((transform) => constrainTransform(transform, dataDomain, track.width, groups))
-          .extent([
-            [0, 0],
-            [track.width, track.height],
-          ])
-          .translateExtent([
-            [0, 0],
-            [track.width, track.height],
-          ])
-          .on('zoom', (event) => handleIndependentZoom(event, track.index))
-          .on('end', () => handleD3ZoomEnd(bindingEpoch))
-        zoomBehaviors.set(track.index, behavior)
-        synchronizingZoomTransform = true
-        try {
-          select(overlay)
-            .call(behavior)
-            .on('dblclick.zoom', null)
-            .call(behavior.transform, independentTransforms.value[track.index] ?? zoomIdentity)
-        } finally {
-          synchronizingZoomTransform = false
-        }
+        bindWheelZoom(
+          overlay,
+          dataDomain,
+          track.width,
+          groups,
+          independentTransforms.value[track.index] ?? zoomIdentity,
+          track.index,
+        )
       })
       return
     }
@@ -336,40 +257,12 @@ export function useWaveformZoom(context: ZoomContext) {
     const groups = trackLayouts.value
       .filter((track) => track.hasVisibleSeries)
       .map((track) => track.seriesList)
-    const minimumScale = resolveMinimumZoomScale(initialXDomain.value)
-    const behavior = zoom<SVGRectElement, unknown>()
-      .filter((event) => canHandleWheelZoom(event, canZoomSharedTracks(), minimumScale))
-      .scaleExtent([minimumScale, resolveMaximumZoomScale(initialXDomain.value, groups)])
-      .constrain((transform) =>
-        constrainTransform(transform, initialXDomain.value, innerWidth.value, groups),
-      )
-      .extent([
-        [0, 0],
-        [innerWidth.value, innerHeight.value],
-      ])
-      .translateExtent([
-        [0, 0],
-        [innerWidth.value, innerHeight.value],
-      ])
-      .on('zoom', handleSharedZoom)
-      .on('end', () => handleD3ZoomEnd(bindingEpoch))
-    zoomBehaviors.set('shared', behavior)
-    synchronizingZoomTransform = true
-    try {
-      select(overlay)
-        .call(behavior)
-        .on('dblclick.zoom', null)
-        .call(behavior.transform, sharedTransform.value)
-    } finally {
-      synchronizingZoomTransform = false
-    }
+    bindWheelZoom(overlay, initialXDomain.value, innerWidth.value, groups, sharedTransform.value)
   }
 
   return {
     cancelPendingZoom,
     clearZoomBindings,
-    canZoomTrack,
-    canZoomSharedTracks,
     configureZoom,
     prepareForDataChange,
   }

package/src/components/interaction/zoomConstraints.ts

@@ -73,7 +73,7 @@ export function resolveMinimumZoomSpan(
   groups: readonly ZoomSeriesGroup[],
   options: ZoomConstraintOptions,
 ): number {
-  const normalized = alignIntegerZoomDomain(normalizedBoundary(boundary), options)
+  const normalized = normalizedBoundary(boundary)
   const boundarySpan = normalized[1] - normalized[0]
   if (!Number.isFinite(boundarySpan) || boundarySpan <= 0) return 0
   const configuredSpan =
@@ -89,8 +89,7 @@ export function resolveMinimumZoomSpan(
       : options.maxZoomScale !== null && configuredSpan === 0 && required === 0
         ? boundarySpan / ZOOM_CONSTRAINTS.DEFAULT_MAX_SCALE
         : 0
-  const integerSpan = options.integerZoom ? (options.timeUnit === 's' ? 1 : 0.001) : 0
-  return Math.max(configuredSpan, pointSpan, scaleSpan, integerSpan)
+  return Math.max(configuredSpan, pointSpan, scaleSpan)
 }
 
 function expandToMinimumPoints(
@@ -141,7 +140,7 @@ export function constrainZoomDomain(
   groups: readonly ZoomSeriesGroup[],
   options: ZoomConstraintOptions,
 ): [number, number] {
-  const normalized = alignIntegerZoomDomain(normalizedBoundary(boundary), options)
+  const normalized = normalizedBoundary(boundary)
   const boundarySpan = normalized[1] - normalized[0]
   if (!Number.isFinite(boundarySpan) || boundarySpan <= 0) return normalized
   if (Math.abs(domain[1] - domain[0]) >= boundarySpan * (1 - 1e-12)) return normalized
@@ -159,7 +158,8 @@ export function constrainZoomDomain(
   const span = Math.max(minimumSpan, Math.min(boundarySpan, expanded[1] - expanded[0]))
   const center = (expanded[0] + expanded[1]) / 2
   const start = Math.max(normalized[0], Math.min(center - span / 2, normalized[1] - span))
-  return alignIntegerZoomDomain([start, start + span], options)
+  const aligned = alignIntegerZoomDomain([start, start + span], options)
+  return [Math.max(normalized[0], aligned[0]), Math.min(normalized[1], aligned[1])]
 }
 
 export function transformForDomain(

package/src/core/data.ts

@@ -215,10 +215,11 @@ function normalizedSeriesOptions(
 /** Internal normalized series which preserves compact TypedArray storage for chart rendering. */
 export function normalizeWaveformSeriesSources(
   data: WaveformData,
+  retainEmpty = false,
 ): NormalizedWaveformSourceSeries[] {
   if (data.kind !== 'series') {
     const source = createWaveformPointSource(data, normalizeWaveformData)
-    return source.length
+    return source.length || retainEmpty
       ? [
           {
             ...normalizedSeriesOptions('series-0', { name: '' }),
@@ -239,7 +240,9 @@ export function normalizeWaveformSeriesSources(
     }
     usedIds.add(uniqueId)
     const source = createWaveformPointSource(series.data, normalizeWaveformData)
-    return source.length ? [{ ...normalizedSeriesOptions(uniqueId, series), source }] : []
+    return source.length || retainEmpty
+      ? [{ ...normalizedSeriesOptions(uniqueId, series), source }]
+      : []
   })
 }
 

package/src/data/simulatedWaveforms.ts

@@ -1,6 +1,5 @@
 import type { WaveformData, WaveformPoint, WaveformSeries } from '../types'
 import { recordedDampedPoints } from './recordedDampedWaveform'
-import { sx2Channel } from './sx2Channel'
 
 const POINT_COUNT = 1_000
 const START_TIME = -5
@@ -177,15 +176,6 @@ const seriesDefinitions: SimulatedSeriesDefinition[] = [
     pointType: 'none',
     signal: (time) => 6e-9 * Math.exp(-(time + 5) * 0.2) * Math.cos(TWO_PI * 0.8 * time),
   },
-  {
-    id: `recorded-${sx2Channel.chnl_id}`,
-    shotNo: String(sx2Channel.shot),
-    name: sx2Channel.chnl,
-    unit: sx2Channel.dat_unit,
-    lineType: 'linear',
-    pointType: 'none',
-    signal: sx2Channel.data.map((value, index) => [sx2Channel.time[index]!, value]),
-  },
 ]
 
 export function createSimulatedWaveformData(trackCount?: number): WaveformData {