@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-N3TIT3OH.mjs

@@ -0,0 +1,1040 @@
+import { lineHitTest, lineFindAllNearest, computeStackBases } from './chunk-WFTX4AQJ.mjs';
+import { buildLinePath, buildStackedFillPath, buildFillPath, hitTestLine, calculateLineLayout, applyTipExtension, restoreTipExtension, buildRangeFillPath, buildDualRangeFillPaths } from './chunk-6HSEJLSR.mjs';
+import { collectLineMarkerOverlays } from './chunk-X4D7FKUS.mjs';
+import { registerDatasetLayers, triggerCompositorRepaint } from './chunk-Q6PPVIHU.mjs';
+import { resolvePointLabels } from './chunk-66T4MRC5.mjs';
+import { renderResolvedLabels } from './chunk-QQBXUDM4.mjs';
+import { AnimatedScene, resolveAnimatedProps, LINE_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { cancelRaf, raf } from './chunk-EDAKJLNA.mjs';
+import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { DEFAULT_HOVER_DIM_OPACITY, DEFAULT_HOVER_BRIGHTNESS, DEFAULT_FALLBACK_COLOR } from './chunk-NKUYIWAP.mjs';
+import { streamingPointsInterpolator, buildLineFingerprint, detectStreamingUpdateKind } from './chunk-XQQCGFYB.mjs';
+import { getDefaultColor, isGradientColor, createCanvasGradientFromColor, createSvgGradientFromColor } from './chunk-O2X6FF45.mjs';
+import { createSvgDefs, appendChild, createSvgPath, setAttr, createSvgGroup, materializeSvgNode } from './chunk-SSLTFJ3U.mjs';
+
+// src/series/line/controller/helpers.ts
+function resolveLineAnimationPlan(layouts, animConfig, isInitial, lastFingerprint, sceneElementCount) {
+  const updateMode = animConfig?.updateMode ?? "auto";
+  const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+  const limit = animConfig?.limit ?? 5e3;
+  const fingerprint = buildLineFingerprint(layouts);
+  const phase = isInitial ? "entrance" : lastFingerprint !== "" && fingerprint !== lastFingerprint ? "update" : "static";
+  let totalPoints = 0;
+  for (const [, layout] of layouts) {
+    totalPoints += layout.points.length;
+  }
+  const shouldAnimate = animEnabled && duration > 0 && totalPoints <= limit && (totalPoints > 0 || sceneElementCount > 0) && phase !== "static";
+  return { fingerprint, updateMode, limit, phase, totalPoints, shouldAnimate, duration, easing };
+}
+function findNearestPointIndexByX(layout, axisX) {
+  const pts = layout.visiblePoints;
+  const bandStep = pts.length >= 2 ? Math.abs(pts[1].x - pts[0].x) : Infinity;
+  const halfStep = isFinite(bandStep) ? bandStep / 2 : Infinity;
+  let bestIdx = null;
+  let bestDist = Infinity;
+  for (const pt of pts) {
+    const d = Math.abs(pt.x - axisX);
+    if (d < bestDist) {
+      bestDist = d;
+      bestIdx = pt.dataIndex;
+    }
+  }
+  if (bestDist > halfStep) bestIdx = null;
+  return bestIdx;
+}
+function computeTipPositions(layouts, tipProgress, isExiting) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const [id, layout] of layouts) {
+    if (isExiting(id)) continue;
+    const points = layout.visiblePoints;
+    if (points.length < 2) continue;
+    const last = points[points.length - 1];
+    const prev = points[points.length - 2];
+    const x = prev.x + (last.x - prev.x) * tipProgress;
+    const y = prev.y + (last.y - prev.y) * tipProgress;
+    positions.set(id, { x, y });
+  }
+  return positions.size > 0 ? positions : null;
+}
+
+// src/series/line/controller/types.ts
+var LINE_REGISTRY = {
+  number: [],
+  color: [],
+  custom: {
+    geometry: streamingPointsInterpolator
+  }
+};
+
+// src/series/line/controller/hover.ts
+function applyHoverToProps(ctx, propsMap) {
+  if (ctx._hoverPropsCacheResult && ctx._hoverPropsCacheHover === ctx.hover && ctx._hoverPropsCachePropsMap === propsMap) {
+    return ctx._hoverPropsCacheResult;
+  }
+  const result = /* @__PURE__ */ new Map();
+  const anyHovered = ctx.hover.datasetId !== null && ctx.lastInput?.hoverConfig != null;
+  const axisX = ctx.hover.axisX;
+  const axisIndex = ctx.hover.axisIndex;
+  const isAxisMode = axisX != null || axisIndex != null;
+  for (const [dsId, props] of propsMap) {
+    const isThisSeries = ctx.hover.datasetId === dsId;
+    let hoveredIndex;
+    if (axisX != null) {
+      const layout = ctx.layoutCache.get(dsId);
+      hoveredIndex = layout ? findNearestPointIndexByX(layout, axisX) : null;
+    } else {
+      hoveredIndex = axisIndex != null ? axisIndex : isThisSeries ? ctx.hover.index : null;
+    }
+    result.set(dsId, {
+      ...props,
+      interaction: {
+        ...props.interaction,
+        hoveredIndex,
+        isSeriesDimmed: isAxisMode ? false : anyHovered && !isThisSeries
+      }
+    });
+  }
+  ctx._hoverPropsCacheHover = ctx.hover;
+  ctx._hoverPropsCachePropsMap = propsMap;
+  ctx._hoverPropsCacheResult = result;
+  return result;
+}
+function applyHover(ctx, hover) {
+  ctx.hover = hover;
+  if (!ctx.lastRenderedLayouts || ctx.lastRenderedLayouts.size === 0 || !ctx.lastInput) return;
+  const input = ctx.lastInput;
+  if (triggerCompositorRepaint(input.renderer, ctx.canvasEl, input.compositor)) {
+    return;
+  }
+  if (ctx._animRafId !== null) return;
+  if (input.renderer === "svg" && ctx.svgGroup && ctx.lastRenderedLayouts) {
+    const context = {
+      chartId: input.chartId,
+      width: input.width,
+      height: input.height,
+      renderer: "svg",
+      chartArea: input.chartArea,
+      theme: input.theme
+    };
+    const layouts = ctx.lastRenderedLayouts;
+    const hoveredPropsMap = applyHoverToProps(ctx, ctx.activeRenderPropsCache);
+    const tipStates = [];
+    if (ctx.tipProgress < 1) {
+      for (const [id, layout] of layouts) {
+        const el = ctx._scene.getElement(id);
+        if (!el || el.current.isExiting) continue;
+        const state = applyTipExtension(layout, ctx.tipProgress);
+        if (state) tipStates.push({ layout, state });
+      }
+    }
+    try {
+      const children = buildLineSvgChildren({
+        paint: ctx._paint,
+        layouts,
+        renderPropsMap: hoveredPropsMap,
+        context,
+        datasetVisibility: input.datasetVisibility,
+        labelConfig: input.labelConfig,
+        rangeGroups: input.rangeGroups,
+        theme: input.theme
+      });
+      reconcileSvgChildren(ctx.svgGroup, children);
+    } finally {
+      for (const { layout, state } of tipStates) {
+        restoreTipExtension(layout, state);
+      }
+    }
+    return;
+  }
+  ctx.renderFrameCycle();
+}
+
+// src/series/line/controller/paint.ts
+function renderLinesFrame(params) {
+  const { paint, renderer, group, canvas, layouts, renderPropsMap, context, chartArea, rangeGroups, labelConfig, clipProgress, datasetVisibility } = params;
+  if (renderer === "svg" && group) {
+    while (group.firstChild) group.removeChild(group.firstChild);
+    let dataTarget = group;
+    if (clipProgress !== void 0 && clipProgress < 1) {
+      const clipId = `line-entrance-clip-${context.chartId}`;
+      const clipPath = document.createElementNS("http://www.w3.org/2000/svg", "clipPath");
+      clipPath.setAttribute("id", clipId);
+      const clipRect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+      clipRect.setAttribute("x", String(chartArea.x));
+      clipRect.setAttribute("y", String(chartArea.y));
+      clipRect.setAttribute("width", String(Math.max(0, chartArea.width * clipProgress)));
+      clipRect.setAttribute("height", String(chartArea.height));
+      clipPath.appendChild(clipRect);
+      group.appendChild(clipPath);
+      dataTarget = document.createElementNS("http://www.w3.org/2000/svg", "g");
+      dataTarget.setAttribute("clip-path", `url(#${clipId})`);
+    }
+    const children = buildLineSvgChildren({ paint, layouts, renderPropsMap, context, datasetVisibility, labelConfig, rangeGroups, theme: context.theme });
+    dataTarget.replaceChildren(...children.map(materializeSvgNode));
+    if (dataTarget !== group) {
+      group.appendChild(dataTarget);
+    }
+  }
+  if (renderer === "canvas") {
+    const ctx = canvas?.getContext("2d");
+    if (!ctx) return;
+    if (clipProgress !== void 0 && clipProgress < 1) {
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(chartArea.x, chartArea.y, chartArea.width * clipProgress, chartArea.height);
+      ctx.clip();
+    }
+    if (rangeGroups) {
+      renderRangeFillsCanvas(ctx, rangeGroups, layouts, renderPropsMap, chartArea, context.theme);
+    }
+    for (const [, lineLayout] of layouts) {
+      const props = renderPropsMap.get(lineLayout.datasetId);
+      if (!props) continue;
+      const hasCustomRenderMarker = !!props.renderMarker;
+      const renderProps = hasCustomRenderMarker ? { ...props, showMarkers: false, interaction: { ...props.interaction, hoveredIndex: null } } : { ...props, interaction: { ...props.interaction, hoveredIndex: null } };
+      paint.renderCanvas(renderProps, lineLayout, ctx, context);
+    }
+    for (const [, lineLayout] of layouts) {
+      const props = renderPropsMap.get(lineLayout.datasetId);
+      if (!props) continue;
+      const hoveredIndex = props.interaction?.hoveredIndex ?? null;
+      if (hoveredIndex === null) continue;
+      if (props.renderMarker) continue;
+      const markerOnlyProps = { ...props, showMarkers: false, fillOpacity: 0, lineStrokeWidth: 0 };
+      paint.renderCanvas(markerOnlyProps, lineLayout, ctx, context);
+    }
+    if (labelConfig) {
+      for (const [, lineLayout] of layouts) {
+        if (datasetVisibility?.get(lineLayout.datasetId) === false) continue;
+        const props = renderPropsMap.get(lineLayout.datasetId);
+        if (!props) continue;
+        const seriesColor = typeof lineLayout.lineColor === "string" ? lineLayout.lineColor : getDefaultColor(lineLayout.seriesIdx, context.theme);
+        const total = lineLayout.visiblePoints.reduce((sum, pt) => sum + (pt.value ?? 0), 0);
+        const labels = resolvePointLabels(lineLayout.visiblePoints, seriesColor, total, labelConfig, props.name, props.data);
+        renderResolvedLabels(labels, labelConfig, { renderer: "canvas", ctx, theme: context.theme });
+      }
+    }
+    if (clipProgress !== void 0 && clipProgress < 1) {
+      ctx.restore();
+    }
+  }
+}
+function buildLineSvgChildren(params) {
+  const { paint, layouts, renderPropsMap, context, datasetVisibility, labelConfig, rangeGroups, theme } = params;
+  const children = [];
+  if (rangeGroups) {
+    for (const [rgKey, rg] of rangeGroups) {
+      if (rg.datasetIds.length < 2) continue;
+      const layoutA = layouts.get(rg.datasetIds[0]);
+      const layoutB = layouts.get(rg.datasetIds[1]);
+      if (!layoutA || !layoutB) continue;
+      const dimOpacity = computeRangeDimOpacity(rg, renderPropsMap);
+      const propsA = renderPropsMap.get(rg.datasetIds[0]);
+      const curve = propsA?.curve ?? "linear";
+      const tension = propsA?.tension;
+      if (rg.color !== void 0) {
+        const pathD = buildRangeFillPath(layoutA.visiblePoints, layoutB.visiblePoints, curve, tension);
+        if (pathD) {
+          let fill;
+          if (isGradientColor(rg.color)) {
+            const ca = layoutA.chartArea;
+            const gradId = `p-chart-range-grad-${rgKey}-${rg.datasetIds[0]}`;
+            const defs = createSvgDefs();
+            appendChild(defs, createSvgGradientFromColor(rg.color, gradId, { x: ca.x + ca.width / 2, y: ca.y + ca.height / 2 }, Math.max(ca.width, ca.height) / 2, ca, "vertical"));
+            children.push(defs);
+            fill = `url(#${gradId})`;
+          } else {
+            fill = typeof rg.color === "string" ? rg.color : DEFAULT_FALLBACK_COLOR;
+          }
+          children.push(createSvgPath(pathD, { fill, opacity: rg.fillOpacity * dimOpacity }));
+        }
+      } else {
+        const result = buildDualRangeFillPaths(layoutA.visiblePoints, layoutB.visiblePoints, curve, tension);
+        if (result) {
+          const colorA = typeof layoutA.lineColor === "string" ? layoutA.lineColor : getDefaultColor(layoutA.seriesIdx, theme);
+          const colorB = typeof layoutB.lineColor === "string" ? layoutB.lineColor : getDefaultColor(layoutB.seriesIdx, theme);
+          const opacity = rg.fillOpacity * dimOpacity;
+          for (const d of result.abovePaths) children.push(createSvgPath(d, { fill: colorA, opacity }));
+          for (const d of result.belowPaths) children.push(createSvgPath(d, { fill: colorB, opacity }));
+        }
+      }
+    }
+  }
+  for (const [dsId, lineLayout] of layouts) {
+    const props = renderPropsMap.get(dsId);
+    if (!props) continue;
+    const hasCustomRenderMarker = !!props.renderMarker;
+    const renderProps = hasCustomRenderMarker ? { ...props, showMarkers: false, interaction: { ...props.interaction, hoveredIndex: null } } : { ...props, interaction: { ...props.interaction, hoveredIndex: null } };
+    const node = paint.renderSvg(renderProps, lineLayout, context);
+    setAttr(node, "data-dataset", dsId);
+    if (context.accessibility?.enabled && context.accessibility.landmarkVerbosity === "all") {
+      setAttr(node, "role", "region");
+      setAttr(node, "aria-label", generateSeriesDescription(props.name ?? dsId, "line", lineLayout.visiblePoints.length));
+    }
+    children.push(node);
+  }
+  for (const [dsId, lineLayout] of layouts) {
+    const props = renderPropsMap.get(dsId);
+    if (!props) continue;
+    const hoveredIndex = props.interaction?.hoveredIndex ?? null;
+    if (hoveredIndex === null) continue;
+    if (props.renderMarker) continue;
+    const markerOnlyProps = { ...props, showMarkers: false, fillOpacity: 0, lineStrokeWidth: 0 };
+    const node = paint.renderSvg(markerOnlyProps, lineLayout, context);
+    setAttr(node, "data-dataset", `${dsId}-hover`);
+    children.push(node);
+  }
+  if (labelConfig && !labelConfig.render) {
+    const labelGroup = createSvgGroup();
+    for (const [, lineLayout] of layouts) {
+      if (datasetVisibility?.get(lineLayout.datasetId) === false) continue;
+      const seriesColor = typeof lineLayout.lineColor === "string" ? lineLayout.lineColor : getDefaultColor(lineLayout.seriesIdx, context.theme);
+      const total = lineLayout.visiblePoints.reduce((sum, pt) => sum + (pt.value ?? 0), 0);
+      const labels = resolvePointLabels(lineLayout.visiblePoints, seriesColor, total, labelConfig, renderPropsMap.get(lineLayout.datasetId)?.name, renderPropsMap.get(lineLayout.datasetId)?.data);
+      renderResolvedLabels(labels, labelConfig, { renderer: "svg", svgGroup: labelGroup, theme: context.theme });
+    }
+    children.push(labelGroup);
+  }
+  return children;
+}
+function computeRangeDimOpacity(rg, renderPropsMap) {
+  const propsA = renderPropsMap.get(rg.datasetIds[0]);
+  const propsB = renderPropsMap.get(rg.datasetIds[1]);
+  const dimmedA = propsA?.interaction?.isSeriesDimmed ?? false;
+  const dimmedB = propsB?.interaction?.isSeriesDimmed ?? false;
+  if (dimmedA && dimmedB) {
+    const effects = propsA?.effects ?? propsB?.effects;
+    return effects?.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY;
+  }
+  return 1;
+}
+function renderRangeFillsCanvas(ctx, rangeGroups, layouts, renderPropsMap, chartArea, theme) {
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(chartArea.x, chartArea.y, chartArea.width, chartArea.height);
+  ctx.clip();
+  for (const [, rg] of rangeGroups) {
+    if (rg.datasetIds.length < 2) continue;
+    const layoutA = layouts.get(rg.datasetIds[0]);
+    const layoutB = layouts.get(rg.datasetIds[1]);
+    if (!layoutA || !layoutB) continue;
+    const dimOpacity = computeRangeDimOpacity(rg, renderPropsMap);
+    const propsA = renderPropsMap.get(rg.datasetIds[0]);
+    const curve = propsA?.curve ?? "linear";
+    const tension = propsA?.tension;
+    if (rg.color !== void 0) {
+      const pathD = buildRangeFillPath(layoutA.visiblePoints, layoutB.visiblePoints, curve, tension);
+      if (pathD) {
+        const fill = isGradientColor(rg.color) ? createCanvasGradientFromColor(ctx, rg.color, { x: chartArea.x + chartArea.width / 2, y: chartArea.y + chartArea.height / 2 }, Math.max(chartArea.width, chartArea.height) / 2, chartArea, "vertical") : typeof rg.color === "string" ? rg.color : DEFAULT_FALLBACK_COLOR;
+        fillPathCanvas(ctx, pathD, fill, rg.fillOpacity * dimOpacity);
+      }
+    } else {
+      const result = buildDualRangeFillPaths(layoutA.visiblePoints, layoutB.visiblePoints, curve, tension);
+      if (!result) continue;
+      const colorA = typeof layoutA.lineColor === "string" ? layoutA.lineColor : getDefaultColor(layoutA.seriesIdx, theme);
+      const colorB = typeof layoutB.lineColor === "string" ? layoutB.lineColor : getDefaultColor(layoutB.seriesIdx, theme);
+      const opacity = rg.fillOpacity * dimOpacity;
+      for (const d of result.abovePaths) fillPathCanvas(ctx, d, colorA, opacity);
+      for (const d of result.belowPaths) fillPathCanvas(ctx, d, colorB, opacity);
+    }
+  }
+  ctx.restore();
+}
+function fillPathCanvas(ctx, pathD, color, opacity) {
+  ctx.save();
+  ctx.globalAlpha *= opacity;
+  ctx.fillStyle = color;
+  ctx.fill(new Path2D(pathD));
+  ctx.restore();
+}
+function renderSvgFrame(ctx) {
+  if (!ctx.lastInput || !ctx.lastRenderedLayouts) return;
+  const input = ctx.lastInput;
+  const layouts = ctx.lastRenderedLayouts;
+  const context = {
+    chartId: input.chartId,
+    width: input.width,
+    height: input.height,
+    renderer: "svg",
+    chartArea: input.chartArea,
+    theme: input.theme
+  };
+  const tipStates = [];
+  if (ctx.tipProgress < 1) {
+    for (const [id, layout] of layouts) {
+      const el = ctx._scene.getElement(id);
+      if (!el || el.current.isExiting) continue;
+      const state = applyTipExtension(layout, ctx.tipProgress);
+      if (state) tipStates.push({ layout, state });
+    }
+  }
+  try {
+    renderLinesFrame({
+      paint: ctx._paint,
+      renderer: "svg",
+      group: ctx.svgGroup,
+      canvas: null,
+      layouts,
+      renderPropsMap: applyHoverToProps(ctx, ctx.activeRenderPropsCache),
+      context,
+      chartArea: input.chartArea,
+      rangeGroups: input.rangeGroups,
+      labelConfig: input.labelConfig,
+      clipProgress: ctx.entranceClipProgress < 1 ? ctx.entranceClipProgress : void 0,
+      dir: input.dir,
+      datasetVisibility: input.datasetVisibility
+    });
+  } finally {
+    for (const { layout, state } of tipStates) {
+      restoreTipExtension(layout, state);
+    }
+  }
+}
+function paintCanvasLayer(ctx, canvasCtx, dsId, rangeFirstDs, context) {
+  const frameLayouts = ctx.lastRenderedLayouts;
+  const layout = frameLayouts?.get(dsId);
+  if (!layout || !ctx.lastInput) return;
+  const input = ctx.lastInput;
+  const el = ctx._scene.getElement(dsId);
+  const isExiting = el?.current.isExiting ?? false;
+  const hoveredProps = applyHoverToProps(ctx, ctx.activeRenderPropsCache);
+  const props = hoveredProps.get(dsId);
+  if (!props) return;
+  const clip = ctx.entranceClipProgress;
+  const clipActive = clip < 1;
+  if (clipActive) {
+    canvasCtx.save();
+    canvasCtx.beginPath();
+    canvasCtx.rect(input.chartArea.x, input.chartArea.y, Math.max(0, input.chartArea.width * clip), input.chartArea.height);
+    canvasCtx.clip();
+  }
+  const tipState = ctx.tipProgress < 1 && !isExiting ? applyTipExtension(layout, ctx.tipProgress) : null;
+  try {
+    if (rangeFirstDs.has(dsId) && input.rangeGroups) {
+      renderRangeFillsCanvas(canvasCtx, input.rangeGroups, frameLayouts, hoveredProps, input.chartArea, input.theme);
+    }
+    const renderProps = props.renderMarker ? { ...props, showMarkers: false, interaction: { ...props.interaction, hoveredIndex: null } } : props;
+    ctx._paint.renderCanvas(renderProps, layout, canvasCtx, context);
+    if (input.labelConfig && input.datasetVisibility?.get(dsId) !== false) {
+      const seriesColor = typeof layout.lineColor === "string" ? layout.lineColor : getDefaultColor(layout.seriesIdx, input.theme);
+      const total = layout.visiblePoints.reduce((sum, pt) => sum + (pt.value ?? 0), 0);
+      const labels = resolvePointLabels(layout.visiblePoints, seriesColor, total, input.labelConfig, props.name, props.data);
+      renderResolvedLabels(labels, input.labelConfig, { renderer: "canvas", ctx: canvasCtx, theme: input.theme });
+    }
+  } finally {
+    if (tipState) restoreTipExtension(layout, tipState);
+    if (clipActive) canvasCtx.restore();
+  }
+}
+
+// src/series/line/controller/scene.ts
+function clamp01(v) {
+  if (v < 0) return 0;
+  if (v > 1) return 1;
+  return v;
+}
+function cancelRafCtx(ctx) {
+  if (ctx._animRafId !== null) {
+    cancelRaf(ctx._animRafId);
+    ctx._animRafId = null;
+  }
+}
+function commit(ctx, fingerprint) {
+  ctx._isInitial = false;
+  ctx._lastFingerprint = fingerprint;
+}
+function startEntranceLoop(ctx, duration, easing) {
+  const startAt = performance.now();
+  const tick = (now) => {
+    ctx._animRafId = null;
+    const rawProgress = clamp01((now - startAt) / duration);
+    if (rawProgress >= 1) {
+      ctx.entranceClipProgress = 1;
+      renderFrameCycle(ctx);
+      return;
+    }
+    ctx.entranceClipProgress = easing(rawProgress);
+    renderFrameCycle(ctx);
+    ctx._animRafId = raf(tick);
+  };
+  ctx._animRafId = raf(tick);
+}
+function startSceneUpdateLoop(ctx, easing) {
+  const tipWasActive = ctx.tipDuration > 0;
+  const tick = (now) => {
+    ctx._animRafId = null;
+    const { allIdle } = ctx._scene.tick(now);
+    const tipRaw = ctx.tipDuration > 0 ? clamp01((now - ctx.tipStartAt) / ctx.tipDuration) : 1;
+    ctx.tipProgress = tipRaw >= 1 ? 1 : easing(tipRaw);
+    ctx.entranceClipProgress = 1;
+    renderFrameCycle(ctx);
+    if (ctx.tipProgress < 1 && ctx._lastTipPositions) {
+      for (const cb of ctx._tipSubscribers) cb(ctx._lastTipPositions);
+    }
+    const tipDone = tipRaw >= 1;
+    if (!allIdle || !tipDone) {
+      ctx._animRafId = raf(tick);
+      return;
+    }
+    ctx.tipProgress = 1;
+    ctx.tipDuration = 0;
+    ctx.entranceClipProgress = 1;
+    ctx._lastTipPositions = null;
+    if (tipWasActive) {
+      for (const cb of ctx._tipSubscribers) cb(null);
+    }
+    renderFrameCycle(ctx);
+  };
+  ctx._animRafId = raf(tick);
+}
+function buildSceneTargets(ctx, visibleDatasets, renderPropsMap, input, explicitMode) {
+  const targets = /* @__PURE__ */ new Map();
+  let anyTip = false;
+  for (const ds of visibleDatasets) {
+    const newValues = input.lineTransformedValues?.get(ds.id) ?? [];
+    const axisId = ds.props[input.axisIdProp] ?? input.firstValueAxisId;
+    const stackOrder = input.datasets.get(ds.id)?.order ?? 0;
+    const props = ds.props;
+    const renderProps = renderPropsMap.get(ds.id) ?? props;
+    let hint;
+    if (explicitMode === "auto") {
+      const prev = ctx._scene.getElement(ds.id)?.current.geometry.values;
+      hint = prev ? detectStreamingUpdateKind(prev, newValues) : "update";
+    } else {
+      hint = explicitMode;
+    }
+    if (hint === "append" || hint === "scroll") anyTip = true;
+    targets.set(ds.id, {
+      geometry: { values: newValues, streamingHint: hint },
+      datasetId: ds.id,
+      axisId,
+      stackOrder,
+      props,
+      renderProps,
+      isExiting: false
+    });
+  }
+  return { targets, anyTip };
+}
+function renderSceneFrame(ctx) {
+  const layouts = /* @__PURE__ */ new Map();
+  if (!ctx.lastInput) return layouts;
+  const input = ctx.lastInput;
+  if (!input.categoryScale || !input.valueScales || input.valueScales.size === 0) return layouts;
+  const elements = ctx._scene.getElements();
+  if (elements.length === 0) return layouts;
+  const sharedValueScale = input.valueScales.values().next().value;
+  const orderedElements = [...elements].sort((a, b) => a.current.stackOrder - b.current.stackOrder);
+  let categoryCount = 0;
+  for (const el of orderedElements) {
+    categoryCount = Math.max(categoryCount, el.current.geometry.values.length);
+  }
+  const stackedElements = orderedElements.filter((el) => el.current.props.stackId !== void 0);
+  const stackBasesMap = stackedElements.length > 0 && categoryCount > 0 ? computeStackBases(
+    stackedElements.map((el) => el.current.datasetId),
+    stackedElements.map((el) => el.current.geometry.values),
+    categoryCount,
+    { isStacked: true, isWaterfall: false }
+  ) : /* @__PURE__ */ new Map();
+  let datasetIndex = 0;
+  for (const el of orderedElements) {
+    const state = el.current;
+    const targetValueScale = input.valueScales.get(state.axisId) ?? sharedValueScale;
+    const groupedData = input.groupedDataOverride?.get(state.datasetId);
+    const propsForLayout = groupedData ? { ...state.props, data: groupedData } : state.props;
+    const isStacked = state.props.stackId !== void 0;
+    const baseLayout = calculateLineLayout(propsForLayout, input.chartArea, {
+      categoryScale: input.categoryScale,
+      valueScale: targetValueScale,
+      stackBases: isStacked ? stackBasesMap.get(state.datasetId) : void 0,
+      transformedValues: state.geometry.values,
+      seriesId: state.datasetId
+    });
+    layouts.set(state.datasetId, { ...baseLayout, datasetIndex: datasetIndex++ });
+  }
+  return layouts;
+}
+function updateRenderState(ctx) {
+  const layouts = renderSceneFrame(ctx);
+  const activeRenderProps = /* @__PURE__ */ new Map();
+  for (const el of ctx._scene.getElements()) {
+    const baseProps = el.current.renderProps;
+    const overrides = ctx._propertyOverrides.get(el.current.datasetId);
+    const merged = overrides ? { ...baseProps, ...overrides } : baseProps;
+    activeRenderProps.set(el.current.datasetId, merged);
+  }
+  ctx.activeRenderPropsCache = activeRenderProps;
+  ctx.lastRenderedLayouts = layouts;
+  ctx._markerOverlays = collectLineMarkerOverlays(layouts, activeRenderProps, ctx.lastInput?.renderer === "canvas");
+  if (ctx.tipProgress < 1) {
+    ctx._lastTipPositions = computeTipPositions(layouts, ctx.tipProgress, (id) => {
+      const el = ctx._scene.getElement(id);
+      return !el || el.current.isExiting;
+    });
+  } else {
+    ctx._lastTipPositions = null;
+  }
+}
+function renderFrameCycle(ctx) {
+  if (!ctx.lastInput) return;
+  updateRenderState(ctx);
+  const input = ctx.lastInput;
+  if (triggerCompositorRepaint(input.renderer, ctx.canvasEl, input.compositor)) {
+    ctx.onFrame?.();
+    return;
+  }
+  if (input.renderer === "svg") {
+    renderSvgFrame(ctx);
+  } else if (input.renderer === "canvas" && ctx.lastRenderedLayouts) {
+    const layouts = ctx.lastRenderedLayouts;
+    const tipStates = [];
+    if (ctx.tipProgress < 1) {
+      for (const [id, layout] of layouts) {
+        const el = ctx._scene.getElement(id);
+        if (!el || el.current.isExiting) continue;
+        const state = applyTipExtension(layout, ctx.tipProgress);
+        if (state) tipStates.push({ layout, state });
+      }
+    }
+    try {
+      renderLinesFrame({
+        paint: ctx._paint,
+        renderer: "canvas",
+        group: null,
+        canvas: ctx.canvasEl,
+        layouts,
+        renderPropsMap: applyHoverToProps(ctx, ctx.activeRenderPropsCache),
+        context: {
+          chartId: input.chartId,
+          width: input.width,
+          height: input.height,
+          renderer: "canvas",
+          chartArea: input.chartArea,
+          theme: input.theme
+        },
+        chartArea: input.chartArea,
+        rangeGroups: input.rangeGroups,
+        labelConfig: input.labelConfig,
+        clipProgress: ctx.entranceClipProgress < 1 ? ctx.entranceClipProgress : void 0,
+        dir: input.dir,
+        datasetVisibility: input.datasetVisibility
+      });
+    } finally {
+      for (const { layout, state } of tipStates) {
+        restoreTipExtension(layout, state);
+      }
+    }
+  }
+  ctx.onFrame?.();
+}
+
+// src/series/line/controller/index.ts
+var LineRendererController = class {
+  constructor(paint) {
+    // Animation lifecycle — local raf handle, initial-render flag, and
+    // fingerprint for static-phase detection.
+    this._animRafId = null;
+    this._isInitial = true;
+    this._lastFingerprint = "";
+    // Tip-position subscribers — fired every animation frame so cross-controller
+    // consumers (e.g. custom markers in CartesianRenderer) can imperatively sync
+    // their DOM positions during tip extension. Replaces the old
+    // `orchestrator.share/notify('line:tipPositions', ...)` pub/sub.
+    this._tipSubscribers = /* @__PURE__ */ new Set();
+    // Layout caches (read by hit test / legend)
+    this.layoutCache = /* @__PURE__ */ new Map();
+    this.renderPropsCache = /* @__PURE__ */ new Map();
+    this.lineDatasets = [];
+    this.storedLayoutData = null;
+    // Last rendered state (for SVG re-render on hover; canvas paint callback reads this)
+    this.lastRenderedLayouts = null;
+    this.activeRenderPropsCache = /* @__PURE__ */ new Map();
+    /**
+     * Per-dataset property-animation overrides. Layered onto scene-derived renderProps
+     * at read time inside updateRenderState. Property animations write to this map;
+     * scene tick never touches it. Cleared in destroy().
+     */
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // Controller-level clocks. Value-channel tweens are owned by `_scene`;
+    // tip extension (geometric last-segment animation) and entrance clip-reveal
+    // remain manual clocks for parity with the prior dual-channel design.
+    this.tipProgress = 1;
+    this.entranceClipProgress = 1;
+    this.tipStartAt = 0;
+    this.tipDuration = 0;
+    // Current state.
+    // Single source of truth for the current hover. Written ONLY by applyHover (never
+    // re-seeded from input.hover), read by applyHoverToProps for every render path. Hover
+    // is event-driven and always arrives via applyHover, so re-seeding from the swappable
+    // input would let a stale input.hover clobber the live hover. Mirrors candlestick/
+    // heatmap/radar/polar.
+    this.hover = { datasetId: null, index: null };
+    this.lastInput = null;
+    this._markerOverlays = [];
+    this._lastTipPositions = null;
+    // applyHoverToProps memo — paintCanvasLayer asks for the full hovered props
+    // map once per dataset per compositor.repaint; without this cache that's
+    // O(D²×P) work per mouse-driven repaint on synced/crosshair pages.
+    // Keys: hover ref + input propsMap ref. The hover ref is replaced wholesale by
+    // applyHover() and the propsMap by update(), so reference identity is a safe key.
+    this._hoverPropsCacheHover = null;
+    this._hoverPropsCachePropsMap = null;
+    this._hoverPropsCacheResult = null;
+    // DOM targets
+    this.svgGroup = null;
+    this.canvasEl = null;
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: lines enter from zeros at the same x positions.
+      // values=[] is intentional — the controller seeds the real "zeros" array
+      // at _buildSceneTargets time (it needs to know category count).
+      emptyState: (target) => ({
+        ...target,
+        geometry: { values: target.geometry.values.map(() => 0), streamingHint: "update" },
+        isExiting: false
+      }),
+      // EXIT: shrink to zeros at current x positions.
+      exitEmptyState: (target) => ({
+        ...target,
+        geometry: { values: target.geometry.values.map(() => 0), streamingHint: "update" },
+        isExiting: true
+      }),
+      registry: LINE_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  update(input) {
+    this.lastInput = input;
+    this.svgGroup = input.svgGroup ?? null;
+    this.canvasEl = input.canvasEl ?? null;
+    this.storedLayoutData = input.layoutData ?? null;
+    const { datasets, datasetVisibility, features, compositor } = input;
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    this.lineDatasets = collectItems(sortedDatasets, datasetVisibility).line;
+    let layoutResult = input.layoutResult ?? this.computeLayout(input);
+    if (!layoutResult && this._scene.getElements().length > 0 && input.categoryScale && input.valueScales && input.valueScales.size > 0) {
+      layoutResult = { layouts: /* @__PURE__ */ new Map(), renderPropsMap: /* @__PURE__ */ new Map(), visibleDatasets: [] };
+    }
+    if (!layoutResult) {
+      this.layoutCache.clear();
+      this.renderPropsCache.clear();
+      this.activeRenderPropsCache.clear();
+      this.lastRenderedLayouts = null;
+      this._cancelRaf();
+      this._scene.reset();
+      this._isInitial = true;
+      this._lastFingerprint = "";
+      this.tipProgress = 1;
+      this.tipDuration = 0;
+      if (input.renderer === "svg" && this.svgGroup) {
+        while (this.svgGroup.firstChild) this.svgGroup.removeChild(this.svgGroup.firstChild);
+      }
+      return;
+    }
+    if (input.renderer === "svg" && !this.svgGroup) return;
+    const { layouts, renderPropsMap, visibleDatasets } = layoutResult;
+    this.layoutCache = layouts;
+    this.renderPropsCache = renderPropsMap;
+    const context = {
+      chartId: input.chartId,
+      width: input.width,
+      height: input.height,
+      renderer: input.renderer,
+      chartArea: input.chartArea,
+      theme: input.theme,
+      accessibility: buildAccessibilityRenderContext(features)
+    };
+    const animConfig = features.get("animation")?.props;
+    const { fingerprint, updateMode, phase, shouldAnimate, duration, easing } = resolveLineAnimationPlan(layouts, animConfig, this._isInitial, this._lastFingerprint, this._scene.getElements().length);
+    const { targets: sceneTargets, anyTip } = buildSceneTargets(this, visibleDatasets, renderPropsMap, input, updateMode);
+    if (input.renderer === "canvas" && compositor) {
+      compositor.removeLayersByPrefix?.("line:");
+      const rangeFirstDs = /* @__PURE__ */ new Set();
+      if (input.rangeGroups) {
+        for (const [, rg] of input.rangeGroups) {
+          if (rg.datasetIds.length >= 2) rangeFirstDs.add(rg.datasetIds[0]);
+        }
+      }
+      const layerIds = /* @__PURE__ */ new Set([...layouts.keys(), ...this._scene.getElements().map((el) => el.current.datasetId)]);
+      registerDatasetLayers(
+        compositor,
+        "line",
+        layerIds,
+        (dsId) => sceneTargets.get(dsId)?.stackOrder ?? this._scene.getElement(dsId)?.current.stackOrder ?? 0,
+        (dsId) => (ctx) => paintCanvasLayer(this, ctx, dsId, rangeFirstDs, context)
+      );
+    }
+    const opts = {
+      numbers: { duration: shouldAnimate ? duration : 0, easing },
+      colors: { duration: shouldAnimate ? duration : 0, easing }
+    };
+    if (phase === "static" && this._animRafId !== null) {
+      this._commit(fingerprint);
+      return;
+    }
+    if (!shouldAnimate) {
+      this._cancelRaf();
+      this.tipProgress = 1;
+      this.tipDuration = 0;
+      this.entranceClipProgress = 1;
+      this._scene.diff(sceneTargets, opts);
+      this._scene.tick(performance.now());
+      this.renderFrameCycle();
+      this._commit(fingerprint);
+      return;
+    }
+    if (phase === "entrance") {
+      this._cancelRaf();
+      this.tipProgress = 1;
+      this.tipDuration = 0;
+      this.entranceClipProgress = 0;
+      this._scene.diff(sceneTargets, { numbers: { duration: 0, easing }, colors: { duration: 0, easing } });
+      this._scene.tick(performance.now());
+      this._startEntranceLoop(duration, easing);
+      this._commit(fingerprint);
+      return;
+    }
+    this._cancelRaf();
+    this._scene.diff(sceneTargets, opts);
+    if (anyTip) {
+      this.tipStartAt = performance.now();
+      this.tipDuration = duration;
+      this.tipProgress = 0;
+    }
+    this._startSceneUpdateLoop(easing);
+    this._commit(fingerprint);
+  }
+  applyHover(hover) {
+    applyHover(this, hover);
+  }
+  applyPropertyAnimations(store) {
+    if (!this.lastRenderedLayouts || this.lastRenderedLayouts.size === 0 || !this.lastInput) return;
+    const input = this.lastInput;
+    let appliedAny = false;
+    let needsSvgFullRender = false;
+    for (const [dsId, props] of this.activeRenderPropsCache) {
+      const overrides = resolveAnimatedProps(store, "line", dsId, LINE_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(dsId)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(dsId, overrides);
+      this.activeRenderPropsCache.set(dsId, { ...props, ...overrides });
+      if (input.renderer === "svg" && this.svgGroup) {
+        const group = this.svgGroup.querySelector(`[data-dataset="${dsId}"]`);
+        if (!group) continue;
+        if (Object.keys(overrides).some((k) => k !== "lineStrokeWidth" && k !== "lineDashOffset" && k !== "fillOpacity" && k !== "tension")) {
+          needsSvgFullRender = true;
+          continue;
+        }
+        if ("lineStrokeWidth" in overrides) {
+          group.querySelectorAll(".line-strokes path").forEach((el) => {
+            el.setAttribute("stroke-width", String(overrides.lineStrokeWidth));
+          });
+        }
+        if ("lineDashOffset" in overrides) {
+          group.querySelectorAll(".line-strokes path").forEach((el) => {
+            el.setAttribute("stroke-dashoffset", String(overrides.lineDashOffset));
+          });
+        }
+        if ("fillOpacity" in overrides) {
+          group.querySelectorAll(".line-area path").forEach((el) => {
+            el.setAttribute("fill-opacity", String(overrides.fillOpacity));
+          });
+        }
+        if ("tension" in overrides) {
+          const layout = this.lastRenderedLayouts.get(dsId);
+          if (layout) {
+            const { curve, isArea, baselineY } = layout;
+            const newTension = overrides.tension;
+            const linePathEls = Array.from(group.querySelectorAll(".line-strokes path"));
+            const areaPathEls = isArea ? Array.from(group.querySelectorAll(".line-area path")) : [];
+            layout.segments.forEach((seg, i) => {
+              linePathEls[i]?.setAttribute("d", buildLinePath(seg.points, curve, newTension));
+              if (isArea && areaPathEls[i]) {
+                const isStacked = seg.points[0]?.baseY !== void 0;
+                areaPathEls[i].setAttribute("d", isStacked ? buildStackedFillPath(seg.points, curve, newTension) : buildFillPath(seg.points, curve, baselineY, newTension));
+              }
+            });
+          }
+        }
+      }
+    }
+    if (!appliedAny) return;
+    if (triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor)) return;
+    if (input.renderer !== "svg" || needsSvgFullRender) {
+      this.renderFrameCycle();
+    }
+  }
+  hitTest(x, y) {
+    return lineHitTest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, layoutData: this.storedLayoutData, hitTest: hitTestLine, theme: this.lastInput?.theme });
+  }
+  findAllNearest(x, y) {
+    return lineFindAllNearest(x, y, { layouts: this.layoutCache, renderPropsCache: this.renderPropsCache, layoutData: this.storedLayoutData, hitTest: hitTestLine, theme: this.lastInput?.theme });
+  }
+  getSvgOutput() {
+    return null;
+  }
+  get hasData() {
+    return this.lineDatasets.length > 0;
+  }
+  get layouts() {
+    return this.layoutCache;
+  }
+  get renderProps() {
+    return this.renderPropsCache;
+  }
+  get markerOverlays() {
+    return this._markerOverlays;
+  }
+  /**
+   * Sync line point positions with a chrome-animated category/value scale.
+   *
+   * Called from the chrome animation loop each frame (canvas: from inside
+   * `compositor.repaint`'s `bgPainter`; SVG: directly). We only update the
+   * cached input scales — the next line animation frame (or a direct
+   * re-render when no line animation is active) picks them up through
+   * `_renderSceneFrame`.
+   *
+   * IMPORTANT: this method must never call `triggerCompositorRepaint` — it
+   * can be invoked from inside an in-flight compositor.repaint, and nesting
+   * would recurse. On canvas, we only refresh `lastRenderedLayouts` so the
+   * outer repaint's data-layer callbacks read the fresh layout.
+   */
+  syncWithAnimatedScale(categoryScale, valueScales) {
+    if (!this.lastInput) return;
+    this.lastInput.categoryScale = categoryScale;
+    if (valueScales) this.lastInput.valueScales = valueScales;
+    if (this._animRafId !== null || this.tipProgress < 1 || this.entranceClipProgress < 1) {
+      return;
+    }
+    updateRenderState(this);
+    if (this.lastInput.renderer === "svg" && this.svgGroup) {
+      renderSvgFrame(this);
+    }
+  }
+  /**
+   * Subscribe to per-frame tip-position updates during tip-extension animation.
+   * Returns an unsubscribe function. Callback receives the current map of
+   * `datasetId → { x, y }` for the animated last segment endpoint, or `null`
+   * when no tip animation is in flight.
+   *
+   * Used by external consumers (e.g. CartesianRenderer's custom-marker sync)
+   * that need to imperatively update DOM positions during the line tip animation.
+   */
+  subscribeTipPositions(cb) {
+    this._tipSubscribers.add(cb);
+    return () => {
+      this._tipSubscribers.delete(cb);
+    };
+  }
+  destroy() {
+    this._cancelRaf();
+    this._scene.reset();
+    this._isInitial = true;
+    this._lastFingerprint = "";
+    this._tipSubscribers.clear();
+    this.tipProgress = 1;
+    this.tipDuration = 0;
+    this.entranceClipProgress = 1;
+    this._lastTipPositions = null;
+    this.lastRenderedLayouts = null;
+    this.activeRenderPropsCache.clear();
+    this._propertyOverrides.clear();
+    this.layoutCache.clear();
+    this.renderPropsCache.clear();
+    this.lineDatasets = [];
+    this.storedLayoutData = null;
+    this.lastInput?.compositor?.removeLayersByPrefix("line:");
+    this._hoverPropsCacheHover = null;
+    this._hoverPropsCachePropsMap = null;
+    this._hoverPropsCacheResult = null;
+  }
+  // ================================================================
+  // PRIVATE HELPERS
+  // ================================================================
+  /** Cancel any in-flight raf. */
+  _cancelRaf() {
+    cancelRafCtx(this);
+  }
+  /** Commit fingerprint for next-frame phase detection and mark initial render complete. */
+  _commit(fingerprint) {
+    commit(this, fingerprint);
+  }
+  /** Entrance clip-reveal raf loop (delegates to `scene.startEntranceLoop`). */
+  _startEntranceLoop(duration, easing) {
+    startEntranceLoop(this, duration, easing);
+  }
+  /** Update/tip raf loop (delegates to `scene.startSceneUpdateLoop`). */
+  _startSceneUpdateLoop(easing) {
+    startSceneUpdateLoop(this, easing);
+  }
+  computeLayout(input) {
+    const { categoryScale, valueScales, chartArea, axisIdProp, firstValueAxisId, lineStackBasesMap, lineTransformedValues, groupedDataOverride, hoverConfig } = input;
+    if (this.lineDatasets.length === 0 || !categoryScale || !valueScales || valueScales.size === 0) return null;
+    const visibleDatasets = this.lineDatasets.filter((d) => d.visible);
+    if (visibleDatasets.length === 0) return null;
+    const layouts = /* @__PURE__ */ new Map();
+    const renderPropsMap = /* @__PURE__ */ new Map();
+    const sharedValueScale = valueScales.values().next().value;
+    let datasetIndex = 0;
+    for (const ld of visibleDatasets) {
+      const targetAxisId = ld.props[axisIdProp] ?? firstValueAxisId;
+      const targetValueScale = valueScales.get(targetAxisId) ?? sharedValueScale;
+      const groupedData = groupedDataOverride?.get(ld.id);
+      const propsForLayout = groupedData ? { ...ld.props, data: groupedData } : ld.props;
+      const baseLayout = calculateLineLayout(propsForLayout, chartArea, {
+        categoryScale,
+        valueScale: targetValueScale,
+        stackBases: lineStackBasesMap?.get(ld.id),
+        transformedValues: lineTransformedValues?.get(ld.id),
+        seriesId: ld.id
+      });
+      layouts.set(ld.id, { ...baseLayout, datasetIndex: datasetIndex++ });
+      const seriesHoverProps = ld.props;
+      renderPropsMap.set(ld.id, {
+        ...ld.props,
+        interaction: { hoveredIndex: null },
+        effects: {
+          hoverBrightness: hoverConfig?.brightness ?? DEFAULT_HOVER_BRIGHTNESS,
+          dimOpacity: hoverConfig?.dimOpacity ?? DEFAULT_HOVER_DIM_OPACITY,
+          hoverRadiusMultiplier: hoverConfig?.radiusMultiplier,
+          hoverBackgroundColor: seriesHoverProps.hoverColor ?? hoverConfig?.backgroundColor,
+          hoverBorderColor: seriesHoverProps.hoverBorderColor ?? hoverConfig?.borderColor,
+          hoverBorderStrokeWidth: hoverConfig?.borderStrokeWidth,
+          hoverPointRadius: seriesHoverProps.hoverPointRadius
+        }
+      });
+    }
+    return { layouts, renderPropsMap, visibleDatasets };
+  }
+  /** Refresh render-state caches from the current scene + progresses. No paint. */
+  updateRenderState() {
+    updateRenderState(this);
+  }
+  /** SVG frame render with inline tip extension (delegates to `paint.renderSvgFrame`). */
+  renderSvgFrame() {
+    renderSvgFrame(this);
+  }
+  /** Full frame: update state then paint (delegates to `scene.renderFrameCycle`). */
+  renderFrameCycle() {
+    renderFrameCycle(this);
+  }
+  /** Canvas compositor layer paint callback (delegates to `paint.paintCanvasLayer`). */
+  paintCanvasLayer(ctx, dsId, rangeFirstDs, context) {
+    paintCanvasLayer(this, ctx, dsId, rangeFirstDs, context);
+  }
+  /** Bake the current hover into render props (delegates to `hover.applyHoverToProps`). */
+  applyHoverToProps(propsMap) {
+    return applyHoverToProps(this, propsMap);
+  }
+};
+
+export { LineRendererController };