> ## Documentation Index
> Fetch the complete documentation index at: https://docs.siftstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Explore reference

> Settings, options, and behaviors for all Explore features.

export const MintTable = ({columns = [], rows = [], columnWidths = []}) => {
  const pushTextWithLineBreaks = (parts, text, keyBase) => {
    const segments = String(text).split(/\\n|\n/);
    segments.forEach((segment, idx) => {
      if (segment) {
        parts.push(<span key={`${keyBase}-text-${idx}`}>{segment}</span>);
      }
      if (idx < segments.length - 1) {
        parts.push(<br key={`${keyBase}-br-${idx}`} />);
      }
    });
  };
  const parseMarkdown = text => {
    if (text === null || text === undefined) return "";
    const str = String(text);
    const parts = [];
    let lastIndex = 0;
    const pattern = /(`[^`]+`|\*\*[^*]+\*\*|\*[^*]+\*|\[([^\]]+)\]\(([^)]+)\))/g;
    let match;
    while (true) {
      match = pattern.exec(str);
      if (match === null) {
        break;
      }
      if (match.index > lastIndex) {
        pushTextWithLineBreaks(parts, str.substring(lastIndex, match.index), `before-${lastIndex}`);
      }
      const fullMatch = match[0];
      if (fullMatch.startsWith("`") && fullMatch.endsWith("`")) {
        parts.push(<code key={match.index}>{fullMatch.slice(1, -1)}</code>);
      } else if (fullMatch.startsWith("**") && fullMatch.endsWith("**")) {
        parts.push(<strong key={match.index}>{fullMatch.slice(2, -2)}</strong>);
      } else if (fullMatch.startsWith("*") && fullMatch.endsWith("*")) {
        parts.push(<em key={match.index}>{fullMatch.slice(1, -1)}</em>);
      } else if (fullMatch.startsWith("[")) {
        const linkText = match[2];
        const linkUrl = match[3];
        parts.push(<a key={match.index} href={linkUrl} className="text-black-600 dark:text-black-400">
            {linkText}
          </a>);
      }
      lastIndex = pattern.lastIndex;
    }
    if (lastIndex < str.length) {
      pushTextWithLineBreaks(parts, str.substring(lastIndex), `tail-${lastIndex}`);
    }
    if (parts.length > 0) {
      return parts;
    }
    const plainParts = [];
    pushTextWithLineBreaks(plainParts, str, "plain");
    return plainParts.length ? plainParts : str;
  };
  const safeColumns = Array.isArray(columns) ? columns : [];
  const safeRows = Array.isArray(rows) ? rows : [];
  const safeColumnWidths = Array.isArray(columnWidths) ? columnWidths : [];
  const hasColumnWidths = safeColumnWidths.some(w => w !== null && w !== undefined && w !== "");
  const toCssWidth = width => typeof width === "number" ? `${width}px` : String(width);
  const getColumnStyle = idx => {
    const rawWidth = safeColumnWidths[idx];
    if (rawWidth === null || rawWidth === undefined || rawWidth === "") {
      return undefined;
    }
    const width = toCssWidth(rawWidth);
    return {
      width,
      minWidth: width
    };
  };
  const containerStyle = hasColumnWidths ? undefined : {
    overflowX: "auto"
  };
  const tableStyle = hasColumnWidths ? {
    tableLayout: "fixed",
    width: "100%"
  } : {
    width: "max-content",
    minWidth: "100%"
  };
  if (!Array.isArray(columns) || !Array.isArray(rows) || !Array.isArray(columnWidths)) {
    console.warn("MintTable received invalid props:", {
      columns,
      rows,
      columnWidths
    });
  }
  if (!safeColumns.length && !safeRows.length) {
    return null;
  }
  return <div className="mint-table-container" style={containerStyle}>
      <table style={tableStyle}>
        {hasColumnWidths && <colgroup>
            {safeColumns.map((_, idx) => {
    const style = getColumnStyle(idx);
    return <col key={idx} style={style} />;
  })}
          </colgroup>}
        <thead>
          <tr>
            {safeColumns.map((col, idx) => <th key={idx} className="text-left" style={getColumnStyle(idx)}>
                <b>{parseMarkdown(col)}</b>
              </th>)}
          </tr>
        </thead>
        <tbody>
          {safeRows.map((row, rIdx) => {
    const safeRow = Array.isArray(row) ? row : [];
    return <tr key={rIdx}>
                {safeRow.map((cell, cIdx) => <td key={cIdx} style={getColumnStyle(cIdx)}>
                    {parseMarkdown(cell)}
                  </td>)}
              </tr>;
  })}
        </tbody>
      </table>
    </div>;
};

Explore is Sift's workspace for visualizing and investigating high-rate timeseries telemetry. Engineers use it to load data from Assets and Runs, arrange Panels, perform calculations, and share findings without exporting data or switching tools.

## Data sources

A data source defines the telemetry context for an Explore session. It determines which Channels are available for analysis.

<MintTable
  columns={['Data source', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['Asset', 'A physical or logical system (for example, a vehicle or test article). Selecting an Asset makes all Runs associated with it available.'],
['Run', 'A discrete test or data collection session. One or more Runs can be selected to compare telemetry across sessions.'],
]}
/>

### Replace data source

A data source can be replaced mid-session without rebuilding the Panel layout.

<MintTable
  columns={['Behavior', 'Detail']}
  columnWidths={['30%', '70%']}
  rows={[
['Compatibility check', 'The replacement data source must contain compatible Channels. Missing or incompatible Channels are flagged during preview.'],
['Cross-type replacement', 'Replacing between Runs and Assets is supported.'],
['Preview step', 'Changes are shown before confirming replacement.'],
]}
/>

## Save Explore configurations

You can save Explore configurations as a snapshot of a complete Explore session. Use saved Explore configurations to:

* [Standardize analysis across Runs](/documentation/analyze/standardize-analysis-across-runs): save a configuration once and reuse it across different Runs so every engineer analyzes data the same way.
* Build reusable templates for your team: saved Explore configurations work as starting points for onboarding, pre-session setup, and operation-specific analysis.

### Save a new Explore configuration

1. Open **Explore** and set up your workspace: add panels, plot channels, pick your runs, assets, or families, and configure compare and time range.
2. Click **Save**.
3. In **Save your exploration**, enter:
   * **Name** (required, up to 128 characters)
   * **Description** (optional)
   * **Visibility**: **Private** (only you can see it) or **Public** (everyone in your org can view and edit it).
4. Click **Save**.

When you make changes to a saved Explore configuration, a small blue dot appears on the **Save** button, reminding you to save your changes.

<Info>
  Live mode is always turned off in the saved snapshot. Loading a saved Explore configuration drops you into static-view mode regardless of how you saved it.
</Info>

### Update an existing Explore configuration

When an Explore configuration is already loaded:

* **Quick overwrite**: click **Save**, in **Overwrite existing exploration?**, click **Save**.
* **Rename, change description, or change visibility**: click the **Save** dropdown, then **Edit Saved Exploration**, make your changes, and click **Save**.
* **Save a copy**: click the **Save as New** dropdown. The name prefills as *Copy of \{original}*, visibility resets to Private, and a new record is created.

Only the original creator can change visibility on an existing Explore configuration. Public Explore configurations let any org member update the workspace data.

### Open a saved Explore configuration

From the **Save** dropdown, select **Open Saved Exploration**. Search, filter by Runs, Assets, or Families, or toggle **My Explorations** to narrow the list, then click a row.

### What gets saved

A saved Explore configuration captures everything in the Explore URL:

* Panels and their settings (plotted channels, axes, colors, etc.)
* Dockview layout (panel positions, tabs, splits)
* Selected runs, assets, and families
* Compare settings and alignments
* Sidebar state and time range
* Draft (unpublished) calculated channels

## Share

The sharing feature in Explore captures the current workspace state and generates a shareable URL. Recipients open the workspace in the exact state it was shared, with no manual reconfiguration required.

## Export data

Export data is available in the Timeseries Panel toolbar. Selecting <Icon icon="arrow-down-to-bracket" /> **Export data** opens a dropdown with the following options.

<MintTable
  columns={['Option', 'Description']}
  columnWidths={['35%', '65%']}
  rows={[
['Export as CSV', 'Exports the plotted Channels to a `.csv` file.'],
['Export as Parquet', 'Exports the plotted Channels to a `.parquet` file.'],
['Export as WinPlot', 'Exports the plotted Channels to a `.sun` file for use in WinPlot.'],
['Advanced Export', 'Opens the **Export Data** dialog with additional options for [Channel name display](/documentation/reference/supported-file-formats#channel-name-display), [file splitting](/documentation/reference/supported-file-formats#file-splitting), and [Channel data grouping](/documentation/reference/supported-file-formats#channel-data-grouping).'],
['Use previous advanced export settings', 'Exports using the settings from the last Advanced Export without opening the dialog.'],
]}
/>

<Info>
  **Export restrictions**: Nested Calculated Channels cannot be exported and are excluded from the output. Relative Time mode is not supported for export.
</Info>

## User settings

User settings let you define personal default display preferences for Explore across two areas: general settings that apply to all Panels, and default settings per Panel type. Defaults apply to your account only. Individual Panel settings can still be overridden at any time.

User settings are stored in the browser and do not carry over to other computers. Clearing the browser cache resets all User settings to their defaults.

User settings are accessed from the Explore toolbar by clicking <Icon icon="sliders" /> **User Settings**.

### General settings

The following settings are available under **User Settings** and apply globally across all new Panels in Explore.

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['35%', '65%']}
  rows={[
['Default Timezone', 'Timezone applied to all new Panels.'],
['Live Data Refresh Settings', 'How frequently Panels refresh in Live mode.'],
['Live Data Scroll Behavior', 'How Panels update as new data arrives in Live mode.'],
['Disable Annotations', 'Shows or hides Annotations across all Timeseries Panels in Explore.'],
['Channel Name Delimiter', 'The character that splits a Channel name into hierarchy levels in the [Channel tree](#channel-tab-views).'],
['Channel Name Prefix Delimiter', 'The character that splits a path-style prefix from the rest of the Channel name in the [Channel tree](#channel-tab-views).'],
['Channel Leaf Keywords', 'Trailing words stripped from a Channel name so they do not appear as extra leaf nodes in the [Channel tree](#channel-tab-views).'],
]}
/>

<Info>
  **Channel tree hierarchy:** The following three settings work together to control how Channel names display in the [Channel tree](#channel-tab-views):

  * **Channel Name Delimiter**,
  * **Channel Name Prefix Delimiter**, and
  * **Channel Leaf Keywords**.

  See [Channel name structure](/documentation/reference/naming-rules#channel-name-structure) for details.
</Info>

#### Set the display timezone

1. In the Explore toolbar, click <Icon icon="sliders" /> **User Settings**.
2. Under **Default Timezone**, select the timezone you want.

<Info>
  * **All Panels**: This applies to all new Panels for your account. Panels already open in the session are not updated.
  * **Single Panel**: To override the timezone on a single Panel without changing the global default, open <Icon icon="gear" /> **Panel settings**, go to the **General** tab, and set **UTC offset**.
</Info>

### Chart type settings

Default settings can be configured per Panel type. Select a Panel type from the **Chart Type Settings** dropdown to configure its defaults. Settings vary by Panel type and correspond to the individual Panel settings for each type. All Panel types are supported.

#### WebGL traces

Enables GPU-accelerated WebGL rendering for Timeseries Panels instead of the default ECharts renderer. Reduces slowdowns when displaying many or high-frequency Channels. (Beta)

## Live mode

Live mode monitors real-time telemetry as it streams into Sift. All Panel types support Live mode. Live mode is compatible with [Panel Sync](#sync-panels): when both are active, all synced Panels advance together as new data arrives.

<MintTable
  columns={['Setting', 'Options', 'Default']}
  columnWidths={['33%', '34%', '33%']}
  rows={[
['Refresh interval', 'Configurable', 'Every 1 second'],
['Scroll behavior', 'Smooth Scroll, Jump', 'Smooth Scroll'],
]}
/>

## Panels

Panels are the individual visualization units in an Explore workspace. Each Panel is independently configurable. Changing settings on one Panel does not affect other Panels.

### Panel types

<MintTable
  columns={['Panel type', 'Use']}
  columnWidths={['25%', '75%']}
  rows={[
['Timeseries', 'Spot trends, anomalies, and temporal patterns.'],
['Histogram', 'Quickly identify frequency, spread, and outliers.'],
['Geo Map', 'Analyze location, movement, and spatial relationships in geographic context.'],
['Table', 'Inspect raw telemetry values, timestamps, and logs in a precise, structured format.'],
['FFT (Fast Fourier Transform)', 'Identify dominant frequencies, vibrations, and noise characteristics in the frequency domain.'],
['Scatter Plot', 'Reveal correlations between signals to uncover relationships and dependencies.'],
['Metrics', 'Quantify signal behavior over a selected time range with instant statistics like min, max, and mean.'],
['File Viewer', 'Correlate images, video, and audio with telemetry to investigate critical moments in real-world context.'],
['Stat', 'Display the most recent value for each channel as a tile. Supports numeric, boolean, enum, and bit field channels.'],
['Enum', 'Display enum and boolean channels as a color-coded timeline. Each channel occupies its own row; each value period is drawn as a colored band.'],
]}
/>

### Layout

Panels can be added, split, and repositioned freely within the workspace.

**Add a Panel**

Panels can be added at any time using the **Add** button in the workspace toolbar.

**Split a Panel**

Split options appear when right-clicking a Panel tab. A split duplicates the Panel in the selected direction. The new Panel is independent and can be configured separately.

<MintTable
  columns={['Split type', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Split up', 'Duplicates the Panel directly above the current one.'],
['Split down', 'Duplicates the Panel directly below the current one.'],
['Split left', 'Duplicates the Panel to the left of the current one.'],
['Split right', 'Duplicates the Panel to the right of the current one.'],
]}
/>

**Reposition a Panel**

Panels can be moved to the top, bottom, left, or right of the workspace.

### Sync Panels

Syncing aligns the time range across multiple Panels. Adjusting the time window in one Panel updates all synced Panels.

Panel Sync is compatible with Live mode. When both are active, all synced Panels advance together as new data streams in.

<MintTable
  columns={['Sync mode', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Absolute', 'Define a specific start and end date and time.'],
['Relative', 'Define a time range relative to T-0.'],
]}
/>

### Range controls

Range controls are available in the Timeseries, FFT, and Scatter Plot Panels.

<MintTable
  columns={['Control', 'Panel', 'Description']}
  columnWidths={['20%', '25%', '55%']}
  rows={[
['Zoom XY', 'Timeseries, FFT, Scatter Plot', 'Zoom in on both the X and Y axes simultaneously.'],
['Zoom X', 'Timeseries, FFT, Scatter Plot', 'Zoom in on the X axis only.'],
['Pan', 'Timeseries, FFT, Scatter Plot', 'Pan across the data without changing the zoom level.'],
['Select X', 'Timeseries', 'Select a specific range on the X axis for further actions, such as creating an Annotation, a new Run, or a Metrics Panel.'],
]}
/>

### Panel settings

Each Panel type has its own settings organized into tabs. Settings are independent per Panel.

#### Timeseries: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format for the data (for example, Timeseries).'],
['Panel name', 'Display name shown in the Panel header.'],
['UTC offset', 'Timezone offset for the time axis.'],
['Time range', 'Temporal window for the displayed telemetry.'],
['Channel label', 'Naming convention for signals (for example, Full name, Short name).'],
['Overflow truncation', 'How long names are shortened when they exceed available space.'],
['Show run name', 'Toggles the Run identifier in the signal label.'],
['Show asset name', 'Toggles the hardware name in the signal label.'],
['Show points', 'Toggles visible dots for individual data points on the signal line.'],
['Line style', 'Appearance of plotted lines (for example, Solid, Dashed).'],
['Line connection style', 'How segments between points are drawn (for example, Line, Step).'],
['Line weight', 'Thickness of signal lines.'],
['Show tooltip', 'Enables or disables the data readout when hovering over the plot.'],
['Tooltip location', 'Where the tooltip appears relative to the cursor.'],
['Decimal places', 'Numerical precision shown in the tooltip (for example, Raw data).'],
['Tooltip background opacity', 'Transparency of the tooltip box.'],
['Split by Y-axis', 'Separates signals into individual vertical axes for easier comparison of different scales.'],
]}
/>

#### Timeseries: Time-alignment tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Alignment', 'Method used to align data. Default is Absolute/UTC. Relative alignment points can be created or selected to compare data relative to specific events.'],
]}
/>

#### Timeseries: Channel tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Group by', 'Applies properties in bulk to all Channels sharing an attribute. [Learn about Group by options](#options-group-by).'],
['Y-axis', 'Assigns the selected signals to a specific vertical axis (for example, L1, L2).'],
['Axis label', 'Label for the Y-axis. Appears in the legend as a prefix on each entry (for example, **L1: Pressure**) after you right-click the legend and select **Legend Group By** > **Y-Axis**.'],
['Channel color', 'Color of the signal line.'],
['Opacity', 'Transparency of the signal line.'],
['Channel label', 'Inherits the global naming convention or sets a specific override.'],
['Overflow truncation', 'Inherits the global truncation style or sets a specific override.'],
['Show Run name', 'Determines if the Run name is visible for this specific group.'],
['Show Asset name', 'Determines if the hardware name is visible for this specific group.'],
['Show channel', 'Toggles the visibility of the signal group within the Panel.'],
['Decimal places', 'Overrides the global precision settings for the selected signals.'],
['Show points', 'Enables or disables visible data points for this specific group.'],
['Line style', 'Sets a unique line style for the selected signals.'],
['Line connection style', 'Sets how lines are drawn between points for the group.'],
['Line weight', 'Sets a specific thickness for these signal lines.'],
['Sampling method', 'Controls how data points are reduced when a Channel contains more data than can be displayed. [Learn about Sampling method options](#options-sampling-method).'],
]}
/>

#### Options: Group by

<MintTable
  columns={['Option', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Individual', 'Apply settings to one specific signal at a time.'],
['Channel unit', 'Group signals sharing the same measurement unit.'],
['Data type', 'Group by the underlying data format.'],
['Run', 'Group by specific test or operational runs.'],
['Asset', 'Group by specific hardware systems.'],
['Axis', 'Group by assigned Y-axis.'],
['Channel name', 'Group by the specific name of the signal.'],
['All channels', 'Apply changes globally to every signal in the Panel.'],
]}
/>

#### Options: Sampling method

<MintTable
  columns={['Option', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Min/Max', 'Default option. Returns the minimum and maximum values within each interval. Preserves true peaks and valleys. Best for anomaly detection and monitoring extremes.'],
['LTTB', 'Selects representative points to preserve the overall shape of the signal. Best for general visualization of numeric Channels.'],
['Changed Only', 'Returns only points where the value changes. Best for enum and boolean Channels where state transitions must be preserved.'],
]}
/>

#### Histogram: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format for the data (for example, Histogram).'],
['Panel name', 'Display name shown in the Panel header.'],
['UTC offset', 'Timezone offset for the time axis.'],
['Time range', 'Temporal window for the displayed telemetry.'],
['Channel label', 'Naming convention for signals.'],
['Overflow truncation', 'How long names are shortened when they exceed available space.'],
['Show family name', 'Toggles the Family identifier in the signal label.'],
['Show run name', 'Toggles the Run identifier in the signal label.'],
['Show asset name', 'Toggles the hardware name in the signal label.'],
['Binning method', 'Algorithm used to calculate the number and width of bins in the histogram.'],
]}
/>

#### Histogram: Time-alignment tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Alignment', 'Method used to align data. Default is Absolute/UTC. Relative alignment points can be created or selected to compare data relative to specific events.'],
]}
/>

#### Geo Map: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format and allows conversion to a different Panel type (for example, Timeseries or Histogram).'],
['Panel name', 'Display name shown in the Panel header.'],
['UTC offset', 'Timezone offset for the time axis displayed on the map.'],
['Time range', 'Temporal window for the displayed telemetry.'],
['Map style', 'Base map layer (for example, satellite or street view).'],
['Coordinate set', 'A group of Channels (Latitude and Longitude) used to render a path or position on the map.'],
['Latitude', 'Channel providing latitude data for a coordinate set.'],
['Longitude', 'Channel providing longitude data for a coordinate set.'],
['Color', 'Channel that drives the color of the rendered path or points.'],
['Gradient', 'Appears when a Channel is selected for Color. Determines the color scale (for example, Viridis) applied to the data values.'],
['Point size', 'Channel that drives the diameter of rendered points and the visual thickness of the path drawn on the map.'],
['Tooltip', 'Channels displayed in the data readout when hovering over map points.'],
['Channel label', 'Naming convention for signals (for example, Full name, Short name).'],
['Overflow truncation', 'How long names are shortened when they exceed available space.'],
['Show Run name', 'Toggles the Run identifier in the signal labels.'],
['Show Asset name', 'Toggles the hardware name in the signal labels.'],
]}
/>

#### Geo Map: Time-alignment tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Alignment', 'Method used to align data. Default is Absolute/UTC. Relative alignment points can be created or selected to compare data relative to specific events.'],
]}
/>

#### Table: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format and allows conversion to a different Panel type (for example, Timeseries or Histogram).'],
['Panel name', 'Display label for the Panel header.'],
['UTC offset', 'Timezone offset for the timestamp column.'],
['Time range', 'Temporal window for the raw data points displayed.'],
['Channel label', 'Naming convention for column headers (for example, Full name).'],
['Show family name', 'Toggles the Family identifier in column headers.'],
['Show Run name', 'Toggles the Run identifier in column headers.'],
['Show Asset name', 'Toggles the hardware name in column headers.'],
['Show carried values', 'When enabled, displays the last known value for a Channel if no new data exists for a given timestamp.'],
['Track focused time', 'Automatically scrolls or highlights table rows based on the global cursor position.'],
['Freeze timestamp column', 'Pins the timestamp column to the left of the table for consistent reference while scrolling horizontally.'],
['Mode', 'Toggles between Split (separate columns for each signal) and Merge (combined rows for better density).'],
]}
/>

#### Table: Channels tab

**Filter**

Filters isolate data points that meet specific numerical criteria per Channel before rows are created.

<MintTable
  columns={['Operator', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['>', 'Greater than.'],
['<', 'Less than.'],
['≥', 'Greater than or equal to.'],
['≤', 'Less than or equal to.'],
['=', 'Equal to.'],
]}
/>

**Row creation trigger**

Determines when a specific Channel contributes to generating a new row. Configured per Channel.

<MintTable
  columns={['Trigger', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['Change', 'A new row is created only when the value in this column changes.'],
['Reference', 'This column does not generate its own rows. Instead, it fills values into rows created by other non-reference columns at the same timestamps.'],
['Sample', 'A new row is created for every incoming sampled data point in this column.'],
]}
/>

#### FFT: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format for the data (set to FFT).'],
['Panel name', 'Display name shown in the Panel header.'],
['UTC offset', 'Timezone offset for the time reference.'],
['Time range', 'Temporal window of data used to generate the frequency transform.'],
['Channel label', 'Naming convention for signals (for example, Full name or Short name).'],
['Overflow truncation', 'How long names are shortened when they exceed available space.'],
['Show family name', 'Toggles the Family identifier in the signal label.'],
['Show run name', 'Toggles the Run identifier in the signal label.'],
['Show asset name', 'Toggles the hardware name in the signal label.'],
['X-axis scale', 'Frequency axis scale: Linear or Logarithmic.'],
['Y-axis scale', 'Magnitude axis scale: Linear or Logarithmic.'],
['Show points', 'Toggles visible dots on the plot lines.'],
['Line style', 'Appearance of the plotted lines (for example, Solid or Dashed).'],
['Line connection style', 'How segments between frequency points are drawn (for example, Line or Step).'],
['Line weight', 'Thickness of signal lines.'],
['Family Channels', 'How related Channels are displayed in the legend: Expanded or Collapsed.'],
['Show tooltip', 'Enables or disables the data readout when hovering over the frequency plot.'],
['Tooltip location', 'Where the tooltip appears relative to the cursor.'],
['Decimal places', 'Numerical precision shown in the tooltip.'],
['Tooltip background opacity', 'Transparency of the tooltip box background.'],
]}
/>

#### FFT: Time-alignment tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Alignment', 'Method used to align data. Default is Absolute/UTC. Relative alignment points can be created or selected to compare data relative to specific events.'],
]}
/>

#### FFT: Channel tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Group by', 'Applies properties in bulk to all Channels sharing an attribute. See Group by options below.'],
['Channel color', 'Color of the frequency signal line.'],
['Opacity', 'Transparency of the signal line.'],
['Channel label', 'Global naming convention or a specific override.'],
['Overflow truncation', 'Global truncation style or a specific override.'],
['Show family name', 'Toggles the Family identifier for this specific group.'],
['Show run name', 'Toggles the Run name for this specific group.'],
['Show asset name', 'Toggles the hardware name for this specific group.'],
['Show channel', 'Toggles the visibility of the signal within the Panel.'],
['Decimal places', 'Overrides the global numerical precision for the selected signals.'],
['Show points', 'Enables or disables visible data points for this specific group.'],
['Line style', 'Line style for the selected signals (for example, Solid, Dashed).'],
['Line connection style', 'How lines are drawn between discrete frequency points.'],
['Line weight', 'Thickness for the selected signal lines.'],
]}
/>

**Group by options**

<MintTable
  columns={['Option', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Individual', 'Apply configurations to one specific signal at a time.'],
['Channel unit', 'Group signals sharing the same measurement unit.'],
['Data type', 'Group signals by their underlying data format.'],
['Family', 'Group signals by their defined functional family (for example, EPS, Payload).'],
['Run', 'Group signals by specific test or operational runs.'],
['Asset', 'Group signals by specific hardware systems.'],
['Channel name', 'Group by the specific name of the signal.'],
['All channels', 'Apply changes globally to every signal in the Panel.'],
]}
/>

#### Scatter Plot: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Panel type', 'Visualization format (set to Scatter Plot).'],
['Panel name', 'Display name shown in the Panel header.'],
['Trace group', 'A specific correlation set. Multiple groups can be overlaid on the same coordinate system.'],
['X-axis', 'Channel used for the horizontal coordinate.'],
['Y-axis', 'Channel used for the vertical coordinate.'],
['Color', 'Channel that drives the color of points. When a Channel is selected, a Gradient option appears to define the color scale.'],
['Point size', 'Channel that drives the size of points. When a Channel is selected, Min size and Max size fields appear to define the scaling range.'],
['Split by trace group', 'Separates trace groups into individual sub-plots or overlays them on a single coordinate system.'],
]}
/>

<Note>
  * Both an X-axis and a Y-axis Channel must be selected for the Scatter Plot to render data. Selecting only one Channel results in a "No data available" message.
  * Axis labels for the X-axis and Y-axis Channels currently appear in the legend only when **Legend Group By** is active. They are not yet rendered directly on the chart axes.
  * Scatter Plot and Geo Map panels can be slow when the selected time range contains many data points, because neither panel type applies multi-channel downsampling. Use a Timeseries panel with [Panel Sync](#sync-panels) enabled to narrow the time range before working with the Scatter Plot or Geo Map.
</Note>

#### Scatter Plot: Time-alignment tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Alignment', 'Method used to align data. Default is Absolute/UTC. Can be adjusted to relative alignment points to compare correlations across different events.'],
]}
/>

<Note>
  Scatter Plot and Geo Map panels can slow down or become unresponsive when plotting large numbers of points across a wide time range. To improve performance, zoom into a narrower time range directly in the panel, or use a Timeseries panel with Panel Sync enabled to control the Scatter Plot time range via pan and zoom.
</Note>

#### Metrics: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format and allows conversion to a different Panel type (for example, Timeseries or Histogram).'],
['Panel name', 'Display name shown in the Panel header (for example, "Metrics 1").'],
['Total values', 'Total count of data points recorded within the selected time range.'],
['Start value', 'Signal value at the beginning of the selected range.'],
['End value', 'Signal value at the end of the selected range.'],
['Change in value', 'Numerical difference between the start and end values.'],
['Min', 'Lowest value recorded in the range.'],
['Max', 'Highest value recorded in the range.'],
['Mean', 'Mathematical average of all data points in the range.'],
['Median', 'Middle value in the dataset.'],
['Start time', 'Timestamp of the first data point in the range.'],
['End time', 'Timestamp of the last data point in the range.'],
['Duration', 'Total time elapsed between the start and end points.'],
['Standard deviation', 'Amount of variation or dispersion within the dataset.'],
['Percent change', 'Relative change between the start and end values as a percentage.'],
['Slope', 'Rate of change for the signal over the duration.'],
['Max decimal places', 'Numerical precision for calculated values. Range: Raw data, 0–9.'],
['Time unit', 'Unit for duration and timestamp fields: Auto, ms, s, m, or h.'],
]}
/>

#### File Viewer: General tab

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel name', 'Display name shown in the Panel header.'],
['Show media timeline', 'Toggles the playback progress bar at the bottom of the media player.'],
['Start', 'Absolute timestamp corresponding to the beginning of the file. Defined based on the start time alignment and the duration of the file.'],
]}
/>

#### Stat: General tab

<Info>The Stat panel is in open beta.</Info>

The Stat panel displays the most recent value for each channel as a tile. In Live mode, tiles update on the 1-second tick. When you hover over a synced Timeseries panel, each tile shows the value at the hovered position. When time is focused, tiles show the value at the focused position. When not in Live mode and no time is focused, tiles do not display a value.

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format for the data (for example, Stat).'],
['Panel name', 'Display name shown in the Panel header (for example, "Stat 1").'],
['Layout', 'Arrangement of tiles. Auto sizes tiles to fill the available space. Manual lets you set orientation explicitly.'],
['Orientation', 'Direction tiles are arranged: horizontal or vertical.'],
['Compact mode', 'Reduces tile size to fit a larger number of channels in a table-like layout.'],
['Group by namespace', 'Groups tiles by channel namespace.'],
['Decimal places', 'Number of decimal places shown in each tile value.'],
['Color formatting', 'Toggles color coding for boolean channels.'],
]}
/>

**Limitations**

* The Stat panel looks back a maximum of 5 minutes to find the most recent value for each channel.
* Numeric thresholds are not supported. Threshold configuration is planned for a future release.

#### Enum: General tab

<Info>The Enum Panel is in open beta.</Info>

The Enum Panel renders enum and boolean channels as a color-coded timeline. Each channel occupies its own row. Each period the channel holds a value is drawn as a colored band. When multiple states fall within a single pixel of width, the Panel renders a striped gray **Multiple Values** band instead of picking one state; zoom in to resolve the individual values.

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Panel type', 'Visualization format for the data (for example, Enum).'],
['Panel name', 'Display name shown in the Panel header (for example, "Enum 1").'],
['Time Range', 'Temporal window for the displayed telemetry.'],
['Enum preset', 'Color palette applied to enum channels: Balanced, Muted, High contrast, Viridis, or Rainbow.'],
['Boolean preset', 'Color mapping applied to boolean channels: Red: false / Green: true; Green: false / Red: true; Purple: false / Yellow: true; Yellow: false / Purple: true; White: false / Black: true; or Black: false / White: true.'],
['Channel Label', 'Naming convention for channel labels in the panel: Full name, Unique ends, or Last segment.'],
['Show Family Name', 'Toggles the family name in the channel label.'],
['Show Run Name', 'Toggles the Run identifier in the channel label.'],
['Show Asset Name', 'Toggles the asset name in the channel label.'],
]}
/>

#### Enum: Channel tab

The Channel tab shows each channel added to the panel and allows color preset overrides per channel or per group. Overrides inherit from the panel-level preset by default; selecting a specific preset on a channel replaces the inherited value for that channel only.

<MintTable
  columns={['Setting', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['Group By', 'Groups channels for bulk color preset application: Individual, Data type, Family, Run, Asset, Name, or All.'],
['Enum preset (per channel)', 'Overrides the panel-level enum preset for this channel. Defaults to Inherit.'],
['Boolean preset (per channel)', 'Overrides the panel-level boolean preset for this boolean channel. Defaults to Inherit.'],
]}
/>

**Limitations**

* Enum and boolean channels only. Numeric, string, bytes, and bit field channels are not supported and are filtered out automatically.
* Preset-based coloring only. There is no per-state manual color picker.
* CSV export is not supported.

### Panel Configurations

Panel Configurations save and reuse a Panel's visualization setup. Configurations can be applied to any Run or Asset.

<MintTable
  columns={['Operation', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['Create', 'Save a Panel\'s current setup as a named configuration.'],
['Apply', 'Load a saved configuration into a Panel.'],
['Overwrite', 'Update an existing configuration with the current Panel setup.'],
['Archive', 'Remove a configuration from active use without deleting it.'],
['Filter', 'Narrow the list of configurations shown in the Panel Configurations tab.'],
]}
/>

**Compatibility with Explore (legacy)**

Views from Explore (legacy) are automatically available as Panel Configurations in Explore. New Views created in Explore (legacy) continue to generate corresponding Panel Configurations.

### Panel export

Export is available for Timeseries Panels only. Exports run in the background.

<MintTable
  columns={['Format', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['CSV', 'Comma-separated values.'],
['Parquet', 'Columnar storage format.'],
['WinPlot (Sun)', 'Compatible with WinPlot analysis tools.'],
]}
/>

**Limitations**

* Nested Calculated Channels cannot be exported and are excluded.
* Relative Time mode is not supported for export.

## Channels

Channels are the individual telemetry signals available for plotting. They are listed in the Channels tab, organized in a Channel tree by default.

### Channel tab views

<MintTable
  columns={['View', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Channel tree', 'Default. Channels organized hierarchically by Asset or Run structure.'],
['Channel list', 'Flat list of all Channels.'],
]}
/>

### Plotting

Channels can be plotted by clicking or dragging from the Channels tab onto any Panel. A data source (Asset or Run) must be selected before Channels are available.

To select and plot multiple Channels at once, use these keyboard shortcuts in the Channels tab:

* **Shift+click** selects a contiguous range of Channels.
* **Cmd+click** (Mac) or **Ctrl+click** (Windows, Linux) adds or removes individual Channels from the selection.

Drag any selected Channel to plot the entire selection. Right-click any selected Channel to apply a context menu action to all selected Channels.

### Axis assignment

Applies to the Timeseries Panel. Channels can be assigned to up to 8 Y-axes. Channels can be reassigned to a different axis by dragging the Channel entry in the Timeseries legend and selecting a target axis.

<MintTable
  columns={['Axis', 'Position']}
  columnWidths={['50%', '50%']}
  rows={[
['L1 (default)', 'Left'],
['L2, L3, L4', 'Left'],
['R1, R2, R3, R4', 'Right'],
]}
/>

### Legend Group By

Right-click the legend in a Timeseries Panel and select **Legend Group By** to control how the legend groups channel entries.

<MintTable
  columns={['Option', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['None', 'Displays all channels as a flat list with no grouping.'],
['Y-Axis', 'Groups legend entries by Y-axis assignment. When an axis label is set, it appears as a prefix on each entry (for example, **L1: Pressure**).'],
['Data Source', 'Groups legend entries by data source (Run, Asset, or Family). Useful when channels from multiple sources are plotted together.'],
['Unit', 'Groups legend entries by measurement unit (for example, m/s, degC, V). Useful for confirming unit consistency across channels on a shared axis.'],
['Data Type', 'Groups legend entries by data type (for example, float, integer, boolean). Useful for isolating state or flag channels from continuous signals.'],
['Alignment Point Number', 'Groups legend entries by the alignment point (T-0 reference) applied to their Run. Useful when multiple Runs are aligned to different events.'],
]}
/>

### Bulk axis and style assignment

Simultaneous axis and style configuration for all Channels. Available in Timeseries and FFT Panels.

## Calculated Channels

Calculated Channels are derived signals created by applying CEL expressions to raw Channel data. They appear in the Calculated Channels tab.

### Types

<MintTable
  columns={['Type', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['Saved', 'Calculated Channels attributed to an Asset. Available across sessions.'],
['Temporary', 'Created within an investigation. Exists for the current session only unless saved to an Asset.'],
]}
/>

### Temporary Calculated Channel fields

The following fields are available when creating a temporary Calculated Channel in Explore.

<MintTable
  columns={['Field', 'Required', 'Description']}
  columnWidths={['25%', '15%', '60%']}
  rows={[
['Asset', 'Yes', 'The Asset the Calculated Channel is attributed to.'],
['Name', 'Yes', 'Display name for the Calculated Channel.'],
['Input Channel', 'Yes', 'The raw Channel(s) used in the expression.'],
['Expression', 'Yes', 'CEL expression that defines the transformation.'],
['Unit', 'No', 'Unit label for the output signal.'],
['Save to Asset', 'No', 'Saves the Calculated Channel to the Asset for future reuse.'],
]}
/>

For full Calculated Channel settings and behaviors, see [Calculated Channels settings](/documentation/reference/calculated-channel-settings).

## Runs

### Time alignment

Time alignment synchronizes multiple Runs to a shared reference point (T-0) for direct comparison. The selected alignment applies to all Runs in the Panel.

<MintTable
  columns={['Alignment method', 'Description']}
  columnWidths={['25%', '75%']}
  rows={[
['Absolute/UTC', 'Default. Data is displayed using absolute timestamps. No T-0 is set.'],
['Run start', 'T-0 is set to the beginning of each Run.'],
['Run end', 'T-0 is set to the end of each Run.'],
['Timestamp', 'T-0 is set to a specific absolute timestamp.'],
['Annotation', 'T-0 is set to when a named event (Annotation) occurs within each Run.'],
]}
/>

**Timeseries Panel shortcuts**

The following shortcuts are available directly from the Timeseries Panel without opening Panel settings.

<MintTable
  columns={['Shortcut', 'Description']}
  columnWidths={['30%', '70%']}
  rows={[
['X-axis toggle', 'Located below the X-axis. Switches the axis between absolute UTC time and relative duration.'],
['Right-click > Set T-0', 'Available in relative time mode. Defines the alignment point for an individual Run directly from the Panel.'],
]}
/>

### Run from selection

A new Run can be created from a specific time window within an existing Run plotted in Explore.

<MintTable
  columns={['Behavior', 'Detail']}
  columnWidths={['30%', '70%']}
  rows={[
['Supported Panel', 'Timeseries only.'],
['Tool required', 'Select X.'],
['Channel scope', 'The new Run includes all Channels ever ingested to the Asset, not only Channels with data in the selected window.'],
['Output', 'The new Run can be added as a data source in the current investigation or navigated to directly.'],
]}
/>

### Metrics Panel from selection

A Metrics Panel can be created from a specific time window selected in an existing Time Series Panel.

<MintTable
  columns={['Behavior', 'Detail']}
  columnWidths={['30%', '70%']}
  rows={[
['Tool required', 'Select X.'],
['Action', 'Right-click the selection and select Create Metrics Panel.'],
['Output', 'A new Metrics Panel scoped to the selected time range. See [Metrics: General tab](/documentation/reference/explore-settings#metrics-general-tab) for the computed fields.'],
]}
/>

## Annotations

Annotations mark specific times or time ranges in a Run. They can be plotted on the Timeseries Panel only and used as T-0 alignment points for Run comparison. In Live mode, live Rules are not rendered; alerts appear as toast notifications.

### Annotation types

Explore supports the following Annotation types.

<MintTable
  columns={['Type', 'Description']}
  columnWidths={['20%', '80%']}
  rows={[
['Phase', 'Represents a period or stage in a Run.'],
['Data Review', 'Captures findings or issues for review.'],
]}
/>

### Annotation fields

The following fields are available when creating or editing an Annotation. Available fields vary by Annotation type.

<MintTable
  columns={['Field', 'Applies to', 'Required', 'Description']}
  columnWidths={['22%', '25%', '13%', '40%']}
  rows={[
['Name', 'Phase, Data Review', 'Yes', 'Display name for the Annotation.'],
['Description', 'Phase, Data Review', 'No', 'Additional context.'],
['Comment', 'Phase, Data Review', 'No', 'Free-text comment.'],
['Status', 'Data Review only', 'No', 'Open, Accepted, or Failed.'],
['Assigned to', 'Data Review only', 'No', 'Assigns the Annotation to a user.'],
['Custom Metadata', 'Phase, Data Review', 'No', 'Key-value metadata.'],
['Associations', 'Phase, Data Review', 'No', 'Links to Assets, a Run, or Channels.'],
['Start time', 'Phase, Data Review', 'Yes*', 'Start of the time range. \n\n*Not required when Instantaneous Annotation is enabled.'],
['End time', 'Phase, Data Review', 'Yes*', 'End of the time range. \n\n*Not required when Instantaneous Annotation is enabled.'],
['Instantaneous Annotation', 'Phase, Data Review', 'No', 'Single point in time with no duration. Mutually exclusive with Start and End time.'],
]}
/>

## Dynamic URLs

Use dynamic URLs to open Explore with preconfigured telemetry data. By navigating to the `/explore` route with query parameters, you can automatically load specific Runs or Assets, Channels, Panel types, and optional time ranges, allowing users to open the exact data needed for analysis without manual setup.

For example, the following URL opens a Timeseries Panel with a single Channel on a single Run:

```
https://{domainName}/explore \
  ?method=single \
  &runs=runName \
  &channels=channelName \
  &panelType=timeseries
```

### URL structure

Use the `/explore` route with the required query parameter `method=single` to launch Explore with preconfigured data. Additional query parameters define Runs or Assets, Channels, Panel type, and optional time range.

Construct the URL using the following format:

```
https://{domainName}/explore?method=single \
  &runId={uuid1,uuid2,...} \
  &runIds={uuid1,uuid2,...} \
  &runs={runNameOrUUID1,runNameOrUUID2,...} \
  &assetId={uuid1,uuid2,...} \
  &assetIds={uuid1,uuid2,...} \
  &assets={assetNameOrUUID1,assetNameOrUUID2,...} \
  &channels={[prefix:]channelNameOrUUID,...} \
  &channelId={[prefix:]uuid,...} \
  &channelIds={[prefix:]uuid,...} \
  &panelType=timeseries|table|histogram|fft|scatter-plot|geo-map|metrics \
  &startTime=YYYY-MM-DDTHH:MM:SSZ \
  &endTime=YYYY-MM-DDTHH:MM:SSZ
```

* **Format**: Line breaks and backslashes (`\`) are shown for readability. In actual use, the URL must be a single continuous string joined with `&`, without spaces or backslashes.
* **Parameter order**: Parameters can appear in any order, but the URL must start with `domainName/explore?method=single`.
* **Channel name matching**: Provide Channel names through `channels`. `channelId` and `channelIds` accept Channel UUIDs only. Channel names are matched case-insensitively.

### URL parameters

<MintTable
  columns={['Parameter', 'Description', 'Type', 'Required', 'Options']}
  columnWidths={['20%', '41%', '14%', '5%', '16%']}
  rows={[
[
  '`domainName`',
  'The base URL of your Explore instance, including the protocol and domain.',
  'String',
  'Yes',
  'Not applicable'
],
[
  '`/explore`',
  'The route appended to `domainName` that opens the Explore interface.',
  'Constant',
  'Yes',
  'Not applicable'
],
[
  '`method=single`',
  'Specifies the Explore launch mode. The only supported value is `single`.',
  'String',
  'Yes',
  'Not applicable'
],
[
  '`runId` | `runIds`',
  'Selects Runs by UUID. Both parameters are aliases and function identically.\n\nAccepts a comma-separated list of Run UUIDs. When provided, the specified Runs are automatically selected on page load. For name-based selection, use `runs`.',
  'UUID, UUID, …',
  'No',
  'Not applicable'
],
[
  '`runs`',
  'Selects Runs by name or UUID.\n\nAccepts a comma-separated list of Run names, UUIDs, or a mix of both. The system automatically detects whether each value is a name or UUID. \n\nIf a name matches multiple Runs, the most recently created Run is used. If a name cannot be resolved, a warning appears and remaining selections still load.',
  'String, UUID, …',
  'No',
  'Not applicable'
],
[
  '`assetId` | `assetIds`',
  'Selects Assets by UUID. Both parameters are aliases and function identically.\n\nAccepts a comma-separated list of Asset UUIDs. When provided, the specified Assets are automatically selected on page load. For name-based selection, use `assets`.',
  'UUID, UUID, …',
  'No',
  'Not applicable'
],
[
  '`assets`',
  'Selects Assets by name or UUID.\n\nAccepts a comma-separated list of Asset names, UUIDs, or a mix of both. The system automatically detects whether each value is a name or UUID. \n\nIf a name cannot be resolved, a warning appears and remaining selections still load.',
  'String, UUID, …',
  'No',
  'Not applicable'
],
[
  '`channels`',
  'Selects Channels to plot by name or UUID.\n\nAccepts a comma-separated list of Channel names, UUIDs, or a mix of both. Channel names are matched case-insensitively.\n\nWhen Runs or Assets are also specified, matching Channels are automatically plotted across all selected data sources. \n\nSupports optional prefixes that assign a Channel to a Y-axis ([Timeseries](#channel-axis-assignment)) or to a role such as X, Y, color, or size ([Scatter Plot](#scatter-plot-channel-roles) and [Geo Map](#geo-map-channel-roles)).\n\nIf a name cannot be resolved, a warning appears and remaining Channels still load.',
  'String, UUID, …',
  'No',
  'Not applicable'
],
[
  '`channelId` | `channelIds`',
  'Selects Channels to plot by UUID. Both parameters are aliases and function identically.\n\nAccepts a comma-separated list of Channel UUIDs. To select Channels by name, use `channels`.\n\nSupports the same optional prefixes as `channels`.',
  'UUID, UUID, …',
  'No',
  'Not applicable'
],
[
  '`panelType`',
  'Specifies the visualization Panel used to display the data. \n\nIf the `panelType` parameter is not specified, the default Panel type is `timeseries`.\n\nEach Panel keeps only the Channels it can display; Channels of an incompatible data type are ignored. \n\n See [Channel selection by Panel type](#channel-selection-by-panel-type).',
  'String',
  'No',
  '`timeseries`, `table`, `histogram`, `fft`, `scatter-plot`, `geo-map`, or `metrics`'
],
[
  '`startTime`',
  'Defines the start of the analysis time range. \n\nIf provided without `endTime`, data is shown from this timestamp until the end of the Run or Asset.',
  'String (ISO 8601 UTC)',
  'No',
  'Not applicable'
],
[
  '`endTime`',
  'Defines the end of the analysis time range. \n\nIf provided without `startTime`, data is shown from the beginning of the Run or Asset up to this timestamp. \n\nWhen `panelType=table`, the view evaluates data at a single timestamp defined by `startTime`, so `endTime` has no effect.',
  'String (ISO 8601 UTC)',
  'No',
  'Not applicable'
]
]}
/>

### Channel axis assignment

In the Timeseries Panel, Channels can be plotted on multiple Y-axes by adding an axis prefix before the Channel name or UUID. If no prefix is provided, the Channel plots on the default axis `L1`. Axis prefixes are case-sensitive and work with both Channel names and UUIDs.

### Scatter Plot Channel roles

In the Scatter Plot Panel, assign each Channel to an axis or visual encoding using a role prefix before the Channel name or UUID:

<MintTable
  columns={['Prefix', 'Role']}
  columnWidths={['30%', '70%']}
  rows={[
['`x:`', 'Plots the Channel on the X-axis.'],
['`y:`', 'Plots the Channel on the Y-axis.'],
['`color:`', 'Maps the Channel to point color.'],
['`size:`', 'Maps the Channel to point size.']
]}
/>

* Role prefixes are case-insensitive and work with both Channel names and UUIDs.
* All prefixed Channels populate a single trace group. When a `color:` Channel is provided, points are colored with a Viridis gradient by default.
* A Channel without a recognized prefix is treated as a plain name or UUID. Scatter Plot sharelinks use a single Run; if multiple Runs are selected, the first is used.

### Geo Map Channel roles

In the Geo Map Panel, assign each Channel to a coordinate or visual encoding using a role prefix before the Channel name or UUID:

<MintTable
  columns={['Prefix', 'Role']}
  columnWidths={['30%', '70%']}
  rows={[
['`lat:`', 'Latitude coordinate.'],
['`lon:`', 'Longitude coordinate. `lng:` and `long:` are accepted aliases.'],
['`color:`', 'Maps the Channel to point color.'],
['`size:`', 'Maps the Channel to point size.']
]}
/>

* Role prefixes are case-insensitive and work with both Channel names and UUIDs.
* All prefixed Channels populate a single coordinate set.
* When a `color:` Channel is provided, points are colored with a Viridis gradient by default.
* If no role prefixes are provided, the Geo Map Panel automatically detects latitude and longitude Channels by name.

### Channel selection by Panel type

Each Panel type displays only the Channels it supports; Channels of an incompatible data type are ignored. For example, the Histogram, FFT, Scatter Plot, Geo Map, and Metrics Panels do not display string Channels, so a string Channel passed to one of them is dropped.

The Histogram Panel displays a single Channel. If more than one Channel is provided, the first compatible Channel is used and a warning appears.