feat(dashboards-v2): switch panel visualization type in the editor

Add a panel-type switcher to the Visualization config section that changes a
panel's kind in place. Switching is reversible within an edit session via a
per-kind cache (Table → List → Table restores the original query + spec); a
first visit rebuilds the query for the new type and resets the plugin spec,
carrying unit/decimals. Every kind now declares a visualization section so the
switcher is reachable from any panel, and it disables types whose supported
signals exclude the current datasource.

Reuse ConfigSelect (extended with per-option disabled + node icons) for the
control, type the panel signal as TelemetrytypesSignalDTO across the editor,
and add EDIT_MODE.md documenting V2 draft/edit mode.

frontend/jest.setup.ts

@@ -29,6 +29,18 @@ if (!HTMLElement.prototype.scrollIntoView) {
 	HTMLElement.prototype.scrollIntoView = function (): void {};
 }
 
+// jsdom doesn't implement the Pointer Capture API, which Radix UI primitives
+// (e.g. @signozhq/ui Select) call when opening. Stub them so those components
+// can be exercised in tests.
+if (!HTMLElement.prototype.hasPointerCapture) {
+	HTMLElement.prototype.hasPointerCapture = function (): boolean {
+		return false;
+	};
+}
+if (!HTMLElement.prototype.releasePointerCapture) {
+	HTMLElement.prototype.releasePointerCapture = function (): void {};
+}
+
 if (typeof window.IntersectionObserver === 'undefined') {
 	class IntersectionObserverMock {
 		observe(): void {}

frontend/src/AppRoutes/pageComponents.ts

@@ -122,6 +122,13 @@ export const DashboardWidget = Loadable(
 		import(/* webpackChunkName: "DashboardWidgetPage" */ 'pages/DashboardWidget'),
 );
 
+export const DashboardPanelEditorPage = Loadable(
+	() =>
+		import(
+			/* webpackChunkName: "DashboardPanelEditorPage" */ 'pages/DashboardPageV2/PanelEditorPage/PanelEditorPage'
+		),
+);
+
 export const EditRulesPage = Loadable(
 	() => import(/* webpackChunkName: "Alerts Edit Page" */ 'pages/EditRules'),
 );

frontend/src/AppRoutes/routes.ts

@@ -11,6 +11,7 @@ import {
 	ChannelsNew,
 	CreateNewAlerts,
 	DashboardPage,
+	DashboardPanelEditorPage,
 	DashboardsListPage,
 	DashboardWidget,
 	EditRulesPage,
@@ -196,6 +197,13 @@ const routes: AppRoutes[] = [
 		isPrivate: true,
 		key: 'DASHBOARD_WIDGET',
 	},
+	{
+		path: ROUTES.DASHBOARD_PANEL_EDITOR,
+		exact: true,
+		component: DashboardPanelEditorPage,
+		isPrivate: true,
+		key: 'DASHBOARD_PANEL_EDITOR',
+	},
 	{
 		path: ROUTES.EDIT_ALERTS,
 		exact: true,

frontend/src/constants/localStorage.ts

@@ -44,4 +44,5 @@ export enum LOCALSTORAGE {
 	ACTIVE_SIGNOZ_INSTANCE_URL = 'ACTIVE_SIGNOZ_INSTANCE_URL',
 	DASHBOARDS_LIST_VISIBLE_COLUMNS = 'DASHBOARDS_LIST_VISIBLE_COLUMNS',
 	DASHBOARDS_LIST_VIEWS = 'DASHBOARDS_LIST_VIEWS',
+	DASHBOARD_V2_PANEL_COLUMN_WIDTHS = 'DASHBOARD_V2_PANEL_COLUMN_WIDTHS',
 }

frontend/src/constants/routes.ts

@@ -24,6 +24,7 @@ const ROUTES = {
 	ALL_DASHBOARD: '/dashboard',
 	DASHBOARD: '/dashboard/:dashboardId',
 	DASHBOARD_WIDGET: '/dashboard/:dashboardId/:widgetId',
+	DASHBOARD_PANEL_EDITOR: '/dashboard/:dashboardId/panel/:panelId',
 	EDIT_ALERTS: '/alerts/edit',
 	LIST_ALL_ALERT: '/alerts',
 	ALERTS_NEW: '/alerts/new',

frontend/src/container/AppLayout/index.tsx

@@ -408,6 +408,9 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 
 	const isPublicDashboard = pathname.startsWith('/public/dashboard/');
 	const isAIAssistantPage = pathname.startsWith('/ai-assistant/');
+	// The V2 panel editor is a chromeless full-page route (no side nav / top nav),
+	// like the onboarding and public-dashboard screens.
+	const isPanelEditorV2 = routeKey === 'DASHBOARD_PANEL_EDITOR';
 
 	const renderFullScreen =
 		pathname === ROUTES.GET_STARTED ||
@@ -418,7 +421,8 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 		pathname === ROUTES.GET_STARTED_LOGS_MANAGEMENT ||
 		pathname === ROUTES.GET_STARTED_AWS_MONITORING ||
 		pathname === ROUTES.GET_STARTED_AZURE_MONITORING ||
-		isPublicDashboard;
+		isPublicDashboard ||
+		isPanelEditorV2;
 
 	const [showTrialExpiryBanner, setShowTrialExpiryBanner] = useState(false);
 

frontend/src/container/DashboardContainer/visualization/layout/ChartLayout/ChartLayout.styles.scss

@@ -7,15 +7,17 @@
 
 	&--legend-right {
 		flex-direction: row;
-
-		.chart-layout__legend-wrapper {
-			padding-left: 0 !important;
-		}
 	}
 
 	&__legend-wrapper {
+		// The inline height is the legend rectangle from calculateChartDimensions;
+		// border-box keeps the padding inside it so the wrapper doesn't grow past
+		// that height and steal space from the chart. overflow:hidden clips to the
+		// rectangle so the virtualized legend scrolls within it.
+		box-sizing: border-box;
+		min-height: 0;
+		overflow: hidden;
 		padding-left: 12px;
 		padding-bottom: 12px;
-		overflow: auto;
 	}
 }

frontend/src/hooks/__tests__/useConfirmableAction.test.ts

@@ -0,0 +1,61 @@
+import { act, renderHook } from '@testing-library/react';
+
+import { useConfirmableAction } from '../useConfirmableAction';
+
+describe('useConfirmableAction', () => {
+	it('starts closed and idle', () => {
+		const { result } = renderHook(() =>
+			useConfirmableAction(jest.fn().mockResolvedValue(undefined)),
+		);
+		expect(result.current.open).toBe(false);
+		expect(result.current.isPending).toBe(false);
+	});
+
+	it('request() opens the prompt without running the action', () => {
+		const action = jest.fn().mockResolvedValue(undefined);
+		const { result } = renderHook(() => useConfirmableAction(action));
+
+		act(() => result.current.request());
+
+		expect(result.current.open).toBe(true);
+		expect(action).not.toHaveBeenCalled();
+	});
+
+	it('confirm() runs the action and closes on success', async () => {
+		const action = jest.fn().mockResolvedValue(undefined);
+		const { result } = renderHook(() => useConfirmableAction(action));
+
+		act(() => result.current.request());
+		await act(async () => {
+			await result.current.confirm();
+		});
+
+		expect(action).toHaveBeenCalledTimes(1);
+		expect(result.current.open).toBe(false);
+		expect(result.current.isPending).toBe(false);
+	});
+
+	it('keeps the prompt open and resets pending when the action rejects', async () => {
+		const action = jest.fn().mockRejectedValue(new Error('boom'));
+		const { result } = renderHook(() => useConfirmableAction(action));
+
+		act(() => result.current.request());
+		await act(async () => {
+			await expect(result.current.confirm()).rejects.toThrow('boom');
+		});
+
+		expect(result.current.open).toBe(true);
+		expect(result.current.isPending).toBe(false);
+	});
+
+	it('cancel() closes the prompt without running the action', () => {
+		const action = jest.fn().mockResolvedValue(undefined);
+		const { result } = renderHook(() => useConfirmableAction(action));
+
+		act(() => result.current.request());
+		act(() => result.current.cancel());
+
+		expect(result.current.open).toBe(false);
+		expect(action).not.toHaveBeenCalled();
+	});
+});

frontend/src/hooks/useConfirmableAction.ts

@@ -0,0 +1,45 @@
+import { useCallback, useMemo, useState } from 'react';
+
+export interface ConfirmableAction {
+	/** Whether the confirmation prompt is open. */
+	open: boolean;
+	/** The confirmed action is in flight. */
+	isPending: boolean;
+	/** Open the confirmation prompt (e.g. from a menu item / button). */
+	request: () => void;
+	/** Run the action, tracking the in-flight flag; closes the prompt on success. */
+	confirm: () => Promise<void>;
+	/** Dismiss the prompt without acting. */
+	cancel: () => void;
+}
+
+/**
+ * Generic two-step confirm flow for a (usually destructive) async action.
+ * `request()` opens the prompt, `confirm()` runs `action` while tracking an
+ * in-flight flag and closes on success, `cancel()` dismisses it. Owns only the
+ * confirm state machine — what renders the prompt (dialog, popover) is the
+ * caller's concern, so it stays reusable across confirm surfaces.
+ */
+export function useConfirmableAction(
+	action: () => Promise<void>,
+): ConfirmableAction {
+	const [open, setOpen] = useState(false);
+	const [isPending, setIsPending] = useState(false);
+
+	const request = useCallback((): void => setOpen(true), []);
+	const cancel = useCallback((): void => setOpen(false), []);
+	const confirm = useCallback(async (): Promise<void> => {
+		setIsPending(true);
+		try {
+			await action();
+			setOpen(false);
+		} finally {
+			setIsPending(false);
+		}
+	}, [action]);
+
+	return useMemo(
+		() => ({ open, isPending, request, confirm, cancel }),
+		[open, isPending, request, confirm, cancel],
+	);
+}

frontend/src/lib/uPlotV2/components/Legend/Legend.styles.scss

@@ -1,3 +1,5 @@
+@use '../../../../styles/scrollbar' as *;
+
 .legend-search-container {
 	flex-shrink: 0;
 	width: 100%;
@@ -15,6 +17,10 @@
 	gap: 12px;
 	height: 100%;
 	width: 100%;
+	// Allow the flex children to shrink below their content height so the
+	// virtualized grid scrolls within the capped legend height instead of
+	// overflowing the wrapper (default min-height:auto would block the shrink).
+	min-height: 0;
 
 	&:has(.legend-item-focused) .legend-item {
 		opacity: 0.3;
@@ -33,6 +39,11 @@
 	}
 
 	.legend-virtuoso-container {
+		// flex:1 + min-height:0 pins the scroller to the space left after the
+		// search box (RIGHT legend) and lets it scroll instead of growing to fit
+		// every row — without this the grid overflows a BOTTOM legend's fixed height.
+		flex: 1;
+		min-height: 0;
 		height: 100%;
 		width: 100%;
 
@@ -67,18 +78,7 @@
 			}
 		}
 
-		&::-webkit-scrollbar {
-			width: 0.3rem;
-		}
-
-		&::-webkit-scrollbar-track {
-			background: transparent;
-		}
-
-		&::-webkit-scrollbar-thumb {
-			background: var(--l3-background);
-			border-radius: 0.5rem;
-		}
+		@include custom-scrollbar;
 	}
 }
 
@@ -108,6 +108,10 @@
 	align-items: center;
 	gap: 6px;
 	padding: 4px 8px;
+	// Include padding within the width so a full-width row (legend-item-right) fits its
+	// column instead of overflowing by the 16px horizontal padding — there is no global
+	// border-box reset, so the default content-box would make it overflow.
+	box-sizing: border-box;
 	max-width: 100%;
 	overflow: hidden;
 	border-radius: 4px;

frontend/src/lib/uPlotV2/components/Legend/Legend.tsx

@@ -5,6 +5,7 @@ import { Button } from '@signozhq/ui/button';
 import { TooltipSimple } from '@signozhq/ui/tooltip';
 import cx from 'classnames';
 import { useCopyToClipboard } from 'hooks/useCopyToClipboard';
+import { useResizeObserver } from 'hooks/useDimensions';
 import { LegendItem } from 'lib/uPlotV2/config/types';
 import { Check, Copy } from '@signozhq/icons';
 
@@ -36,17 +37,16 @@ export default function Legend({
 
 	// Search is intrinsic to the right-positioned legend.
 	const searchEnabled = position === LegendPosition.RIGHT;
+	const { width: containerWidth } = useResizeObserver(legendContainerRef);
 
 	const isSingleRow = useMemo(() => {
-		if (!legendContainerRef.current || position !== LegendPosition.BOTTOM) {
+		if (position !== LegendPosition.BOTTOM || containerWidth <= 0) {
 			return false;
 		}
-		const containerWidth = legendContainerRef.current.clientWidth;
-
 		const totalLegendWidth = items.length * (averageLegendWidth + 16);
 		const totalRows = Math.ceil(totalLegendWidth / containerWidth);
 		return totalRows <= 1;
-	}, [averageLegendWidth, items.length, position]);
+	}, [averageLegendWidth, items.length, position, containerWidth]);
 
 	const visibleLegendItems = useMemo(() => {
 		if (!searchEnabled || !legendSearchQuery.trim()) {

frontend/src/lib/uPlotV2/config/UPlotSeriesBuilder.ts

@@ -87,7 +87,7 @@ export class UPlotSeriesBuilder extends ConfigBuilder<
 			lineConfig.fill = `${finalFillColor}40`;
 		} else if (fillMode && fillMode !== FillMode.None) {
 			if (fillMode === FillMode.Solid) {
-				lineConfig.fill = finalFillColor;
+				lineConfig.fill = `${finalFillColor}70`;
 			} else if (fillMode === FillMode.Gradient) {
 				lineConfig.fill = (self: uPlot): CanvasGradient =>
 					generateGradientFill(self, finalFillColor, 'rgba(0, 0, 0, 0)');

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardPageToolbar/index.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useMemo } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { FullScreenHandle } from 'react-full-screen';
 import { toast } from '@signozhq/ui/sonner';
 import logEvent from 'api/common/logEvent';
@@ -13,10 +13,11 @@ import type {
 } from 'api/generated/services/sigNoz.schemas';
 import { Base64Icons } from 'container/DashboardContainer/DashboardSettings/General/utils';
 import { useAppContext } from 'providers/App/App';
-import { usePanelTypeSelectionModalStore } from 'providers/Dashboard/helpers/panelTypeSelectionModalHelper';
 import { useErrorModal } from 'providers/ErrorModalProvider';
 import APIError from 'types/api/error';
 
+import { useCreatePanel } from '../hooks/useCreatePanel';
+import PanelTypeSelectionModal from '../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal';
 import DashboardActions from './DashboardActions/DashboardActions';
 import DashboardInfo from './DashboardInfo/DashboardInfo';
 import { useEditableTitle } from './DashboardInfo/useEditableTitle';
@@ -49,9 +50,8 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 
 	const { user } = useAppContext();
 	const { showErrorModal } = useErrorModal();
-	const setIsPanelTypeSelectionModalOpen = usePanelTypeSelectionModalStore(
-		(s) => s.setIsPanelTypeSelectionModalOpen,
-	);
+	const createPanel = useCreatePanel();
+	const [isAddingPanel, setIsAddingPanel] = useState(false);
 
 	const isAuthor =
 		!!user?.email && !!dashboard.createdBy && dashboard.createdBy === user.email;
@@ -107,8 +107,8 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 		void logEvent('Dashboard Detail V2: Add new panel clicked', {
 			dashboardId: id,
 		});
-		setIsPanelTypeSelectionModalOpen(true);
-	}, [id, setIsPanelTypeSelectionModalOpen]);
+		setIsAddingPanel(true);
+	}, [id]);
 
 	return (
 		<section className={styles.dashboardPageToolbarContainer}>
@@ -140,6 +140,14 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 			</div>
 
 			<VariablesBar dashboard={dashboard} />
+			<PanelTypeSelectionModal
+				open={isAddingPanel}
+				onClose={(): void => setIsAddingPanel(false)}
+				onSelect={(pluginKind): void => {
+					setIsAddingPanel(false);
+					createPanel({ pluginKind });
+				}}
+			/>
 		</section>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.module.scss

@@ -0,0 +1,90 @@
+.config {
+	display: flex;
+	flex-direction: column;
+	flex: 1;
+	// padding: 18px 18px 44px;
+	background-color: var(--l1-background);
+	overflow-y: auto;
+	overflow-x: hidden;
+
+	//TODO: replace this with custom-scrollbar mixin
+	// Thin, unobtrusive scrollbar (replaces the chunky native bar).
+	$thumb: color-mix(in srgb, var(--bg-vanilla-100) 16%, transparent);
+
+	scrollbar-width: thin;
+	scrollbar-color: $thumb transparent;
+
+	&::-webkit-scrollbar {
+		width: 8px;
+	}
+
+	&::-webkit-scrollbar-track {
+		background: transparent;
+	}
+
+	&::-webkit-scrollbar-thumb {
+		background: $thumb;
+		border-radius: 999px;
+		border: 2px solid transparent;
+		background-clip: padding-box;
+	}
+}
+
+.heading {
+	margin-bottom: 18px;
+	padding: 16px 16px 0 16px;
+}
+
+.title {
+	display: flex;
+	align-items: baseline;
+	gap: 9px;
+	white-space: nowrap;
+}
+
+.subtitle {
+	font-size: 12px;
+	color: var(--text-vanilla-400);
+}
+
+.eyebrow {
+	display: block;
+	margin: 0 2px 10px;
+	font-size: 11px;
+	font-weight: 600;
+	letter-spacing: 0.06em;
+	text-transform: uppercase;
+	color: var(--l1-foreground);
+}
+
+.group {
+	display: flex;
+	flex-direction: column;
+	gap: 16px;
+	padding: 0 16px;
+}
+
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}
+
+.divider {
+	height: 1px;
+	background: var(--l2-border);
+	margin: 18px 0;
+}
+
+.sectionsContainer {
+	padding: 0 16px;
+}
+
+.sections {
+	display: flex;
+	flex-direction: column;
+
+	& > * + * {
+		border-top: 1px solid var(--l2-border);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/ConfigPane.tsx

@@ -0,0 +1,116 @@
+import { Input } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { getPanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/registry';
+import { getBuilderQueries } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/getBuilderQueries';
+
+import type { LegendSeries } from '../hooks/useLegendSeries';
+import type { TableColumnOption } from '../hooks/useTableColumns';
+import SectionSlot from './SectionSlot/SectionSlot';
+
+import styles from './ConfigPane.module.scss';
+import { PanelKind } from '../../Panels/types/panelKind';
+
+interface ConfigPaneProps {
+	/** Full plugin kind (e.g. `signoz/TimeSeriesPanel`); drives which sections show. */
+	panelKind: PanelKind;
+	/** The panel spec — the single editing surface (title/description + section slices). */
+	spec: DashboardtypesPanelSpecDTO;
+	onChangeSpec: (next: DashboardtypesPanelSpecDTO) => void;
+	/** Switch the panel to another visualization kind. */
+	onChangePanelKind: (kind: PanelKind) => void;
+	/** Panel's resolved series, provided to sections that need them (legend colors). */
+	legendSeries: LegendSeries[];
+	/** Table panel's resolved value columns, for the table-only editors. */
+	tableColumns: TableColumnOption[];
+}
+
+/**
+ * Right-hand configuration pane. Renders the always-present general fields (title +
+ * description) followed by the panel kind's configuration sections (Formatting, Axes,
+ * …). The section list is declared per kind (`PanelDefinition.sections`) and rendered
+ * generically via the section registry — only sections with a built editor appear.
+ */
+function ConfigPane({
+	panelKind,
+	spec,
+	onChangeSpec,
+	onChangePanelKind,
+	legendSeries,
+	tableColumns,
+}: ConfigPaneProps): JSX.Element {
+	const definition = getPanelDefinition(panelKind);
+	const sections = definition?.sections ?? [];
+
+	// Telemetry signal of the panel's first builder query — scopes field-key
+	// suggestions for editors that need them (the List column picker). The v5
+	// `signal` literal matches the TelemetrytypesSignalDTO values.
+	const signal = getBuilderQueries(spec.queries)[0]?.signal as
+		| TelemetrytypesSignalDTO
+		| undefined;
+
+	// Title/description are just a slice of the spec — edit them through the same
+	// onChangeSpec path the sections use, so there's a single editing surface.
+	const setDisplayField = (field: 'name' | 'description', value: string): void =>
+		onChangeSpec({ ...spec, display: { ...spec.display, [field]: value } });
+
+	return (
+		<div className={styles.config}>
+			<header className={styles.heading}>
+				<Typography.Text>Panel settings</Typography.Text>
+			</header>
+
+			<div className={styles.group}>
+				<div className={styles.field}>
+					<Typography.Text>Title</Typography.Text>
+					<Input
+						data-testid="panel-editor-v2-title"
+						value={spec.display?.name ?? ''}
+						placeholder="Panel title"
+						onChange={(e): void => setDisplayField('name', e.target.value)}
+					/>
+				</div>
+
+				<div className={styles.field}>
+					<Typography.Text>Description</Typography.Text>
+					<Input.TextArea
+						data-testid="panel-editor-v2-description"
+						value={spec.display?.description ?? ''}
+						placeholder="Add a description"
+						rows={3}
+						onChange={(e): void => setDisplayField('description', e.target.value)}
+					/>
+				</div>
+			</div>
+
+			{sections.length > 0 && (
+				<>
+					<div className={styles.divider} />
+					<div className={styles.sectionsContainer}>
+						<span className={styles.eyebrow}>Display</span>
+						<div className={styles.sections}>
+							{sections.map((config) => (
+								<SectionSlot
+									key={config.kind}
+									config={config}
+									spec={spec}
+									onChangeSpec={onChangeSpec}
+									legendSeries={legendSeries}
+									tableColumns={tableColumns}
+									signal={signal}
+									panelKind={panelKind}
+									onChangePanelKind={onChangePanelKind}
+								/>
+							))}
+						</div>
+					</div>
+				</>
+			)}
+		</div>
+	);
+}
+
+export default ConfigPane;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/PanelTypeSwitcher.module.scss

@@ -0,0 +1,6 @@
+// Matches ConfigPane's `.field` so the switcher lines up with the title/description fields.
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/PanelTypeSwitcher.tsx

@@ -0,0 +1,54 @@
+import { Typography } from '@signozhq/ui/typography';
+import type { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
+
+import { getPanelDefinition } from '../../../Panels/registry';
+import type { PanelKind } from '../../../Panels/types/panelKind';
+import { PANEL_TYPES } from '../../../PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/constants';
+import ConfigSelect from '../controls/ConfigSelect/ConfigSelect';
+
+import styles from './PanelTypeSwitcher.module.scss';
+
+interface PanelTypeSwitcherProps {
+	/** The current panel kind (selected value). */
+	panelKind: PanelKind;
+	/** Panel's current datasource — drives the disabled rule. */
+	signal?: TelemetrytypesSignalDTO;
+	onChange: (kind: PanelKind) => void;
+}
+
+/**
+ * Visualization-type selector (rendered inside the Visualization section). Types whose
+ * supported signals exclude the panel's current datasource are disabled (V1 parity —
+ * e.g. List needs logs/traces, not metrics). The datasource is unknown for
+ * PromQL/ClickHouse queries, in which case no type is disabled.
+ */
+function PanelTypeSwitcher({
+	panelKind,
+	signal,
+	onChange,
+}: PanelTypeSwitcherProps): JSX.Element {
+	const items = PANEL_TYPES.map((type) => {
+		const definition = getPanelDefinition(type.pluginKind as PanelKind);
+		return {
+			value: type.pluginKind,
+			label: type.label,
+			icon: type.icon,
+			disabled:
+				!!signal && !!definition && !definition.supportedSignals.includes(signal),
+		};
+	});
+
+	return (
+		<div className={styles.field}>
+			<Typography.Text>Panel Type</Typography.Text>
+			<ConfigSelect
+				testId="panel-editor-v2-type-switcher"
+				value={panelKind}
+				items={items}
+				onChange={(value): void => onChange(value as PanelKind)}
+			/>
+		</div>
+	);
+}
+
+export default PanelTypeSwitcher;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/PanelTypeSwitcher/__tests__/PanelTypeSwitcher.test.tsx

@@ -0,0 +1,73 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { getPanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/registry';
+
+import PanelTypeSwitcher from '../PanelTypeSwitcher';
+import { TelemetrytypesSignalDTO } from 'api/generated/services/sigNoz.schemas';
+
+jest.mock('pages/DashboardPageV2/DashboardContainer/Panels/registry', () => ({
+	getPanelDefinition: jest.fn(),
+}));
+
+const mockGetPanelDefinition = getPanelDefinition as unknown as jest.Mock;
+
+function openDropdown(): void {
+	fireEvent.mouseDown(screen.getByRole('combobox'));
+}
+
+describe('PanelTypeSwitcher', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		// List supports only logs/traces; every other kind also supports metrics.
+		mockGetPanelDefinition.mockImplementation((kind: string) => ({
+			supportedSignals:
+				kind === 'signoz/ListPanel'
+					? ['logs', 'traces']
+					: ['metrics', 'logs', 'traces'],
+		}));
+	});
+
+	it('fires onChange with the chosen plugin kind', () => {
+		const onChange = jest.fn();
+		render(
+			<PanelTypeSwitcher panelKind="signoz/TimeSeriesPanel" onChange={onChange} />,
+		);
+
+		openDropdown();
+		fireEvent.click(screen.getByText('List'));
+
+		expect(onChange).toHaveBeenCalledWith('signoz/ListPanel');
+	});
+
+	it('disables types whose supported signals exclude the current datasource', () => {
+		render(
+			<PanelTypeSwitcher
+				panelKind="signoz/TimeSeriesPanel"
+				signal={TelemetrytypesSignalDTO.metrics}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		openDropdown();
+		const disabled = Array.from(
+			document.querySelectorAll('.ant-select-item-option-disabled'),
+		).map((el) => el.textContent);
+
+		// List can't render a metrics query, so it's disabled; Time Series stays enabled.
+		expect(disabled).toContain('List');
+		expect(disabled).not.toContain('Time Series');
+	});
+
+	it('does not disable any type when the datasource is unknown', () => {
+		render(
+			<PanelTypeSwitcher
+				panelKind="signoz/TimeSeriesPanel"
+				onChange={jest.fn()}
+			/>,
+		);
+
+		openDropdown();
+		expect(
+			document.querySelectorAll('.ant-select-item-option-disabled'),
+		).toHaveLength(0);
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SectionSlot/SectionSlot.tsx

@@ -0,0 +1,90 @@
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import {
+	SECTION_METADATA,
+	type SectionConfig,
+} from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import type { PanelKind } from '../../../Panels/types/panelKind';
+import type { LegendSeries } from '../../hooks/useLegendSeries';
+import type { TableColumnOption } from '../../hooks/useTableColumns';
+import { resolveSectionEditor } from '../sectionRegistry';
+import SettingsSection from '../SettingsSection/SettingsSection';
+
+interface SectionSlotProps {
+	config: SectionConfig;
+	spec: DashboardtypesPanelSpecDTO;
+	onChangeSpec: (next: DashboardtypesPanelSpecDTO) => void;
+	/** Resolved series, forwarded to editors that need them (legend colors). */
+	legendSeries: LegendSeries[];
+	/** Table panel's resolved value columns, for the table-only editors. */
+	tableColumns: TableColumnOption[];
+	/** Panel's telemetry signal, for editors that fetch field suggestions (List columns). */
+	signal?: TelemetrytypesSignalDTO;
+	/** Current panel kind + switch handler, for the visualization section's type switcher. */
+	panelKind: PanelKind;
+	onChangePanelKind: (kind: PanelKind) => void;
+}
+
+/**
+ * Renders one configuration section: its collapsible wrapper plus the registered editor
+ * for `config.kind`, wired through the registry's spec lens. Renders nothing when the
+ * kind has no editor yet (sections roll out incrementally), so a kind can declare a
+ * section before its editor exists.
+ */
+function SectionSlot({
+	config,
+	spec,
+	onChangeSpec,
+	legendSeries,
+	tableColumns,
+	signal,
+	panelKind,
+	onChangePanelKind,
+}: SectionSlotProps): JSX.Element | null {
+	// A kind can hide a section based on current spec state (e.g. Histogram legend once
+	// queries are merged) — skip it before resolving the editor.
+	if (config.isHidden?.(spec)) {
+		return null;
+	}
+
+	const editor = resolveSectionEditor(config.kind);
+	if (!editor) {
+		return null;
+	}
+
+	const { title, icon: Icon } = SECTION_METADATA[config.kind];
+	const { Component, read, write } = editor;
+	// Atomic sections carry no `controls`; controlled ones do.
+	const controls = 'controls' in config ? config.controls : undefined;
+	// The panel's formatting unit, forwarded to editors that scope to it (thresholds
+	// restrict their unit picker to this unit's category, as in V1).
+	const yAxisUnit = (
+		spec.plugin?.spec as { formatting?: { unit?: string } } | undefined
+	)?.formatting?.unit;
+
+	return (
+		<SettingsSection
+			title={title}
+			icon={<Icon size={15} />}
+			// Open Visualization by default so the type switcher is visible.
+			defaultOpen={config.kind === 'visualization'}
+		>
+			<Component
+				value={read(spec)}
+				controls={controls}
+				onChange={(next): void => onChangeSpec(write(spec, next))}
+				legendSeries={legendSeries}
+				yAxisUnit={yAxisUnit}
+				tableColumns={tableColumns}
+				signal={signal}
+				panelKind={panelKind}
+				onChangePanelKind={onChangePanelKind}
+			/>
+		</SettingsSection>
+	);
+}
+
+export default SectionSlot;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SettingsSection/SettingsSection.module.scss

@@ -0,0 +1,54 @@
+.header {
+	display: flex;
+	align-items: center;
+	gap: 11px;
+	width: 100%;
+	height: 44px;
+	padding: 0 4px;
+	border: none;
+	background: transparent;
+	cursor: pointer;
+	color: var(--text-vanilla-100);
+	border-radius: 4px;
+}
+
+.iconTile {
+	display: grid;
+	place-items: center;
+	width: 27px;
+	height: 27px;
+	flex: none;
+	border-radius: 3px;
+	background: var(--l3-background);
+	color: var(--l3-foreground);
+	transition: all 0.15s ease;
+}
+
+.iconTileOpen {
+	background: color-mix(in srgb, var(--bg-robin-400) 14%, transparent);
+	color: var(--bg-robin-400);
+}
+
+.title {
+	flex: 1;
+	text-align: left;
+	font-weight: 600;
+	color: var(--l2-foreground);
+}
+
+.chevron {
+	flex: none;
+	color: var(--l2-border);
+	transition: transform 0.15s ease;
+
+	&.open {
+		transform: rotate(180deg);
+	}
+}
+
+.body {
+	display: flex;
+	flex-direction: column;
+	gap: 16px;
+	padding: 2px 0 18px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/SettingsSection/SettingsSection.tsx

@@ -0,0 +1,54 @@
+import { type ReactNode, useState } from 'react';
+import { ChevronDown } from '@signozhq/icons';
+import { Typography } from '@signozhq/ui/typography';
+import cx from 'classnames';
+
+import styles from './SettingsSection.module.scss';
+
+interface SettingsSectionProps {
+	title: string;
+	icon?: ReactNode;
+	defaultOpen?: boolean;
+	children: ReactNode;
+}
+
+/**
+ * Collapsible container for one configuration section in the V2 panel editor's
+ * ConfigPane. Header shows an icon tile (accented when expanded), the title, and a
+ * rotating chevron; sections are separated by hairline dividers (no surrounding boxes),
+ * matching the Configure-panel design.
+ */
+function SettingsSection({
+	title,
+	icon,
+	defaultOpen = false,
+	children,
+}: SettingsSectionProps): JSX.Element {
+	const [isOpen, setIsOpen] = useState(defaultOpen);
+
+	return (
+		<section className={styles.section}>
+			<button
+				type="button"
+				className={styles.header}
+				aria-expanded={isOpen}
+				data-testid={`config-section-${title}`}
+				onClick={(): void => setIsOpen((prev) => !prev)}
+			>
+				{icon && (
+					<span className={cx(styles.iconTile, { [styles.iconTileOpen]: isOpen })}>
+						{icon}
+					</span>
+				)}
+				<Typography.Text className={styles.title}>{title}</Typography.Text>
+				<ChevronDown
+					size={15}
+					className={cx(styles.chevron, { [styles.open]: isOpen })}
+				/>
+			</button>
+			{isOpen && <div className={styles.body}>{children}</div>}
+		</section>
+	);
+}
+
+export default SettingsSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/__tests__/ConfigPane.test.tsx

@@ -0,0 +1,70 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { DashboardtypesPanelSpecDTO } from 'api/generated/services/sigNoz.schemas';
+
+import ConfigPane from '../ConfigPane';
+import { PanelKind } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
+
+function spec(unit?: string): DashboardtypesPanelSpecDTO {
+	return {
+		display: { name: 'CPU', description: 'usage' },
+		plugin: {
+			kind: 'signoz/TimeSeriesPanel',
+			spec: unit ? { formatting: { unit } } : {},
+		},
+		queries: [],
+	} as unknown as DashboardtypesPanelSpecDTO;
+}
+
+function renderConfigPane(
+	overrides: Partial<React.ComponentProps<typeof ConfigPane>> = {},
+): React.ComponentProps<typeof ConfigPane> {
+	const props: React.ComponentProps<typeof ConfigPane> = {
+		panelKind: 'signoz/TimeSeriesPanel',
+		spec: spec(),
+		onChangeSpec: jest.fn(),
+		onChangePanelKind: jest.fn(),
+		legendSeries: [],
+		tableColumns: [],
+		...overrides,
+	};
+	render(<ConfigPane {...props} />);
+	return props;
+}
+
+describe('ConfigPane', () => {
+	it('renders the seeded title and description', () => {
+		renderConfigPane();
+
+		expect(screen.getByTestId('panel-editor-v2-title')).toHaveValue('CPU');
+		expect(screen.getByTestId('panel-editor-v2-description')).toHaveValue(
+			'usage',
+		);
+	});
+
+	it('reports title edits through onChangeSpec (into spec.display)', () => {
+		const { onChangeSpec } = renderConfigPane();
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-title'), {
+			target: { value: 'Memory' },
+		});
+
+		expect(onChangeSpec).toHaveBeenCalledWith(
+			expect.objectContaining({
+				display: { name: 'Memory', description: 'usage' },
+			}),
+		);
+	});
+
+	it('renders the Formatting section for a kind that declares it', () => {
+		renderConfigPane();
+		// The TimeSeries kind declares a Formatting section; its collapsible header shows.
+		expect(screen.getByTestId('config-section-Formatting')).toBeInTheDocument();
+	});
+
+	it('omits the Formatting section for an unknown kind', () => {
+		renderConfigPane({ panelKind: 'signoz/UnknownPanel' as PanelKind });
+		expect(
+			screen.queryByTestId('config-section-Formatting'),
+		).not.toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSegmented/ConfigSegmented.module.scss

@@ -0,0 +1,10 @@
+.group {
+	width: 100%;
+}
+
+.segment {
+	display: inline-flex;
+	align-items: center;
+	gap: 6px;
+	white-space: nowrap;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSegmented/ConfigSegmented.tsx

@@ -0,0 +1,59 @@
+import { ToggleGroupSimple } from '@signozhq/ui/toggle-group';
+
+import { SegmentIcon, type SegmentIconName } from '../segmentIcons';
+
+import styles from './ConfigSegmented.module.scss';
+
+export interface ConfigSegmentedItem {
+	value: string;
+	label: string;
+	icon?: SegmentIconName;
+}
+
+interface ConfigSegmentedProps {
+	testId: string;
+	value: string | undefined;
+	items: ConfigSegmentedItem[];
+	onChange: (value: string) => void;
+}
+
+/**
+ * Inline segmented control for short option sets in the config pane (line style, fill
+ * mode, axis scale, legend position). Each segment carries an optional muted glyph that
+ * brightens with the selected state (it inherits the toggle's `currentColor`). Built on
+ * the Periscope ToggleGroup so it stays theme-faithful.
+ */
+function ConfigSegmented({
+	testId,
+	value,
+	items,
+	onChange,
+}: ConfigSegmentedProps): JSX.Element {
+	return (
+		<ToggleGroupSimple
+			type="single"
+			testId={testId}
+			className={styles.group}
+			value={value}
+			items={items.map((item) => ({
+				value: item.value,
+				'aria-label': item.label,
+				label: (
+					<span className={styles.segment}>
+						{item.icon && <SegmentIcon name={item.icon} />}
+						{item.label}
+					</span>
+				),
+			}))}
+			// Single toggle-groups emit '' when the active segment is re-clicked; ignore that
+			// so a required choice (e.g. scale, position) can't be cleared to an empty value.
+			onChange={(next: string): void => {
+				if (next) {
+					onChange(next);
+				}
+			}}
+		/>
+	);
+}
+
+export default ConfigSegmented;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSelect/ConfigSelect.module.scss

@@ -0,0 +1,10 @@
+// Fill the section field so the select lines up with the other full-width controls.
+.select {
+	width: 100%;
+}
+
+.item {
+	display: inline-flex;
+	align-items: center;
+	gap: 9px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSelect/ConfigSelect.tsx

@@ -0,0 +1,64 @@
+import type { ReactNode } from 'react';
+import { Select } from 'antd';
+
+import { SegmentIcon, type SegmentIconName } from '../segmentIcons';
+
+import styles from './ConfigSelect.module.scss';
+
+export interface ConfigSelectItem {
+	value: string;
+	label: string;
+	/** A `SegmentIconName` string (resolved to a glyph), or an arbitrary icon node. */
+	icon?: ReactNode;
+	disabled?: boolean;
+}
+
+interface ConfigSelectProps {
+	testId: string;
+	value: string | undefined;
+	placeholder?: string;
+	items: ConfigSelectItem[];
+	onChange: (value: string) => void;
+}
+
+/**
+ * Single-select dropdown for the panel editor's config sections. Built on antd's
+ * `Select` so it matches the rest of the editor's antd controls; the menu portals to
+ * `document.body` (antd default) so the surrounding `overflow:auto` pane can't clip it.
+ */
+function ConfigSelect({
+	testId,
+	value,
+	placeholder,
+	items,
+	onChange,
+}: ConfigSelectProps): JSX.Element {
+	return (
+		<Select<string>
+			className={styles.select}
+			data-testid={testId}
+			value={value}
+			placeholder={placeholder}
+			onChange={onChange}
+			virtual={false}
+			options={items.map((item) => ({
+				value: item.value,
+				disabled: item.disabled,
+				label: item.icon ? (
+					<span className={styles.item}>
+						{typeof item.icon === 'string' ? (
+							<SegmentIcon name={item.icon as SegmentIconName} />
+						) : (
+							item.icon
+						)}
+						{item.label}
+					</span>
+				) : (
+					item.label
+				),
+			}))}
+		/>
+	);
+}
+
+export default ConfigSelect;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSwitch/ConfigSwitch.module.scss

@@ -0,0 +1,30 @@
+.card {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 12px;
+	padding: 12px 14px;
+	border: 1px solid var(--l2-border);
+	border-radius: 6px;
+	background: var(--l2-background-60);
+}
+
+.text {
+	display: flex;
+	flex-direction: column;
+	gap: 2px;
+	min-width: 0;
+}
+
+.title {
+	font-size: 12px;
+	font-weight: 600;
+	letter-spacing: 0.06em;
+	text-transform: uppercase;
+	color: var(--l2-foreground);
+}
+
+.description {
+	font-size: 12px;
+	color: var(--l3-foreground);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/ConfigSwitch/ConfigSwitch.tsx

@@ -0,0 +1,43 @@
+import { Switch } from '@signozhq/ui/switch';
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './ConfigSwitch.module.scss';
+
+interface ConfigSwitchProps {
+	testId: string;
+	/** Shown uppercased as the card title. */
+	title: string;
+	/** Optional helper line under the title. */
+	description?: string;
+	value: boolean;
+	onChange: (checked: boolean) => void;
+}
+
+/**
+ * Boolean toggle rendered as a bordered card: an uppercase title with an optional
+ * description on the left and a Switch on the right. The standard presentation for
+ * on/off panel-config controls (e.g. "Show points").
+ */
+function ConfigSwitch({
+	testId,
+	title,
+	description,
+	value,
+	onChange,
+}: ConfigSwitchProps): JSX.Element {
+	return (
+		<div className={styles.card}>
+			<div className={styles.text}>
+				<span className={styles.title}>{title}</span>
+				{description && (
+					<Typography.Text className={styles.description}>
+						{description}
+					</Typography.Text>
+				)}
+			</div>
+			<Switch testId={testId} value={value} onChange={onChange} />
+		</div>
+	);
+}
+
+export default ConfigSwitch;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/LegendColorRow.tsx

@@ -0,0 +1,62 @@
+import { ColorPicker } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './LegendColors.module.scss';
+
+interface LegendColorRowProps {
+	label: string;
+	/** Effective color shown in the swatch (override or auto). */
+	color: string;
+	/** True when the series has an explicit override (enables Reset). */
+	isOverridden: boolean;
+	onChange: (hex: string) => void;
+	onReset: () => void;
+}
+
+/**
+ * One series row in the legend-colors list: an antd ColorPicker swatch trigger, the
+ * series label, and a Reset action shown only when the color is overridden. `onChange`
+ * fires on commit (`onChangeComplete`) so dragging the picker doesn't churn the spec.
+ */
+function LegendColorRow({
+	label,
+	color,
+	isOverridden,
+	onChange,
+	onReset,
+}: LegendColorRowProps): JSX.Element {
+	return (
+		<div className={styles.row}>
+			<ColorPicker
+				value={color}
+				size="small"
+				showText={false}
+				trigger="click"
+				onChangeComplete={(next): void => onChange(next.toHexString())}
+			>
+				<button
+					type="button"
+					className={styles.trigger}
+					data-testid={`legend-color-${label}`}
+				>
+					<span className={styles.swatch} style={{ backgroundColor: color }} />
+					<Typography.Text className={styles.label} title={label}>
+						{label}
+					</Typography.Text>
+				</button>
+			</ColorPicker>
+			{isOverridden && (
+				<button
+					type="button"
+					className={styles.reset}
+					onClick={onReset}
+					data-testid={`legend-color-reset-${label}`}
+				>
+					Reset
+				</button>
+			)}
+		</div>
+	);
+}
+
+export default LegendColorRow;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/LegendColors.module.scss

@@ -0,0 +1,61 @@
+.container {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}
+
+.list {
+	width: 100%;
+}
+
+.row {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	min-width: 0;
+	height: 34px;
+}
+
+.trigger {
+	display: flex;
+	flex: 1;
+	align-items: center;
+	gap: 10px;
+	min-width: 0;
+	padding: 0;
+	border: none;
+	background: transparent;
+	cursor: pointer;
+	text-align: left;
+}
+
+.swatch {
+	width: 18px;
+	height: 18px;
+	flex: none;
+	border: 1px solid var(--l2-border);
+	border-radius: 4px;
+}
+
+.label {
+	overflow: hidden;
+	font-size: 12px;
+	color: var(--l2-foreground);
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.reset {
+	flex: none;
+	padding: 0;
+	border: none;
+	background: transparent;
+	color: var(--bg-robin-400);
+	font-size: 12px;
+	cursor: pointer;
+}
+
+.empty {
+	font-size: 12px;
+	color: var(--text-vanilla-400);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/LegendColors.tsx

@@ -0,0 +1,83 @@
+import { useState } from 'react';
+import { Search } from '@signozhq/icons';
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import type { DashboardtypesLegendDTOCustomColors } from 'api/generated/services/sigNoz.schemas';
+import { Virtuoso } from 'react-virtuoso';
+
+import type { LegendSeries } from '../../../hooks/useLegendSeries';
+import LegendColorRow from './LegendColorRow';
+import {
+	clearSeriesColor,
+	filterLegendSeries,
+	resolveSeriesColor,
+	setSeriesColor,
+} from './legendColors.utils';
+
+import styles from './LegendColors.module.scss';
+
+interface LegendColorsProps {
+	/** Panel's resolved series (from the shared preview query). */
+	series: LegendSeries[];
+	value: DashboardtypesLegendDTOCustomColors | undefined;
+	onChange: (next: Record<string, string>) => void;
+}
+
+/**
+ * Per-series color overrides for the legend: a searchable, virtualized list of the
+ * panel's resolved series, each with an antd ColorPicker swatch. Picking a color writes
+ * `{ [seriesLabel]: hex }` into `legend.customColors` — the same label the chart keys its
+ * color lookup on; Reset drops the override. Virtualized so panels with hundreds of
+ * series stay responsive. Until the query produces series, shows a hint.
+ */
+function LegendColors({
+	series,
+	value,
+	onChange,
+}: LegendColorsProps): JSX.Element {
+	const [query, setQuery] = useState('');
+
+	if (series.length === 0) {
+		return (
+			<Typography.Text className={styles.empty}>
+				Run the panel to customise series colors.
+			</Typography.Text>
+		);
+	}
+
+	const filtered = filterLegendSeries(series, query);
+
+	return (
+		<div className={styles.container} data-testid="panel-editor-v2-legend-colors">
+			<Input
+				data-testid="panel-editor-v2-legend-search"
+				placeholder="Search series…"
+				value={query}
+				prefix={<Search size={14} />}
+				onChange={(e): void => setQuery(e.target.value)}
+			/>
+			{filtered.length === 0 ? (
+				<Typography.Text className={styles.empty}>
+					No series match “{query}”.
+				</Typography.Text>
+			) : (
+				<Virtuoso
+					className={styles.list}
+					style={{ height: Math.min(filtered.length * 34, 240) }}
+					data={filtered}
+					itemContent={(_, s): JSX.Element => (
+						<LegendColorRow
+							label={s.label}
+							color={resolveSeriesColor(value, s.label, s.defaultColor)}
+							isOverridden={value?.[s.label] !== undefined}
+							onChange={(hex): void => onChange(setSeriesColor(value, s.label, hex))}
+							onReset={(): void => onChange(clearSeriesColor(value, s.label))}
+						/>
+					)}
+				/>
+			)}
+		</div>
+	);
+}
+
+export default LegendColors;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/__tests__/LegendColors.test.tsx

@@ -0,0 +1,42 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+
+import type { LegendSeries } from '../../../../hooks/useLegendSeries';
+import LegendColors from '../LegendColors';
+
+const SERIES: LegendSeries[] = [
+	{ label: 'frontend', defaultColor: '#ff0000' },
+	{ label: 'cartservice', defaultColor: '#00ff00' },
+];
+
+describe('LegendColors', () => {
+	it('shows a hint when there are no resolved series', () => {
+		render(<LegendColors series={[]} value={undefined} onChange={jest.fn()} />);
+
+		expect(
+			screen.queryByTestId('panel-editor-v2-legend-colors'),
+		).not.toBeInTheDocument();
+		expect(screen.getByText(/run the panel/i)).toBeInTheDocument();
+	});
+
+	it('renders the search box once series are present', () => {
+		render(
+			<LegendColors series={SERIES} value={undefined} onChange={jest.fn()} />,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-legend-search'),
+		).toBeInTheDocument();
+	});
+
+	it('shows a no-match message when the search filters everything out', () => {
+		render(
+			<LegendColors series={SERIES} value={undefined} onChange={jest.fn()} />,
+		);
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-legend-search'), {
+			target: { value: 'zzz' },
+		});
+
+		expect(screen.getByText(/no series match/i)).toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/__tests__/legendColors.utils.test.ts

@@ -0,0 +1,63 @@
+import type { LegendSeries } from '../../../../hooks/useLegendSeries';
+import {
+	clearSeriesColor,
+	filterLegendSeries,
+	resolveSeriesColor,
+	setSeriesColor,
+} from '../legendColors.utils';
+
+const SERIES: LegendSeries[] = [
+	{ label: 'frontend', defaultColor: '#ff0000' },
+	{ label: 'cartservice', defaultColor: '#00ff00' },
+	{ label: 'frontendproxy', defaultColor: '#0000ff' },
+];
+
+describe('legendColors.utils', () => {
+	describe('filterLegendSeries', () => {
+		it('returns all series for an empty/whitespace query', () => {
+			expect(filterLegendSeries(SERIES, '')).toHaveLength(3);
+			expect(filterLegendSeries(SERIES, '   ')).toHaveLength(3);
+		});
+
+		it('matches case-insensitive substrings', () => {
+			expect(
+				filterLegendSeries(SERIES, 'FRONT').map((s) => s.label),
+			).toStrictEqual(['frontend', 'frontendproxy']);
+			expect(filterLegendSeries(SERIES, 'cart')).toHaveLength(1);
+			expect(filterLegendSeries(SERIES, 'zzz')).toHaveLength(0);
+		});
+	});
+
+	describe('resolveSeriesColor', () => {
+		it('prefers the override, falling back to the default', () => {
+			expect(resolveSeriesColor({ frontend: '#111' }, 'frontend', '#ff0000')).toBe(
+				'#111',
+			);
+			expect(resolveSeriesColor(undefined, 'frontend', '#ff0000')).toBe('#ff0000');
+			expect(resolveSeriesColor(null, 'frontend', '#ff0000')).toBe('#ff0000');
+		});
+	});
+
+	describe('setSeriesColor', () => {
+		it('adds/overwrites a label without mutating the input', () => {
+			const value = { frontend: '#111' };
+			const next = setSeriesColor(value, 'cartservice', '#222');
+			expect(next).toStrictEqual({ frontend: '#111', cartservice: '#222' });
+			expect(value).toStrictEqual({ frontend: '#111' });
+		});
+
+		it('handles null/undefined base', () => {
+			expect(setSeriesColor(undefined, 'a', '#1')).toStrictEqual({ a: '#1' });
+			expect(setSeriesColor(null, 'a', '#1')).toStrictEqual({ a: '#1' });
+		});
+	});
+
+	describe('clearSeriesColor', () => {
+		it('removes a label without mutating the input', () => {
+			const value = { frontend: '#111', cartservice: '#222' };
+			const next = clearSeriesColor(value, 'frontend');
+			expect(next).toStrictEqual({ cartservice: '#222' });
+			expect(value).toStrictEqual({ frontend: '#111', cartservice: '#222' });
+		});
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/LegendColors/legendColors.utils.ts

@@ -0,0 +1,43 @@
+import type { DashboardtypesLegendDTOCustomColors } from 'api/generated/services/sigNoz.schemas';
+
+import type { LegendSeries } from '../../../hooks/useLegendSeries';
+
+/** Case-insensitive substring filter over series labels. Empty query → all series. */
+export function filterLegendSeries(
+	series: LegendSeries[],
+	query: string,
+): LegendSeries[] {
+	const q = query.trim().toLowerCase();
+	if (!q) {
+		return series;
+	}
+	return series.filter((s) => s.label.toLowerCase().includes(q));
+}
+
+/** The effective color for a series: the override if set, else its auto color. */
+export function resolveSeriesColor(
+	value: DashboardtypesLegendDTOCustomColors | undefined,
+	label: string,
+	defaultColor: string,
+): string {
+	return value?.[label] ?? defaultColor;
+}
+
+/** Set an override for `label`, returning a new customColors record. */
+export function setSeriesColor(
+	value: DashboardtypesLegendDTOCustomColors | undefined,
+	label: string,
+	hex: string,
+): Record<string, string> {
+	return { ...value, [label]: hex };
+}
+
+/** Drop the override for `label` (revert to the auto color), returning a new record. */
+export function clearSeriesColor(
+	value: DashboardtypesLegendDTOCustomColors | undefined,
+	label: string,
+): Record<string, string> {
+	const next = { ...value };
+	delete next[label];
+	return next;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/controls/segmentIcons.tsx

@@ -0,0 +1,145 @@
+/**
+ * Small glyph icons for the panel-editor segmented/select controls, ported from the
+ * Configure-panel design. They render at 14px and inherit `currentColor` so the
+ * surrounding control can dim them when unselected and brighten them when active.
+ */
+export type SegmentIconName =
+	| 'solid-line'
+	| 'dashed-line'
+	| 'fill-none'
+	| 'fill-solid'
+	| 'fill-gradient'
+	| 'pos-bottom'
+	| 'pos-right'
+	| 'scale-linear'
+	| 'scale-log'
+	| 'interp-linear'
+	| 'interp-spline'
+	| 'interp-step-before'
+	| 'interp-step-after';
+
+function Svg({ children }: { children: React.ReactNode }): JSX.Element {
+	return (
+		<svg
+			width={14}
+			height={14}
+			viewBox="0 0 16 16"
+			fill="none"
+			stroke="currentColor"
+			strokeWidth={1.5}
+			strokeLinecap="round"
+			strokeLinejoin="round"
+			style={{ flex: 'none' }}
+			aria-hidden
+		>
+			{children}
+		</svg>
+	);
+}
+
+const FILLED = { fill: 'currentColor', stroke: 'none' } as const;
+
+export function SegmentIcon({
+	name,
+}: {
+	name: SegmentIconName;
+}): JSX.Element | null {
+	switch (name) {
+		case 'solid-line':
+			return (
+				<Svg>
+					<path d="M2 8 H14" />
+				</Svg>
+			);
+		case 'dashed-line':
+			return (
+				<Svg>
+					<path d="M2 8 H4.5" />
+					<path d="M6.75 8 H9.25" />
+					<path d="M11.5 8 H14" />
+				</Svg>
+			);
+		case 'fill-none':
+			return (
+				<Svg>
+					<path d="M2 11 L6 6 L10 9 L14 5" />
+				</Svg>
+			);
+		case 'fill-solid':
+			return (
+				<Svg>
+					<path
+						d="M2 10.5 L6 5.5 L10 8.5 L14 4.5 V13.5 H2 Z"
+						fill="currentColor"
+						fillOpacity={0.85}
+						stroke="none"
+					/>
+					<path d="M2 10.5 L6 5.5 L10 8.5 L14 4.5" />
+				</Svg>
+			);
+		case 'fill-gradient':
+			return (
+				<Svg>
+					<path
+						d="M2 10.5 L6 5.5 L10 8.5 L14 4.5 V13.5 H2 Z"
+						fill="currentColor"
+						fillOpacity={0.3}
+						stroke="none"
+					/>
+					<path d="M2 10.5 L6 5.5 L10 8.5 L14 4.5" />
+				</Svg>
+			);
+		case 'pos-bottom':
+			return (
+				<Svg>
+					<rect x={2} y={2.5} width={12} height={9} rx={1.2} />
+					<rect x={2} y={9} width={12} height={2.5} {...FILLED} />
+				</Svg>
+			);
+		case 'pos-right':
+			return (
+				<Svg>
+					<rect x={2} y={2.5} width={12} height={9} rx={1.2} />
+					<rect x={10.5} y={2.5} width={3.5} height={9} {...FILLED} />
+				</Svg>
+			);
+		case 'scale-linear':
+			return (
+				<Svg>
+					<path d="M2.5 13 L13.5 3" />
+				</Svg>
+			);
+		case 'scale-log':
+			return (
+				<Svg>
+					<path d="M2.5 13 C5 13, 8 4.5, 13.5 3" />
+				</Svg>
+			);
+		case 'interp-linear':
+			return (
+				<Svg>
+					<path d="M2 12 L6 5 L10 9 L14 4" />
+				</Svg>
+			);
+		case 'interp-spline':
+			return (
+				<Svg>
+					<path d="M2 12 C5 3, 9 3, 14 8" />
+				</Svg>
+			);
+		case 'interp-step-before':
+			return (
+				<Svg>
+					<path d="M2 6 H6 V10 H10 V4.5 H14" />
+				</Svg>
+			);
+		case 'interp-step-after':
+			return (
+				<Svg>
+					<path d="M2 10 H6 V5 H10 V9.5 H14" />
+				</Svg>
+			);
+		default:
+			return null;
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sectionRegistry.tsx

@@ -0,0 +1,176 @@
+import type { ComponentType } from 'react';
+import type {
+	DashboardLinkDTO,
+	DashboardtypesAxesDTO,
+	DashboardtypesBarChartVisualizationDTO,
+	DashboardtypesHistogramBucketsDTO,
+	DashboardtypesLegendDTO,
+	DashboardtypesPanelSpecDTO,
+	DashboardtypesTimeSeriesChartAppearanceDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type {
+	AnyThreshold,
+	PanelFormattingSlice,
+	SectionEditorProps,
+	SectionKind,
+	SectionSpecMap,
+} from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import AxesSection from './sections/AxesSection/AxesSection';
+import BucketsSection from './sections/BucketsSection/BucketsSection';
+import ChartAppearanceSection from './sections/ChartAppearanceSection/ChartAppearanceSection';
+import ContextLinksSection from './sections/ContextLinksSection/ContextLinksSection';
+import FormattingSection from './sections/FormattingSection/FormattingSection';
+import LegendSection from './sections/LegendSection/LegendSection';
+import ThresholdsSection from './sections/ThresholdsSection/ThresholdsSection';
+import VisualizationSection from './sections/VisualizationSection/VisualizationSection';
+
+type PanelSpec = DashboardtypesPanelSpecDTO;
+
+/**
+ * Pairs a section kind with its editor component and a typed lens into the panel spec.
+ * The lens reads/writes over the WHOLE panel spec, so a section can target either the
+ * plugin spec (`spec.plugin.spec.<key>`) or a panel-level field (e.g. `spec.links`).
+ */
+export interface SectionDescriptor<K extends SectionKind> {
+	Component: ComponentType<SectionEditorProps<K>>;
+	read: (spec: PanelSpec) => SectionSpecMap[K] | undefined;
+	write: (spec: PanelSpec, value: SectionSpecMap[K]) => PanelSpec;
+}
+
+// The plugin spec is a discriminated union over panel kinds; reading/writing a shared
+// slice (formatting, axes, …) by key is the one place the union must be narrowed. The
+// helper concentrates that cast so the registry entries stay declarative.
+type PluginSpecSlice = Partial<Record<string, unknown>>;
+
+function readPluginSlice<T>(spec: PanelSpec, key: string): T | undefined {
+	return (spec.plugin?.spec as PluginSpecSlice | undefined)?.[key] as
+		| T
+		| undefined;
+}
+
+function writePluginSlice(
+	spec: PanelSpec,
+	key: string,
+	value: unknown,
+): PanelSpec {
+	return {
+		...spec,
+		plugin: {
+			...spec.plugin,
+			spec: { ...(spec.plugin?.spec as PluginSpecSlice), [key]: value },
+		},
+	} as PanelSpec;
+}
+
+/**
+ * Registry of section editors. Partial by design: only sections with a built editor
+ * appear here, so ConfigPane renders exactly those and silently skips the rest. Adding
+ * a section editor = one entry here + one component file.
+ */
+export const SECTION_REGISTRY: {
+	[K in SectionKind]?: SectionDescriptor<K>;
+} = {
+	formatting: {
+		Component: FormattingSection,
+		read: (spec): PanelFormattingSlice | undefined =>
+			readPluginSlice<PanelFormattingSlice>(spec, 'formatting'),
+		write: (spec, formatting): PanelSpec =>
+			writePluginSlice(spec, 'formatting', formatting),
+	},
+	axes: {
+		Component: AxesSection,
+		read: (spec): DashboardtypesAxesDTO | undefined =>
+			readPluginSlice<DashboardtypesAxesDTO>(spec, 'axes'),
+		write: (spec, axes): PanelSpec => writePluginSlice(spec, 'axes', axes),
+	},
+	legend: {
+		Component: LegendSection,
+		read: (spec): DashboardtypesLegendDTO | undefined =>
+			readPluginSlice<DashboardtypesLegendDTO>(spec, 'legend'),
+		write: (spec, legend): PanelSpec => writePluginSlice(spec, 'legend', legend),
+	},
+	chartAppearance: {
+		Component: ChartAppearanceSection,
+		read: (spec): DashboardtypesTimeSeriesChartAppearanceDTO | undefined =>
+			readPluginSlice<DashboardtypesTimeSeriesChartAppearanceDTO>(
+				spec,
+				'chartAppearance',
+			),
+		write: (spec, chartAppearance): PanelSpec =>
+			writePluginSlice(spec, 'chartAppearance', chartAppearance),
+	},
+	visualization: {
+		Component: VisualizationSection,
+		read: (spec): DashboardtypesBarChartVisualizationDTO | undefined =>
+			readPluginSlice<DashboardtypesBarChartVisualizationDTO>(
+				spec,
+				'visualization',
+			),
+		write: (spec, visualization): PanelSpec =>
+			writePluginSlice(spec, 'visualization', visualization),
+	},
+	buckets: {
+		Component: BucketsSection,
+		read: (spec): DashboardtypesHistogramBucketsDTO | undefined =>
+			readPluginSlice<DashboardtypesHistogramBucketsDTO>(spec, 'histogramBuckets'),
+		write: (spec, buckets): PanelSpec =>
+			writePluginSlice(spec, 'histogramBuckets', buckets),
+	},
+	contextLinks: {
+		Component: ContextLinksSection,
+		// Panel-level slice (spec.links), not under the plugin spec — no cast needed.
+		read: (spec): DashboardLinkDTO[] | undefined => spec.links,
+		write: (spec, links): PanelSpec => ({ ...spec, links }),
+	},
+	// One editor for every threshold variant (label / comparison / table); the kind's
+	// `controls.variant` picks the row editor + element shape. All persist to the same
+	// plugin.spec.thresholds key.
+	thresholds: {
+		Component: ThresholdsSection,
+		read: (spec): AnyThreshold[] | undefined =>
+			readPluginSlice<AnyThreshold[]>(spec, 'thresholds'),
+		write: (spec, thresholds): PanelSpec =>
+			writePluginSlice(spec, 'thresholds', thresholds),
+	},
+};
+
+/**
+ * A section descriptor with the kind correlation erased. `SECTION_REGISTRY[kind]` and a
+ * `SectionConfig` are both unions keyed by the same `kind`, but TS can't prove the lookup
+ * and the config refer to the same member — the classic correlated-union limitation. The
+ * resolver below narrows once here (the single localized cast), so render sites compose
+ * `read` → `Component` → `write` without any further casts.
+ */
+export interface ErasedSectionDescriptor {
+	Component: ComponentType<{
+		value: unknown;
+		controls?: unknown;
+		onChange: (next: unknown) => void;
+		// Forwarded to every editor; only sections that need the panel's resolved series
+		// (legend colors) read it. Optional so editors can ignore it.
+		legendSeries?: unknown;
+		// The panel's formatting unit; read by editors that scope to it (thresholds).
+		yAxisUnit?: unknown;
+		// The Table panel's resolved value columns; read by the table-only editors
+		// (column units, per-column thresholds) to offer real columns.
+		tableColumns?: unknown;
+		// The panel's telemetry signal; read by editors that fetch field-key
+		// suggestions scoped to it (List column picker).
+		signal?: unknown;
+		// Current panel kind + switch handler; read by the visualization section's
+		// type switcher.
+		panelKind?: unknown;
+		onChangePanelKind?: unknown;
+	}>;
+	read: (spec: PanelSpec) => unknown;
+	write: (spec: PanelSpec, value: unknown) => PanelSpec;
+}
+
+export function resolveSectionEditor(
+	kind: SectionKind,
+): ErasedSectionDescriptor | undefined {
+	return SECTION_REGISTRY[kind] as unknown as
+		| ErasedSectionDescriptor
+		| undefined;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/AxesSection/AxesSection.module.scss

@@ -0,0 +1,11 @@
+.bounds {
+	display: flex;
+	gap: 8px;
+}
+
+.field {
+	display: flex;
+	flex: 1;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/AxesSection/AxesSection.tsx

@@ -0,0 +1,80 @@
+import type { ChangeEvent } from 'react';
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import ConfigSegmented from '../../controls/ConfigSegmented/ConfigSegmented';
+
+import styles from './AxesSection.module.scss';
+
+type SoftBound = 'softMin' | 'softMax';
+
+const SCALE_OPTIONS = [
+	{ value: 'linear', label: 'Linear', icon: 'scale-linear' as const },
+	{ value: 'log', label: 'Log', icon: 'scale-log' as const },
+];
+
+/**
+ * Edits the `axes` slice of a panel spec: soft Y-axis min/max bounds and the
+ * linear/logarithmic scale toggle. Each control is gated by its `controls` flag.
+ */
+function AxesSection({
+	value,
+	controls,
+	onChange,
+}: SectionEditorProps<'axes'>): JSX.Element {
+	// An empty field clears the bound (null); otherwise parse to a number, ignoring
+	// transient non-numeric input (e.g. a lone "-") by leaving the bound unset.
+	const handleBound =
+		(bound: SoftBound) =>
+		(e: ChangeEvent<HTMLInputElement>): void => {
+			const raw = e.target.value;
+			const next = raw === '' || Number.isNaN(Number(raw)) ? null : Number(raw);
+			onChange({ ...value, [bound]: next });
+		};
+
+	return (
+		<>
+			{controls.minMax && (
+				<div className={styles.bounds}>
+					<div className={styles.field}>
+						<Typography.Text>Soft min</Typography.Text>
+						<Input
+							data-testid="panel-editor-v2-soft-min"
+							type="number"
+							placeholder="Auto"
+							value={value?.softMin ?? ''}
+							onChange={handleBound('softMin')}
+						/>
+					</div>
+					<div className={styles.field}>
+						<Typography.Text>Soft max</Typography.Text>
+						<Input
+							data-testid="panel-editor-v2-soft-max"
+							type="number"
+							placeholder="Auto"
+							value={value?.softMax ?? ''}
+							onChange={handleBound('softMax')}
+						/>
+					</div>
+				</div>
+			)}
+
+			{controls.logScale && (
+				<div className={styles.field}>
+					<Typography.Text>Y-axis scale</Typography.Text>
+					<ConfigSegmented
+						testId="panel-editor-v2-log-scale"
+						value={value?.isLogScale ? 'log' : 'linear'}
+						items={SCALE_OPTIONS}
+						onChange={(next): void =>
+							onChange({ ...value, isLogScale: next === 'log' })
+						}
+					/>
+				</div>
+			)}
+		</>
+	);
+}
+
+export default AxesSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/AxesSection/__tests__/AxesSection.test.tsx

@@ -0,0 +1,83 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+
+import AxesSection from '../AxesSection';
+
+describe('AxesSection', () => {
+	it('renders soft bounds and the log-scale switch when both controls are enabled', () => {
+		render(
+			<AxesSection
+				value={undefined}
+				controls={{ minMax: true, logScale: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(screen.getByTestId('panel-editor-v2-soft-min')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-soft-max')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-log-scale')).toBeInTheDocument();
+	});
+
+	it('hides the soft bounds when minMax is off', () => {
+		render(
+			<AxesSection
+				value={undefined}
+				controls={{ logScale: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.queryByTestId('panel-editor-v2-soft-min'),
+		).not.toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-log-scale')).toBeInTheDocument();
+	});
+
+	it('writes a numeric soft min through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<AxesSection
+				value={undefined}
+				controls={{ minMax: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-soft-min'), {
+			target: { value: '5' },
+		});
+
+		expect(onChange).toHaveBeenCalledWith({ softMin: 5 });
+	});
+
+	it('clears a soft bound to null when the field is emptied', () => {
+		const onChange = jest.fn();
+		render(
+			<AxesSection
+				value={{ softMax: 100 }}
+				controls={{ minMax: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-soft-max'), {
+			target: { value: '' },
+		});
+
+		expect(onChange).toHaveBeenCalledWith({ softMax: null });
+	});
+
+	it('toggles the logarithmic scale through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<AxesSection
+				value={{ isLogScale: false }}
+				controls={{ logScale: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByText('Log'));
+
+		expect(onChange).toHaveBeenCalledWith({ isLogScale: true });
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/BucketsSection/BucketsSection.module.scss

@@ -0,0 +1,5 @@
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/BucketsSection/BucketsSection.tsx

@@ -0,0 +1,75 @@
+import type { ChangeEvent } from 'react';
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import ConfigSwitch from '../../controls/ConfigSwitch/ConfigSwitch';
+
+import styles from './BucketsSection.module.scss';
+
+type NumericBound = 'bucketCount' | 'bucketWidth';
+
+/**
+ * Edits the `histogramBuckets` slice of a Histogram panel spec: bucket count / width
+ * and whether to merge all active queries into one set of buckets. Each control is gated
+ * by its `controls` flag.
+ */
+function BucketsSection({
+	value,
+	controls,
+	onChange,
+}: SectionEditorProps<'buckets'>): JSX.Element {
+	// Empty clears the bound to null (chart auto-sizes); otherwise parse to a number,
+	// ignoring transient non-numeric input by leaving it unset.
+	const handleNumber =
+		(bound: NumericBound) =>
+		(e: ChangeEvent<HTMLInputElement>): void => {
+			const raw = e.target.value;
+			const next = raw === '' || Number.isNaN(Number(raw)) ? null : Number(raw);
+			onChange({ ...value, [bound]: next });
+		};
+
+	return (
+		<>
+			{controls.count && (
+				<div className={styles.field}>
+					<Typography.Text>Bucket count</Typography.Text>
+					<Input
+						data-testid="panel-editor-v2-bucket-count"
+						type="number"
+						placeholder="Auto"
+						value={value?.bucketCount ?? ''}
+						onChange={handleNumber('bucketCount')}
+					/>
+				</div>
+			)}
+
+			{controls.width && (
+				<div className={styles.field}>
+					<Typography.Text>Bucket width</Typography.Text>
+					<Input
+						data-testid="panel-editor-v2-bucket-width"
+						type="number"
+						placeholder="Auto"
+						value={value?.bucketWidth ?? ''}
+						onChange={handleNumber('bucketWidth')}
+					/>
+				</div>
+			)}
+
+			{controls.mergeQueries && (
+				<ConfigSwitch
+					testId="panel-editor-v2-merge-queries"
+					title="Merge active queries"
+					description="Bucket all active queries together into one distribution"
+					value={value?.mergeAllActiveQueries ?? false}
+					onChange={(checked): void =>
+						onChange({ ...value, mergeAllActiveQueries: checked })
+					}
+				/>
+			)}
+		</>
+	);
+}
+
+export default BucketsSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/BucketsSection/__tests__/BucketsSection.test.tsx

@@ -0,0 +1,68 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+
+import BucketsSection from '../BucketsSection';
+
+describe('BucketsSection', () => {
+	it('renders only the controls whose flag is set', () => {
+		render(
+			<BucketsSection
+				value={undefined}
+				controls={{ count: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-bucket-count'),
+		).toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-bucket-width'),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-merge-queries'),
+		).not.toBeInTheDocument();
+	});
+
+	it('writes a numeric bucket count and clears it to null when emptied', () => {
+		const onChange = jest.fn();
+		const { rerender } = render(
+			<BucketsSection
+				value={undefined}
+				controls={{ count: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-bucket-count'), {
+			target: { value: '20' },
+		});
+		expect(onChange).toHaveBeenLastCalledWith({ bucketCount: 20 });
+
+		rerender(
+			<BucketsSection
+				value={{ bucketCount: 20 }}
+				controls={{ count: true }}
+				onChange={onChange}
+			/>,
+		);
+		fireEvent.change(screen.getByTestId('panel-editor-v2-bucket-count'), {
+			target: { value: '' },
+		});
+		expect(onChange).toHaveBeenLastCalledWith({ bucketCount: null });
+	});
+
+	it('toggles merge-active-queries through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<BucketsSection
+				value={{ mergeAllActiveQueries: false }}
+				controls={{ mergeQueries: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-merge-queries'));
+
+		expect(onChange).toHaveBeenCalledWith({ mergeAllActiveQueries: true });
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.module.scss

@@ -0,0 +1,5 @@
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/ChartAppearanceSection.tsx

@@ -0,0 +1,164 @@
+import type { ChangeEvent } from 'react';
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import {
+	DashboardtypesFillModeDTO,
+	DashboardtypesLineInterpolationDTO,
+	DashboardtypesLineStyleDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import ConfigSegmented from '../../controls/ConfigSegmented/ConfigSegmented';
+import ConfigSelect from '../../controls/ConfigSelect/ConfigSelect';
+import ConfigSwitch from '../../controls/ConfigSwitch/ConfigSwitch';
+
+import styles from './ChartAppearanceSection.module.scss';
+
+const LINE_STYLE_OPTIONS = [
+	{
+		value: DashboardtypesLineStyleDTO.solid,
+		label: 'Solid',
+		icon: 'solid-line' as const,
+	},
+	{
+		value: DashboardtypesLineStyleDTO.dashed,
+		label: 'Dashed',
+		icon: 'dashed-line' as const,
+	},
+];
+
+const LINE_INTERPOLATION_OPTIONS = [
+	{
+		value: DashboardtypesLineInterpolationDTO.linear,
+		label: 'Linear',
+		icon: 'interp-linear' as const,
+	},
+	{
+		value: DashboardtypesLineInterpolationDTO.spline,
+		label: 'Spline',
+		icon: 'interp-spline' as const,
+	},
+	{
+		value: DashboardtypesLineInterpolationDTO.step_before,
+		label: 'Step before',
+		icon: 'interp-step-before' as const,
+	},
+	{
+		value: DashboardtypesLineInterpolationDTO.step_after,
+		label: 'Step after',
+		icon: 'interp-step-after' as const,
+	},
+];
+
+const FILL_MODE_OPTIONS = [
+	{
+		value: DashboardtypesFillModeDTO.none,
+		label: 'None',
+		icon: 'fill-none' as const,
+	},
+	{
+		value: DashboardtypesFillModeDTO.solid,
+		label: 'Solid',
+		icon: 'fill-solid' as const,
+	},
+	{
+		value: DashboardtypesFillModeDTO.gradient,
+		label: 'Gradient',
+		icon: 'fill-gradient' as const,
+	},
+];
+
+/**
+ * Edits the `chartAppearance` slice of a TimeSeries panel spec: line style /
+ * interpolation, fill mode, point markers, and the connect-null-gaps threshold. Each
+ * control is gated by its `controls` flag.
+ */
+function ChartAppearanceSection({
+	value,
+	controls,
+	onChange,
+}: SectionEditorProps<'chartAppearance'>): JSX.Element {
+	// `spanGaps.fillLessThan` is a stringified seconds threshold: empty means "connect
+	// every gap" (the chart default), a number means "only bridge gaps shorter than this".
+	const handleSpanGaps = (e: ChangeEvent<HTMLInputElement>): void => {
+		const raw = e.target.value;
+		onChange({
+			...value,
+			spanGaps: raw === '' ? undefined : { ...value?.spanGaps, fillLessThan: raw },
+		});
+	};
+	return (
+		<>
+			{controls.lineStyle && (
+				<div className={styles.field}>
+					<Typography.Text>Line style</Typography.Text>
+					<ConfigSegmented
+						testId="panel-editor-v2-line-style"
+						value={value?.lineStyle}
+						items={LINE_STYLE_OPTIONS}
+						onChange={(next): void =>
+							onChange({ ...value, lineStyle: next as DashboardtypesLineStyleDTO })
+						}
+					/>
+				</div>
+			)}
+
+			{controls.lineInterpolation && (
+				<div className={styles.field}>
+					<Typography.Text>Line interpolation</Typography.Text>
+					<ConfigSelect
+						testId="panel-editor-v2-line-interpolation"
+						placeholder="Select interpolation…"
+						value={value?.lineInterpolation}
+						items={LINE_INTERPOLATION_OPTIONS}
+						onChange={(next): void =>
+							onChange({
+								...value,
+								lineInterpolation: next as DashboardtypesLineInterpolationDTO,
+							})
+						}
+					/>
+				</div>
+			)}
+
+			{controls.fillMode && (
+				<div className={styles.field}>
+					<Typography.Text>Fill mode</Typography.Text>
+					<ConfigSegmented
+						testId="panel-editor-v2-fill-mode"
+						value={value?.fillMode}
+						items={FILL_MODE_OPTIONS}
+						onChange={(next): void =>
+							onChange({ ...value, fillMode: next as DashboardtypesFillModeDTO })
+						}
+					/>
+				</div>
+			)}
+
+			{controls.showPoints && (
+				<ConfigSwitch
+					testId="panel-editor-v2-show-points"
+					title="Show points"
+					description="Display individual data points on the chart"
+					value={value?.showPoints ?? false}
+					onChange={(checked): void => onChange({ ...value, showPoints: checked })}
+				/>
+			)}
+
+			{controls.spanGaps && (
+				<div className={styles.field}>
+					<Typography.Text>Connect gaps shorter than (s)</Typography.Text>
+					<Input
+						data-testid="panel-editor-v2-span-gaps"
+						type="number"
+						placeholder="All gaps"
+						value={value?.spanGaps?.fillLessThan ?? ''}
+						onChange={handleSpanGaps}
+					/>
+				</div>
+			)}
+		</>
+	);
+}
+
+export default ChartAppearanceSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ChartAppearanceSection/__tests__/ChartAppearanceSection.test.tsx

@@ -0,0 +1,140 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { DashboardtypesLineStyleDTO } from 'api/generated/services/sigNoz.schemas';
+
+import ChartAppearanceSection from '../ChartAppearanceSection';
+
+// Open the antd Select by clicking its selector, then pick the option by label. The
+// line-style and fill-mode controls are ConfigSegmented (buttons), so this helper is
+// only used for the line-interpolation ConfigSelect.
+async function pickOption(triggerTestId: string, label: string): Promise<void> {
+	const user = userEvent.setup();
+	const trigger = screen.getByTestId(triggerTestId);
+	await user.click(trigger.querySelector('.ant-select-selector') as HTMLElement);
+	await user.click(await screen.findByRole('option', { name: label }));
+}
+
+const ALL_CONTROLS = {
+	lineStyle: true,
+	lineInterpolation: true,
+	fillMode: true,
+	showPoints: true,
+	spanGaps: true,
+};
+
+describe('ChartAppearanceSection', () => {
+	it('renders every control that is enabled', () => {
+		render(
+			<ChartAppearanceSection
+				value={undefined}
+				controls={ALL_CONTROLS}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(screen.getByTestId('panel-editor-v2-line-style')).toBeInTheDocument();
+		expect(
+			screen.getByTestId('panel-editor-v2-line-interpolation'),
+		).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-fill-mode')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-show-points')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-span-gaps')).toBeInTheDocument();
+	});
+
+	it('renders only the controls whose flag is set', () => {
+		render(
+			<ChartAppearanceSection
+				value={undefined}
+				controls={{ lineStyle: true, fillMode: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(screen.getByTestId('panel-editor-v2-line-style')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-fill-mode')).toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-line-interpolation'),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-show-points'),
+		).not.toBeInTheDocument();
+	});
+
+	it('writes the chosen fill mode through the segmented control', () => {
+		const onChange = jest.fn();
+		render(
+			<ChartAppearanceSection
+				value={{ lineStyle: DashboardtypesLineStyleDTO.solid }}
+				controls={{ fillMode: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByText('Gradient'));
+
+		expect(onChange).toHaveBeenCalledWith({
+			lineStyle: 'solid',
+			fillMode: 'gradient',
+		});
+	});
+
+	it('writes the chosen line interpolation through the dropdown', async () => {
+		const onChange = jest.fn();
+		render(
+			<ChartAppearanceSection
+				value={undefined}
+				controls={{ lineInterpolation: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		await pickOption('panel-editor-v2-line-interpolation', 'Spline');
+
+		expect(onChange).toHaveBeenCalledWith({ lineInterpolation: 'spline' });
+	});
+
+	it('toggles show points through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<ChartAppearanceSection
+				value={{ showPoints: false }}
+				controls={{ showPoints: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-show-points'));
+
+		expect(onChange).toHaveBeenCalledWith({ showPoints: true });
+	});
+
+	it('writes a span-gaps threshold and clears it when emptied', () => {
+		const onChange = jest.fn();
+		const { rerender } = render(
+			<ChartAppearanceSection
+				value={undefined}
+				controls={{ spanGaps: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.change(screen.getByTestId('panel-editor-v2-span-gaps'), {
+			target: { value: '60' },
+		});
+		expect(onChange).toHaveBeenLastCalledWith({
+			spanGaps: { fillLessThan: '60' },
+		});
+
+		rerender(
+			<ChartAppearanceSection
+				value={{ spanGaps: { fillLessThan: '60' } }}
+				controls={{ spanGaps: true }}
+				onChange={onChange}
+			/>,
+		);
+		fireEvent.change(screen.getByTestId('panel-editor-v2-span-gaps'), {
+			target: { value: '' },
+		});
+		expect(onChange).toHaveBeenLastCalledWith({ spanGaps: undefined });
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/ContextLinksSection.module.scss

@@ -0,0 +1,32 @@
+.list {
+	display: flex;
+	flex-direction: column;
+	gap: 12px;
+}
+
+.row {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+	padding: 10px;
+	border: 1px solid var(--l2-border);
+	border-radius: 6px;
+}
+
+.rowFooter {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+}
+
+.newTab {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	cursor: pointer;
+}
+
+.newTabLabel {
+	font-size: 12px;
+	color: var(--text-vanilla-400);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/ContextLinksSection.tsx

@@ -0,0 +1,94 @@
+import { Plus, Trash2 } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import { Switch } from '@signozhq/ui/switch';
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import styles from './ContextLinksSection.module.scss';
+
+/**
+ * Edits the panel's context links (`spec.links`): a list of label + URL rows with an
+ * "open in new tab" toggle, plus add/remove. Atomic section — no per-kind sub-controls.
+ * URLs may reference dashboard/query variables; that interpolation is resolved at render
+ * time, so this editor just captures the raw strings.
+ */
+function ContextLinksSection({
+	value,
+	onChange,
+}: SectionEditorProps<'contextLinks'>): JSX.Element {
+	const links = value ?? [];
+
+	const updateAt = (index: number, patch: Partial<DashboardLinkDTO>): void =>
+		onChange(
+			links.map((link, i) => (i === index ? { ...link, ...patch } : link)),
+		);
+
+	const addLink = (): void =>
+		onChange([...links, { name: '', url: '', targetBlank: true }]);
+
+	const removeAt = (index: number): void =>
+		onChange(links.filter((_, i) => i !== index));
+
+	return (
+		<div className={styles.list}>
+			{links.map((link, index) => (
+				// Links have no stable id on the wire; index is the row identity here.
+				// eslint-disable-next-line react/no-array-index-key
+				<div className={styles.row} key={index}>
+					<Input
+						data-testid={`context-link-label-${index}`}
+						placeholder="Label"
+						value={link.name ?? ''}
+						onChange={(e): void => updateAt(index, { name: e.target.value })}
+					/>
+					<Input
+						data-testid={`context-link-url-${index}`}
+						placeholder="https://… or /path?var=$variable"
+						value={link.url ?? ''}
+						onChange={(e): void => updateAt(index, { url: e.target.value })}
+					/>
+					<div className={styles.rowFooter}>
+						<div className={styles.newTab}>
+							<Switch
+								testId={`context-link-newtab-${index}`}
+								value={link.targetBlank ?? false}
+								onChange={(checked: boolean): void =>
+									updateAt(index, { targetBlank: checked })
+								}
+							/>
+							<Typography.Text className={styles.newTabLabel}>
+								Open in new tab
+							</Typography.Text>
+						</div>
+						<Button
+							type="button"
+							variant="ghost"
+							color="destructive"
+							size="icon"
+							aria-label={`Remove link ${index + 1}`}
+							data-testid={`context-link-remove-${index}`}
+							onClick={(): void => removeAt(index)}
+						>
+							<Trash2 size={14} />
+						</Button>
+					</div>
+				</div>
+			))}
+
+			<Button
+				type="button"
+				variant="dashed"
+				color="secondary"
+				prefix={<Plus size={14} />}
+				data-testid="panel-editor-v2-add-link"
+				onClick={addLink}
+			>
+				Add link
+			</Button>
+		</div>
+	);
+}
+
+export default ContextLinksSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ContextLinksSection/__tests__/ContextLinksSection.test.tsx

@@ -0,0 +1,54 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { DashboardLinkDTO } from 'api/generated/services/sigNoz.schemas';
+
+import ContextLinksSection from '../ContextLinksSection';
+
+const LINKS: DashboardLinkDTO[] = [
+	{ name: 'Docs', url: 'https://signoz.io', targetBlank: true },
+];
+
+describe('ContextLinksSection', () => {
+	it('renders only the add button when there are no links', () => {
+		render(<ContextLinksSection value={undefined} onChange={jest.fn()} />);
+
+		expect(screen.getByTestId('panel-editor-v2-add-link')).toBeInTheDocument();
+		expect(screen.queryByTestId('context-link-label-0')).not.toBeInTheDocument();
+	});
+
+	it('appends a blank link (open-in-new-tab on) when Add link is clicked', () => {
+		const onChange = jest.fn();
+		render(<ContextLinksSection value={[]} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-add-link'));
+
+		expect(onChange).toHaveBeenCalledWith([
+			{ name: '', url: '', targetBlank: true },
+		]);
+	});
+
+	it('renders existing links and edits a label through onChange', () => {
+		const onChange = jest.fn();
+		render(<ContextLinksSection value={LINKS} onChange={onChange} />);
+
+		expect(screen.getByTestId('context-link-label-0')).toHaveValue('Docs');
+		expect(screen.getByTestId('context-link-url-0')).toHaveValue(
+			'https://signoz.io',
+		);
+
+		fireEvent.change(screen.getByTestId('context-link-label-0'), {
+			target: { value: 'Runbook' },
+		});
+		expect(onChange).toHaveBeenCalledWith([
+			{ name: 'Runbook', url: 'https://signoz.io', targetBlank: true },
+		]);
+	});
+
+	it('removes a link through onChange', () => {
+		const onChange = jest.fn();
+		render(<ContextLinksSection value={LINKS} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('context-link-remove-0'));
+
+		expect(onChange).toHaveBeenCalledWith([]);
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/ColumnUnits.tsx

@@ -0,0 +1,65 @@
+import { Typography } from '@signozhq/ui/typography';
+import YAxisUnitSelector from 'components/YAxisUnitSelector';
+import { YAxisSource } from 'components/YAxisUnitSelector/types';
+
+import type { TableColumnOption } from '../../../hooks/useTableColumns';
+
+import styles from './FormattingSection.module.scss';
+
+interface ColumnUnitsProps {
+	/** Resolved value columns of the panel's current table result. */
+	columns: TableColumnOption[];
+	/** Current per-column unit map (`formatting.columnUnits`), keyed by column key. */
+	value: Record<string, string>;
+	onChange: (next: Record<string, string>) => void;
+}
+
+/**
+ * Per-column unit picker for Table panels: one unit selector per resolved value
+ * column, writing `{ [columnKey]: unitId }` keyed by the query identifier (V1
+ * parity). Clearing a column's unit drops its entry. Until the panel produces
+ * columns, shows a hint.
+ */
+function ColumnUnits({
+	columns,
+	value,
+	onChange,
+}: ColumnUnitsProps): JSX.Element {
+	if (columns.length === 0) {
+		return (
+			<Typography.Text className={styles.columnUnitsHint}>
+				Run the panel to set per-column units.
+			</Typography.Text>
+		);
+	}
+
+	const setUnit = (columnKey: string, unit: string | undefined): void => {
+		const next = { ...value };
+		if (unit) {
+			next[columnKey] = unit;
+		} else {
+			delete next[columnKey];
+		}
+		onChange(next);
+	};
+
+	return (
+		<div className={styles.columnUnits}>
+			{columns.map((column) => (
+				<div className={styles.columnField} key={column.key}>
+					<Typography.Text>{column.label}</Typography.Text>
+					<YAxisUnitSelector
+						data-testid={`panel-editor-v2-column-unit-${column.key}`}
+						placeholder="Select unit"
+						source={YAxisSource.DASHBOARDS}
+						value={value[column.key]}
+						containerClassName={styles.columnUnitSelector}
+						onChange={(unit): void => setUnit(column.key, unit)}
+					/>
+				</div>
+			))}
+		</div>
+	);
+}
+
+export default ColumnUnits;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/FormattingSection.module.scss

@@ -0,0 +1,37 @@
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}
+
+.unitSelector {
+	:global(.ant-select) {
+		width: 100%;
+	}
+}
+
+// Stacked per-column unit pickers; each column keeps the standard field layout.
+.columnUnits {
+	display: flex;
+	flex-direction: column;
+	gap: 12px;
+
+	:global(.ant-select) {
+		width: 100%;
+	}
+}
+
+.columnUnitsHint {
+	font-size: 12px;
+	color: var(--l2-foreground);
+}
+
+.columnField {
+	display: flex;
+	flex-direction: row;
+	align-items: center;
+	gap: 16px;
+}
+.columnUnitSelector {
+	flex: 1;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/FormattingSection.tsx

@@ -0,0 +1,89 @@
+import { Typography } from '@signozhq/ui/typography';
+import { DashboardtypesPrecisionOptionDTO } from 'api/generated/services/sigNoz.schemas';
+import YAxisUnitSelector from 'components/YAxisUnitSelector';
+import { YAxisSource } from 'components/YAxisUnitSelector/types';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import type { TableColumnOption } from '../../../hooks/useTableColumns';
+import ConfigSelect from '../../controls/ConfigSelect/ConfigSelect';
+import ColumnUnits from './ColumnUnits';
+
+import styles from './FormattingSection.module.scss';
+
+type FormattingSectionProps = SectionEditorProps<'formatting'> & {
+	/** Table panel's resolved value columns; required for the column-units editor. */
+	tableColumns?: TableColumnOption[];
+};
+
+// `full` means "show the raw value, no rounding"; the digits round to that many places.
+const DECIMAL_OPTIONS: {
+	value: DashboardtypesPrecisionOptionDTO;
+	label: string;
+}[] = [
+	{ value: DashboardtypesPrecisionOptionDTO.NUMBER_0, label: '0 decimals' },
+	{ value: DashboardtypesPrecisionOptionDTO.NUMBER_1, label: '1 decimal' },
+	{ value: DashboardtypesPrecisionOptionDTO.NUMBER_2, label: '2 decimals' },
+	{ value: DashboardtypesPrecisionOptionDTO.NUMBER_3, label: '3 decimals' },
+	{ value: DashboardtypesPrecisionOptionDTO.NUMBER_4, label: '4 decimals' },
+	{ value: DashboardtypesPrecisionOptionDTO.full, label: 'Full' },
+];
+
+/**
+ * Edits the `formatting` slice of a panel spec (unit + decimal precision). Which
+ * controls show is driven by the per-kind `controls` flags; the spec slice itself
+ * is uniform across every kind that declares the Formatting section.
+ */
+function FormattingSection({
+	value,
+	controls,
+	onChange,
+	tableColumns = [],
+}: FormattingSectionProps): JSX.Element {
+	return (
+		<>
+			{controls.unit && (
+				<div className={styles.field}>
+					<Typography.Text>Unit</Typography.Text>
+					<YAxisUnitSelector
+						containerClassName={styles.unitSelector}
+						data-testid="panel-editor-v2-unit"
+						source={YAxisSource.DASHBOARDS}
+						value={value?.unit}
+						onChange={(unit): void => onChange({ ...value, unit })}
+					/>
+				</div>
+			)}
+
+			{controls.decimals && (
+				<div className={styles.field}>
+					<Typography.Text>Decimals</Typography.Text>
+					<ConfigSelect
+						testId="panel-editor-v2-decimals"
+						placeholder="Select decimals…"
+						value={value?.decimalPrecision}
+						items={DECIMAL_OPTIONS}
+						onChange={(next): void =>
+							onChange({
+								...value,
+								decimalPrecision: next as DashboardtypesPrecisionOptionDTO,
+							})
+						}
+					/>
+				</div>
+			)}
+
+			{controls.columnUnits && (
+				<div className={styles.field}>
+					<Typography.Text>Column units</Typography.Text>
+					<ColumnUnits
+						columns={tableColumns}
+						value={value?.columnUnits ?? {}}
+						onChange={(columnUnits): void => onChange({ ...value, columnUnits })}
+					/>
+				</div>
+			)}
+		</>
+	);
+}
+
+export default FormattingSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/FormattingSection/__tests__/FormattingSection.test.tsx

@@ -0,0 +1,74 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import FormattingSection from '../FormattingSection';
+
+// Open the Decimals select (clicking its antd selector) and pick the option with the
+// given visible label.
+async function pickDecimal(label: string): Promise<void> {
+	const user = userEvent.setup();
+	const trigger = screen.getByTestId('panel-editor-v2-decimals');
+	await user.click(trigger.querySelector('.ant-select-selector') as HTMLElement);
+	await user.click(await screen.findByRole('option', { name: label }));
+}
+
+describe('FormattingSection', () => {
+	it('renders Unit and Decimals when both controls are enabled', () => {
+		render(
+			<FormattingSection
+				value={undefined}
+				controls={{ unit: true, decimals: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(screen.getByTestId('panel-editor-v2-unit')).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-decimals')).toBeInTheDocument();
+	});
+
+	it('hides a control when its flag is off', () => {
+		render(
+			<FormattingSection
+				value={undefined}
+				controls={{ decimals: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(screen.queryByTestId('panel-editor-v2-unit')).not.toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-decimals')).toBeInTheDocument();
+	});
+
+	it('writes the chosen decimal precision through onChange', async () => {
+		const onChange = jest.fn();
+		render(
+			<FormattingSection
+				value={undefined}
+				controls={{ decimals: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		await pickDecimal('Full');
+
+		expect(onChange).toHaveBeenCalledWith({ decimalPrecision: 'full' });
+	});
+
+	it('merges the edit into the existing formatting slice', async () => {
+		const onChange = jest.fn();
+		render(
+			<FormattingSection
+				value={{ unit: 'bytes' }}
+				controls={{ decimals: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		await pickDecimal('2 decimals');
+
+		expect(onChange).toHaveBeenCalledWith({
+			unit: 'bytes',
+			decimalPrecision: '2',
+		});
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/LegendSection/LegendSection.module.scss

@@ -0,0 +1,5 @@
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/LegendSection/LegendSection.tsx

@@ -0,0 +1,73 @@
+import { Typography } from '@signozhq/ui/typography';
+import { DashboardtypesLegendPositionDTO } from 'api/generated/services/sigNoz.schemas';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import ConfigSegmented from '../../controls/ConfigSegmented/ConfigSegmented';
+import LegendColors from '../../controls/LegendColors/LegendColors';
+import type { LegendSeries } from '../../../hooks/useLegendSeries';
+
+import styles from './LegendSection.module.scss';
+
+type LegendSectionProps = SectionEditorProps<'legend'> & {
+	/** Panel's resolved series, forwarded by SectionSlot for the colors control. */
+	legendSeries?: LegendSeries[];
+};
+
+const POSITION_OPTIONS = [
+	{
+		value: DashboardtypesLegendPositionDTO.bottom,
+		label: 'Bottom',
+		icon: 'pos-bottom' as const,
+	},
+	{
+		value: DashboardtypesLegendPositionDTO.right,
+		label: 'Right',
+		icon: 'pos-right' as const,
+	},
+];
+
+/**
+ * Edits the `legend` slice of a panel spec: legend position and per-series color
+ * overrides. The colors control reads the panel's resolved series from context (the
+ * shared preview query) and writes `customColors` keyed by series label.
+ */
+function LegendSection({
+	value,
+	controls,
+	onChange,
+	legendSeries,
+}: LegendSectionProps): JSX.Element {
+	return (
+		<>
+			{controls.position && (
+				<div className={styles.field}>
+					<Typography.Text>Position</Typography.Text>
+					<ConfigSegmented
+						testId="panel-editor-v2-legend-position"
+						items={POSITION_OPTIONS}
+						value={value?.position}
+						onChange={(next): void =>
+							onChange({
+								...value,
+								position: next as DashboardtypesLegendPositionDTO,
+							})
+						}
+					/>
+				</div>
+			)}
+
+			{controls.colors && (
+				<div className={styles.field}>
+					<Typography.Text>Series colors</Typography.Text>
+					<LegendColors
+						series={legendSeries ?? []}
+						value={value?.customColors}
+						onChange={(customColors): void => onChange({ ...value, customColors })}
+					/>
+				</div>
+			)}
+		</>
+	);
+}
+
+export default LegendSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/LegendSection/__tests__/LegendSection.test.tsx

@@ -0,0 +1,68 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { DashboardtypesLegendPositionDTO } from 'api/generated/services/sigNoz.schemas';
+
+import LegendSection from '../LegendSection';
+
+describe('LegendSection', () => {
+	it('renders the position toggle with both options when position is enabled', () => {
+		render(
+			<LegendSection
+				value={undefined}
+				controls={{ position: true }}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-legend-position'),
+		).toBeInTheDocument();
+		expect(screen.getByText('Bottom')).toBeInTheDocument();
+		expect(screen.getByText('Right')).toBeInTheDocument();
+	});
+
+	it('renders nothing when position is not enabled', () => {
+		render(
+			<LegendSection value={undefined} controls={{}} onChange={jest.fn()} />,
+		);
+
+		expect(
+			screen.queryByTestId('panel-editor-v2-legend-position'),
+		).not.toBeInTheDocument();
+	});
+
+	it('writes the chosen position through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<LegendSection
+				value={{ position: undefined }}
+				controls={{ position: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByText('Right'));
+
+		expect(onChange).toHaveBeenCalledWith({ position: 'right' });
+	});
+
+	it('preserves other legend fields when changing position', () => {
+		const onChange = jest.fn();
+		render(
+			<LegendSection
+				value={{
+					position: DashboardtypesLegendPositionDTO.bottom,
+					customColors: { a: '#fff' },
+				}}
+				controls={{ position: true }}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByText('Right'));
+
+		expect(onChange).toHaveBeenCalledWith({
+			position: 'right',
+			customColors: { a: '#fff' },
+		});
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdColorSelect.tsx

@@ -0,0 +1,50 @@
+import { ChevronDown } from '@signozhq/icons';
+import { ColorPicker } from 'antd';
+
+import styles from './ThresholdsSection.module.scss';
+
+interface ThresholdColorSelectProps {
+	value: string;
+	testId?: string;
+	onChange: (hex: string) => void;
+}
+
+// Named presets from the SigNoz palette (cherry / amber / forest / robin). They surface
+// as quick swatches in the picker; the full picker below covers any custom color.
+const PRESETS: { label: string; value: string }[] = [
+	{ label: 'Red', value: '#F1575F' },
+	{ label: 'Orange', value: '#F5B225' },
+	{ label: 'Green', value: '#2BB673' },
+	{ label: 'Blue', value: '#4E74F8' },
+];
+
+/**
+ * Threshold color control: an antd ColorPicker with the palette presets plus a full
+ * custom picker, in a single popover (so moving from the trigger into the picker never
+ * dismisses it). The trigger shows the current swatch and its preset name, or "Custom".
+ */
+function ThresholdColorSelect({
+	value,
+	testId,
+	onChange,
+}: ThresholdColorSelectProps): JSX.Element {
+	const current = PRESETS.find(
+		(p) => p.value.toLowerCase() === value?.toLowerCase(),
+	);
+
+	return (
+		<ColorPicker
+			value={value}
+			onChangeComplete={(c): void => onChange(c.toHexString())}
+			presets={[{ label: 'Defaults', colors: PRESETS.map((p) => p.value) }]}
+		>
+			<button type="button" className={styles.colorTrigger} data-testid={testId}>
+				<span className={styles.dot} style={{ backgroundColor: value }} />
+				<span className={styles.colorLabel}>{current?.label ?? 'Custom'}</span>
+				<ChevronDown size={13} />
+			</button>
+		</ColorPicker>
+	);
+}
+
+export default ThresholdColorSelect;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.module.scss

@@ -0,0 +1,104 @@
+.list {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}
+
+// ── View mode: compact summary row ──────────────────────────────────────────
+.viewRow {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	height: 40px;
+	padding: 0 4px 0 10px;
+	border: 1px solid var(--l2-border);
+	background-color: var(--l2-background);
+	border-radius: 6px;
+}
+
+.viewValue {
+	flex: none;
+	font-size: 13px;
+	font-weight: 500;
+	color: var(--text-vanilla-100);
+}
+
+.viewLabel {
+	overflow: hidden;
+	font-size: 12px;
+	color: var(--text-vanilla-400);
+	white-space: nowrap;
+	text-overflow: ellipsis;
+}
+
+.spacer {
+	flex: 1;
+}
+
+// ── Edit mode: labelled form ────────────────────────────────────────────────
+.editRow {
+	display: flex;
+	flex-direction: column;
+	gap: 12px;
+	padding: 12px;
+	background-color: var(--l2-background);
+	border: 1px solid var(--bg-robin-400);
+	border-radius: 6px;
+}
+
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 6px;
+}
+
+.fieldLabel {
+	font-size: 12px;
+	color: var(--text-vanilla-400);
+}
+
+.actions {
+	display: flex;
+	justify-content: flex-end;
+	gap: 8px;
+}
+
+// ── Shared ──────────────────────────────────────────────────────────────────
+.dot {
+	width: 12px;
+	height: 12px;
+	flex: none;
+	border-radius: 50%;
+}
+
+.colorTrigger {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	width: 100%;
+	height: 36px;
+	padding: 0 10px;
+	border: 1px solid var(--l2-border);
+	border-radius: 4px;
+	background: transparent;
+	color: var(--text-vanilla-100);
+	cursor: pointer;
+}
+
+.colorLabel {
+	flex: 1;
+	font-size: 13px;
+	text-align: left;
+}
+
+// Match Formatting: make the YAxisUnitSelector fill the row width.
+.unitSelector {
+	:global(.ant-select) {
+		width: 100%;
+	}
+}
+
+.invalidUnit {
+	font-size: 11px;
+	color: var(--bg-cherry-400);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/ThresholdsSection.tsx

@@ -0,0 +1,181 @@
+import { useState } from 'react';
+import { Plus } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import {
+	DashboardtypesComparisonOperatorDTO,
+	type DashboardtypesComparisonThresholdDTO,
+	type DashboardtypesTableThresholdDTO,
+	DashboardtypesThresholdFormatDTO,
+	type DashboardtypesThresholdWithLabelDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type {
+	AnyThreshold,
+	ThresholdVariant,
+} from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import type { TableColumnOption } from '../../../hooks/useTableColumns';
+import ComparisonThresholdRow from './rows/ComparisonThresholdRow';
+import LabelThresholdRow from './rows/LabelThresholdRow';
+import TableThresholdRow from './rows/TableThresholdRow';
+
+import styles from './ThresholdsSection.module.scss';
+
+// New thresholds default to red (the first palette preset); the user recolors per rule.
+const DEFAULT_THRESHOLD_COLOR = '#F1575F';
+
+// Add-button testId per variant — kept stable so existing E2E/unit selectors hold.
+const ADD_TESTID: Record<ThresholdVariant, string> = {
+	label: 'panel-editor-v2-add-threshold',
+	comparison: 'panel-editor-v2-add-comparison-threshold',
+	table: 'panel-editor-v2-add-table-threshold',
+};
+
+// Seed for a freshly-added row, in the shape the variant's editor + spec expect.
+function defaultThreshold(
+	variant: ThresholdVariant,
+	tableColumns: TableColumnOption[],
+): AnyThreshold {
+	switch (variant) {
+		case 'comparison':
+			return {
+				value: 0,
+				color: DEFAULT_THRESHOLD_COLOR,
+				operator: DashboardtypesComparisonOperatorDTO.above,
+				format: DashboardtypesThresholdFormatDTO.text,
+			};
+		case 'table':
+			return {
+				columnName: tableColumns[0]?.key ?? '',
+				value: 0,
+				color: DEFAULT_THRESHOLD_COLOR,
+				operator: DashboardtypesComparisonOperatorDTO.above,
+				format: DashboardtypesThresholdFormatDTO.background,
+			};
+		default:
+			return { value: 0, color: DEFAULT_THRESHOLD_COLOR, label: '' };
+	}
+}
+
+type ThresholdsSectionProps = {
+	value: AnyThreshold[] | undefined;
+	/** `variant` picks the row editor + element shape; defaults to `label`. */
+	controls?: { variant?: ThresholdVariant };
+	onChange: (next: AnyThreshold[]) => void;
+	/** Panel formatting unit; scopes each row's unit picker to its category (V1 parity). */
+	yAxisUnit?: string;
+	/** Table panel's resolved value columns (table variant only). */
+	tableColumns?: TableColumnOption[];
+};
+
+/**
+ * Edits the `thresholds` slice for every panel kind. All variants share the same
+ * list mechanics (one row edits at a time; a freshly-added row opens in edit mode and
+ * is removed if discarded before saving) and differ only in the row editor, picked by
+ * `controls.variant`: `label` (TimeSeries/Bar), `comparison` (Number), `table` (Table).
+ */
+function ThresholdsSection({
+	value,
+	controls,
+	onChange,
+	yAxisUnit,
+	tableColumns = [],
+}: ThresholdsSectionProps): JSX.Element {
+	const variant = controls?.variant ?? 'label';
+	const thresholds = value ?? [];
+	// Which row is being edited, and whether it was just added (so Discard removes it).
+	const [editingIndex, setEditingIndex] = useState<number | null>(null);
+	const [unsavedIndex, setUnsavedIndex] = useState<number | null>(null);
+
+	const addThreshold = (): void => {
+		const nextIndex = thresholds.length;
+		onChange([...thresholds, defaultThreshold(variant, tableColumns)]);
+		setEditingIndex(nextIndex);
+		setUnsavedIndex(nextIndex);
+	};
+
+	const saveAt =
+		(index: number) =>
+		(next: AnyThreshold): void => {
+			onChange(thresholds.map((t, i) => (i === index ? next : t)));
+			setEditingIndex(null);
+			setUnsavedIndex(null);
+		};
+
+	const removeAt = (index: number): void => {
+		onChange(thresholds.filter((_, i) => i !== index));
+		setEditingIndex(null);
+		setUnsavedIndex(null);
+	};
+
+	const discardAt = (index: number) => (): void => {
+		// Discarding a row that was never saved removes it; otherwise just exit edit.
+		if (index === unsavedIndex) {
+			removeAt(index);
+			return;
+		}
+		setEditingIndex(null);
+	};
+
+	const renderRow = (threshold: AnyThreshold, index: number): JSX.Element => {
+		// Shared row controls; the threshold value is narrowed per variant at this
+		// branch boundary — the slice only ever holds the active variant's shape.
+		const common = {
+			index,
+			yAxisUnit,
+			isEditing: editingIndex === index,
+			onEdit: (): void => setEditingIndex(index),
+			onSave: saveAt(index),
+			onDiscard: discardAt(index),
+			onRemove: (): void => removeAt(index),
+		};
+
+		if (variant === 'comparison') {
+			return (
+				<ComparisonThresholdRow
+					// eslint-disable-next-line react/no-array-index-key
+					key={index}
+					threshold={threshold as DashboardtypesComparisonThresholdDTO}
+					{...common}
+				/>
+			);
+		}
+		if (variant === 'table') {
+			return (
+				<TableThresholdRow
+					// eslint-disable-next-line react/no-array-index-key
+					key={index}
+					threshold={threshold as DashboardtypesTableThresholdDTO}
+					tableColumns={tableColumns}
+					{...common}
+				/>
+			);
+		}
+		return (
+			<LabelThresholdRow
+				// eslint-disable-next-line react/no-array-index-key
+				key={index}
+				threshold={threshold as DashboardtypesThresholdWithLabelDTO}
+				{...common}
+			/>
+		);
+	};
+
+	return (
+		<div className={styles.list}>
+			{thresholds.map(renderRow)}
+
+			<Button
+				type="button"
+				variant="dashed"
+				color="secondary"
+				prefix={<Plus size={14} />}
+				data-testid={ADD_TESTID[variant]}
+				onClick={addThreshold}
+			>
+				Add threshold
+			</Button>
+		</div>
+	);
+}
+
+export default ThresholdsSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.comparison.test.tsx

@@ -0,0 +1,198 @@
+import { useState } from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import {
+	DashboardtypesComparisonOperatorDTO,
+	type DashboardtypesComparisonThresholdDTO,
+	DashboardtypesThresholdFormatDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { AnyThreshold } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import UnifiedThresholdsSection from '../ThresholdsSection';
+
+// The comparison editor is the unified ThresholdsSection in its `comparison` variant;
+// this wrapper pins the variant so the suite reads as the comparison editor's spec.
+function ComparisonThresholdsSection(props: {
+	value: DashboardtypesComparisonThresholdDTO[] | undefined;
+	onChange: (next: DashboardtypesComparisonThresholdDTO[]) => void;
+	yAxisUnit?: string;
+}): JSX.Element {
+	return (
+		<UnifiedThresholdsSection
+			value={props.value}
+			onChange={props.onChange as (next: AnyThreshold[]) => void}
+			yAxisUnit={props.yAxisUnit}
+			controls={{ variant: 'comparison' }}
+		/>
+	);
+}
+
+const THRESHOLDS: DashboardtypesComparisonThresholdDTO[] = [
+	{
+		value: 80,
+		color: '#F5B225',
+		operator: DashboardtypesComparisonOperatorDTO.above,
+		unit: 'percent',
+		format: DashboardtypesThresholdFormatDTO.background,
+	},
+];
+
+// Stateful harness for flows that depend on the value updating (add/discard).
+function Harness({ yAxisUnit }: { yAxisUnit?: string }): JSX.Element {
+	const [value, setValue] = useState<DashboardtypesComparisonThresholdDTO[]>([]);
+	return (
+		<ComparisonThresholdsSection
+			value={value}
+			onChange={setValue}
+			yAxisUnit={yAxisUnit}
+		/>
+	);
+}
+
+describe('ComparisonThresholdsSection', () => {
+	it('renders only the add button when there are no thresholds', () => {
+		render(
+			<ComparisonThresholdsSection value={undefined} onChange={jest.fn()} />,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-add-comparison-threshold'),
+		).toBeInTheDocument();
+		expect(
+			screen.queryByTestId('comparison-threshold-edit-0'),
+		).not.toBeInTheDocument();
+	});
+
+	it('shows an existing threshold in view mode (no form until Edit)', () => {
+		render(
+			<ComparisonThresholdsSection value={THRESHOLDS} onChange={jest.fn()} />,
+		);
+
+		expect(screen.getByTestId('comparison-threshold-edit-0')).toBeInTheDocument();
+		// Operator symbol + value render in the summary.
+		expect(screen.getByText(/> 80/)).toBeInTheDocument();
+		// The editable fields are hidden until the row is edited.
+		expect(
+			screen.queryByTestId('comparison-threshold-value-0'),
+		).not.toBeInTheDocument();
+	});
+
+	it('formats the view-mode value through its unit (e.g. currency symbol)', () => {
+		render(
+			<ComparisonThresholdsSection
+				value={[
+					{
+						value: 3100,
+						color: '#F5B225',
+						operator: DashboardtypesComparisonOperatorDTO.below,
+						unit: 'currencyUSD',
+					},
+				]}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		const row = screen.getByTestId('comparison-threshold-edit-0').closest('div');
+		// Unit-aware: shows the currency symbol, never the raw unit id.
+		expect(row).toHaveTextContent('$');
+		expect(row).not.toHaveTextContent('currencyUSD');
+	});
+
+	it('edits a threshold value and commits it on Save', () => {
+		const onChange = jest.fn();
+		render(
+			<ComparisonThresholdsSection value={THRESHOLDS} onChange={onChange} />,
+		);
+
+		fireEvent.click(screen.getByTestId('comparison-threshold-edit-0'));
+		expect(screen.getByTestId('comparison-threshold-value-0')).toHaveValue(80);
+
+		fireEvent.change(screen.getByTestId('comparison-threshold-value-0'), {
+			target: { value: '90' },
+		});
+		fireEvent.click(screen.getByTestId('comparison-threshold-save-0'));
+
+		expect(onChange).toHaveBeenCalledWith([
+			{
+				value: 90,
+				color: '#F5B225',
+				operator: DashboardtypesComparisonOperatorDTO.above,
+				unit: 'percent',
+				format: DashboardtypesThresholdFormatDTO.background,
+			},
+		]);
+	});
+
+	it('does not commit edits when Discard is clicked', () => {
+		const onChange = jest.fn();
+		render(
+			<ComparisonThresholdsSection value={THRESHOLDS} onChange={onChange} />,
+		);
+
+		fireEvent.click(screen.getByTestId('comparison-threshold-edit-0'));
+		fireEvent.change(screen.getByTestId('comparison-threshold-value-0'), {
+			target: { value: '90' },
+		});
+		fireEvent.click(screen.getByTestId('comparison-threshold-discard-0'));
+
+		expect(onChange).not.toHaveBeenCalled();
+		// Back to view mode.
+		expect(
+			screen.queryByTestId('comparison-threshold-value-0'),
+		).not.toBeInTheDocument();
+		expect(screen.getByTestId('comparison-threshold-edit-0')).toBeInTheDocument();
+	});
+
+	it('removes a threshold from view mode', () => {
+		const onChange = jest.fn();
+		render(
+			<ComparisonThresholdsSection value={THRESHOLDS} onChange={onChange} />,
+		);
+
+		fireEvent.click(screen.getByTestId('comparison-threshold-remove-0'));
+
+		expect(onChange).toHaveBeenCalledWith([]);
+	});
+
+	it('adds a threshold that opens in edit mode, and discards it away', () => {
+		render(<Harness />);
+
+		fireEvent.click(
+			screen.getByTestId('panel-editor-v2-add-comparison-threshold'),
+		);
+		// New row opens in edit mode.
+		expect(
+			screen.getByTestId('comparison-threshold-value-0'),
+		).toBeInTheDocument();
+
+		fireEvent.click(screen.getByTestId('comparison-threshold-discard-0'));
+		// Discarding a never-saved row removes it entirely.
+		expect(
+			screen.queryByTestId('comparison-threshold-value-0'),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('comparison-threshold-edit-0'),
+		).not.toBeInTheDocument();
+	});
+
+	it('flags a threshold unit in a different category than the y-axis unit', () => {
+		render(
+			<ComparisonThresholdsSection
+				value={[
+					{
+						value: 80,
+						color: '#F5B225',
+						operator: DashboardtypesComparisonOperatorDTO.above,
+						unit: 'ms',
+					},
+				]}
+				yAxisUnit="bytes"
+				onChange={jest.fn()}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('comparison-threshold-edit-0'));
+		expect(
+			screen.getByTestId('comparison-threshold-unit-invalid-0'),
+		).toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/__tests__/ThresholdsSection.test.tsx

@@ -0,0 +1,134 @@
+import { useState } from 'react';
+import { fireEvent, render, screen } from '@testing-library/react';
+import type { DashboardtypesThresholdWithLabelDTO } from 'api/generated/services/sigNoz.schemas';
+import type { AnyThreshold } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import ThresholdsSection from '../ThresholdsSection';
+
+const THRESHOLDS: DashboardtypesThresholdWithLabelDTO[] = [
+	{ value: 80, color: '#F5B225', label: 'High', unit: 'percent' },
+];
+
+// Stateful harness for flows that depend on the value updating (add/discard);
+// omits `controls` to exercise the default `label` variant.
+function Harness({ yAxisUnit }: { yAxisUnit?: string }): JSX.Element {
+	const [value, setValue] = useState<AnyThreshold[]>([]);
+	return (
+		<ThresholdsSection value={value} onChange={setValue} yAxisUnit={yAxisUnit} />
+	);
+}
+
+describe('ThresholdsSection', () => {
+	it('renders only the add button when there are no thresholds', () => {
+		render(<ThresholdsSection value={undefined} onChange={jest.fn()} />);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-add-threshold'),
+		).toBeInTheDocument();
+		expect(screen.queryByTestId('threshold-edit-0')).not.toBeInTheDocument();
+	});
+
+	it('shows an existing threshold in view mode (no form until Edit)', () => {
+		render(<ThresholdsSection value={THRESHOLDS} onChange={jest.fn()} />);
+
+		expect(screen.getByTestId('threshold-edit-0')).toBeInTheDocument();
+		expect(screen.getByText('High')).toBeInTheDocument();
+		expect(screen.queryByTestId('threshold-value-0')).not.toBeInTheDocument();
+	});
+
+	it('edits a threshold value and commits it on Save', () => {
+		const onChange = jest.fn();
+		render(<ThresholdsSection value={THRESHOLDS} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('threshold-edit-0'));
+		expect(screen.getByTestId('threshold-value-0')).toHaveValue(80);
+
+		fireEvent.change(screen.getByTestId('threshold-value-0'), {
+			target: { value: '90' },
+		});
+		fireEvent.click(screen.getByTestId('threshold-save-0'));
+
+		expect(onChange).toHaveBeenCalledWith([
+			{ value: 90, color: '#F5B225', label: 'High', unit: 'percent' },
+		]);
+	});
+
+	it('persists an empty-string label when none is provided', () => {
+		const onChange = jest.fn();
+		// Label absent (e.g. a pre-existing spec); spec requires a string, so save
+		// must send '' not undefined.
+		const noLabel = [{ value: 50, color: '#F1575F' }] as AnyThreshold[];
+		render(<ThresholdsSection value={noLabel} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('threshold-edit-0'));
+		fireEvent.click(screen.getByTestId('threshold-save-0'));
+
+		expect(onChange).toHaveBeenCalledWith([
+			{ value: 50, color: '#F1575F', label: '' },
+		]);
+	});
+
+	it('does not commit edits when Discard is clicked', () => {
+		const onChange = jest.fn();
+		render(<ThresholdsSection value={THRESHOLDS} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('threshold-edit-0'));
+		fireEvent.change(screen.getByTestId('threshold-value-0'), {
+			target: { value: '90' },
+		});
+		fireEvent.click(screen.getByTestId('threshold-discard-0'));
+
+		expect(onChange).not.toHaveBeenCalled();
+		expect(screen.queryByTestId('threshold-value-0')).not.toBeInTheDocument();
+		expect(screen.getByTestId('threshold-edit-0')).toBeInTheDocument();
+	});
+
+	it('removes a threshold from view mode', () => {
+		const onChange = jest.fn();
+		render(<ThresholdsSection value={THRESHOLDS} onChange={onChange} />);
+
+		fireEvent.click(screen.getByTestId('threshold-remove-0'));
+
+		expect(onChange).toHaveBeenCalledWith([]);
+	});
+
+	it('adds a threshold that opens in edit mode, and discards it away', () => {
+		render(<Harness />);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-add-threshold'));
+		expect(screen.getByTestId('threshold-value-0')).toBeInTheDocument();
+
+		// Discarding a never-saved row removes it entirely.
+		fireEvent.click(screen.getByTestId('threshold-discard-0'));
+		expect(screen.queryByTestId('threshold-value-0')).not.toBeInTheDocument();
+		expect(screen.queryByTestId('threshold-edit-0')).not.toBeInTheDocument();
+	});
+
+	it('flags a threshold unit in a different category than the y-axis unit', () => {
+		render(
+			<ThresholdsSection
+				value={[{ value: 80, color: '#F5B225', label: '', unit: 'ms' }]}
+				yAxisUnit="bytes"
+				onChange={jest.fn()}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('threshold-edit-0'));
+		expect(screen.getByTestId('threshold-unit-invalid-0')).toBeInTheDocument();
+	});
+
+	it('does not flag a threshold unit in the same category as the y-axis unit', () => {
+		render(
+			<ThresholdsSection
+				value={[{ value: 80, color: '#F5B225', label: '', unit: 'ms' }]}
+				yAxisUnit="s"
+				onChange={jest.fn()}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('threshold-edit-0'));
+		expect(
+			screen.queryByTestId('threshold-unit-invalid-0'),
+		).not.toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/ComparisonThresholdRow.tsx

@@ -0,0 +1,117 @@
+import {
+	type DashboardtypesComparisonOperatorDTO,
+	type DashboardtypesComparisonThresholdDTO,
+	type DashboardtypesThresholdFormatDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { formatPanelValue } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/formatPanelValue';
+
+import {
+	FORMAT_OPTIONS,
+	OPERATOR_OPTIONS,
+	OPERATOR_SYMBOL,
+} from '../thresholdOptions';
+import ThresholdColorField from './shared/ThresholdColorField';
+import ThresholdRowShell from './shared/ThresholdRowShell';
+import ThresholdSelectField from './shared/ThresholdSelectField';
+import ThresholdUnitField from './shared/ThresholdUnitField';
+import { useThresholdDraft } from './shared/useThresholdDraft';
+import ThresholdValueField from './shared/ThresholdValueField';
+
+import styles from '../ThresholdsSection.module.scss';
+
+interface ComparisonThresholdRowProps {
+	index: number;
+	threshold: DashboardtypesComparisonThresholdDTO;
+	/** Panel formatting unit — scopes the unit picker to its category (V1 parity). */
+	yAxisUnit?: string;
+	isEditing: boolean;
+	onEdit: () => void;
+	onSave: (next: DashboardtypesComparisonThresholdDTO) => void;
+	onDiscard: () => void;
+	onRemove: () => void;
+}
+
+/**
+ * Comparison threshold (Number): value crosses an operator → recolor. Edit form is
+ * condition (operator), value, unit, color, display format.
+ */
+function ComparisonThresholdRow({
+	index,
+	threshold,
+	yAxisUnit,
+	isEditing,
+	onEdit,
+	onSave,
+	onDiscard,
+	onRemove,
+}: ComparisonThresholdRowProps): JSX.Element {
+	const { draft, setDraft, setValue } = useThresholdDraft(threshold, isEditing);
+
+	const symbol = threshold.operator ? OPERATOR_SYMBOL[threshold.operator] : '';
+	const summary = (
+		<span className={styles.viewValue}>
+			{symbol} {formatPanelValue(threshold.value, threshold.unit)}
+		</span>
+	);
+
+	return (
+		<ThresholdRowShell
+			index={index}
+			testIdPrefix="comparison-threshold"
+			color={threshold.color}
+			isEditing={isEditing}
+			summary={summary}
+			onEdit={onEdit}
+			onSave={(): void => onSave(draft)}
+			onDiscard={onDiscard}
+			onRemove={onRemove}
+		>
+			<ThresholdSelectField
+				label="If value is"
+				testId={`comparison-threshold-operator-${index}`}
+				placeholder="Select condition"
+				value={draft.operator}
+				items={OPERATOR_OPTIONS}
+				onChange={(operator): void =>
+					setDraft((d) => ({
+						...d,
+						operator: operator as DashboardtypesComparisonOperatorDTO,
+					}))
+				}
+			/>
+			<ThresholdValueField
+				testId={`comparison-threshold-value-${index}`}
+				value={draft.value}
+				onChange={setValue}
+			/>
+			<ThresholdUnitField
+				testId={`comparison-threshold-unit-${index}`}
+				invalidTestId={`comparison-threshold-unit-invalid-${index}`}
+				value={draft.unit}
+				scopeUnit={yAxisUnit}
+				scopeLabel="y-axis unit"
+				onChange={(unit): void => setDraft((d) => ({ ...d, unit }))}
+			/>
+			<ThresholdColorField
+				testId={`comparison-threshold-color-${index}`}
+				value={draft.color}
+				onChange={(color): void => setDraft((d) => ({ ...d, color }))}
+			/>
+			<ThresholdSelectField
+				label="Display"
+				testId={`comparison-threshold-format-${index}`}
+				placeholder="Select display"
+				value={draft.format}
+				items={FORMAT_OPTIONS}
+				onChange={(format): void =>
+					setDraft((d) => ({
+						...d,
+						format: format as DashboardtypesThresholdFormatDTO,
+					}))
+				}
+			/>
+		</ThresholdRowShell>
+	);
+}
+
+export default ComparisonThresholdRow;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/LabelThresholdRow.tsx

@@ -0,0 +1,93 @@
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+import type { DashboardtypesThresholdWithLabelDTO } from 'api/generated/services/sigNoz.schemas';
+import { formatPanelValue } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/formatPanelValue';
+
+import ThresholdColorField from './shared/ThresholdColorField';
+import ThresholdRowShell from './shared/ThresholdRowShell';
+import ThresholdUnitField from './shared/ThresholdUnitField';
+import { useThresholdDraft } from './shared/useThresholdDraft';
+import ThresholdValueField from './shared/ThresholdValueField';
+
+import styles from '../ThresholdsSection.module.scss';
+
+interface LabelThresholdRowProps {
+	index: number;
+	threshold: DashboardtypesThresholdWithLabelDTO;
+	/** Panel formatting unit — scopes the unit picker to its category (V1 parity). */
+	yAxisUnit?: string;
+	isEditing: boolean;
+	onEdit: () => void;
+	onSave: (next: DashboardtypesThresholdWithLabelDTO) => void;
+	onDiscard: () => void;
+	onRemove: () => void;
+}
+
+/** Value + color + label threshold (TimeSeries / Bar): a line drawn on the chart. */
+function LabelThresholdRow({
+	index,
+	threshold,
+	yAxisUnit,
+	isEditing,
+	onEdit,
+	onSave,
+	onDiscard,
+	onRemove,
+}: LabelThresholdRowProps): JSX.Element {
+	const { draft, setDraft, setValue } = useThresholdDraft(threshold, isEditing);
+
+	const summary = (
+		<>
+			<span className={styles.viewValue}>
+				{formatPanelValue(threshold.value, threshold.unit)}
+			</span>
+			{threshold.label && (
+				<span className={styles.viewLabel}>{threshold.label}</span>
+			)}
+		</>
+	);
+
+	return (
+		<ThresholdRowShell
+			index={index}
+			testIdPrefix="threshold"
+			color={threshold.color}
+			isEditing={isEditing}
+			summary={summary}
+			onEdit={onEdit}
+			onSave={(): void => onSave({ ...draft, label: draft.label ?? '' })}
+			onDiscard={onDiscard}
+			onRemove={onRemove}
+		>
+			<ThresholdColorField
+				testId={`threshold-color-${index}`}
+				value={draft.color}
+				onChange={(color): void => setDraft((d) => ({ ...d, color }))}
+			/>
+			<ThresholdValueField
+				testId={`threshold-value-${index}`}
+				value={draft.value}
+				onChange={setValue}
+			/>
+			<ThresholdUnitField
+				testId={`threshold-unit-${index}`}
+				invalidTestId={`threshold-unit-invalid-${index}`}
+				value={draft.unit}
+				scopeUnit={yAxisUnit}
+				scopeLabel="y-axis unit"
+				onChange={(unit): void => setDraft((d) => ({ ...d, unit }))}
+			/>
+			<div className={styles.field}>
+				<Typography.Text className={styles.fieldLabel}>Label</Typography.Text>
+				<Input
+					data-testid={`threshold-label-${index}`}
+					placeholder="Optional"
+					value={draft.label ?? ''}
+					onChange={(e): void => setDraft((d) => ({ ...d, label: e.target.value }))}
+				/>
+			</div>
+		</ThresholdRowShell>
+	);
+}
+
+export default LabelThresholdRow;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/TableThresholdRow.tsx

@@ -0,0 +1,141 @@
+import {
+	type DashboardtypesComparisonOperatorDTO,
+	type DashboardtypesTableThresholdDTO,
+	type DashboardtypesThresholdFormatDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { formatPanelValue } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/formatPanelValue';
+
+import type { TableColumnOption } from '../../../../hooks/useTableColumns';
+import {
+	FORMAT_OPTIONS,
+	OPERATOR_OPTIONS,
+	OPERATOR_SYMBOL,
+} from '../thresholdOptions';
+import ThresholdColorField from './shared/ThresholdColorField';
+import ThresholdRowShell from './shared/ThresholdRowShell';
+import ThresholdSelectField from './shared/ThresholdSelectField';
+import ThresholdUnitField from './shared/ThresholdUnitField';
+import { useThresholdDraft } from './shared/useThresholdDraft';
+import ThresholdValueField from './shared/ThresholdValueField';
+
+import styles from '../ThresholdsSection.module.scss';
+
+interface TableThresholdRowProps {
+	index: number;
+	threshold: DashboardtypesTableThresholdDTO;
+	/** Resolved value columns (with their configured units); the rule targets one. */
+	tableColumns: TableColumnOption[];
+	isEditing: boolean;
+	onEdit: () => void;
+	onSave: (next: DashboardtypesTableThresholdDTO) => void;
+	onDiscard: () => void;
+	onRemove: () => void;
+}
+
+/**
+ * Per-column comparison threshold (Table): value in a column crosses an operator →
+ * recolor that column's cells. Edit form is column, condition (operator), value, unit,
+ * color, display format. The unit picker scopes to the selected column's unit (Table
+ * panels have no single panel-wide unit — V1 parity).
+ */
+function TableThresholdRow({
+	index,
+	threshold,
+	tableColumns,
+	isEditing,
+	onEdit,
+	onSave,
+	onDiscard,
+	onRemove,
+}: TableThresholdRowProps): JSX.Element {
+	const { draft, setDraft, setValue } = useThresholdDraft(threshold, isEditing);
+
+	// Stored columnName is the query key; resolve its label + configured unit.
+	const columnUnit = tableColumns.find((c) => c.key === draft.columnName)?.unit;
+	const columnLabel =
+		tableColumns.find((c) => c.key === threshold.columnName)?.label ??
+		threshold.columnName;
+	const columnItems = tableColumns.map((column) => ({
+		value: column.key,
+		label: column.label,
+	}));
+
+	const symbol = threshold.operator ? OPERATOR_SYMBOL[threshold.operator] : '';
+	const summary = (
+		<>
+			<span className={styles.viewLabel}>{columnLabel}</span>
+			<span className={styles.viewValue}>
+				{symbol} {formatPanelValue(threshold.value, threshold.unit)}
+			</span>
+		</>
+	);
+
+	return (
+		<ThresholdRowShell
+			index={index}
+			testIdPrefix="table-threshold"
+			color={threshold.color}
+			isEditing={isEditing}
+			summary={summary}
+			onEdit={onEdit}
+			onSave={(): void => onSave(draft)}
+			onDiscard={onDiscard}
+			onRemove={onRemove}
+		>
+			<ThresholdSelectField
+				label="Column"
+				testId={`table-threshold-column-${index}`}
+				placeholder="Select column"
+				value={draft.columnName || undefined}
+				items={columnItems}
+				onChange={(columnName): void => setDraft((d) => ({ ...d, columnName }))}
+			/>
+			<ThresholdSelectField
+				label="If value is"
+				testId={`table-threshold-operator-${index}`}
+				placeholder="Select condition"
+				value={draft.operator}
+				items={OPERATOR_OPTIONS}
+				onChange={(operator): void =>
+					setDraft((d) => ({
+						...d,
+						operator: operator as DashboardtypesComparisonOperatorDTO,
+					}))
+				}
+			/>
+			<ThresholdValueField
+				testId={`table-threshold-value-${index}`}
+				value={draft.value}
+				onChange={setValue}
+			/>
+			<ThresholdUnitField
+				testId={`table-threshold-unit-${index}`}
+				invalidTestId={`table-threshold-unit-invalid-${index}`}
+				value={draft.unit}
+				scopeUnit={columnUnit}
+				scopeLabel="column unit"
+				onChange={(unit): void => setDraft((d) => ({ ...d, unit }))}
+			/>
+			<ThresholdColorField
+				testId={`table-threshold-color-${index}`}
+				value={draft.color}
+				onChange={(color): void => setDraft((d) => ({ ...d, color }))}
+			/>
+			<ThresholdSelectField
+				label="Display"
+				testId={`table-threshold-format-${index}`}
+				placeholder="Select display"
+				value={draft.format}
+				items={FORMAT_OPTIONS}
+				onChange={(format): void =>
+					setDraft((d) => ({
+						...d,
+						format: format as DashboardtypesThresholdFormatDTO,
+					}))
+				}
+			/>
+		</ThresholdRowShell>
+	);
+}
+
+export default TableThresholdRow;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdColorField.tsx

@@ -0,0 +1,27 @@
+import { Typography } from '@signozhq/ui/typography';
+
+import ThresholdColorSelect from '../../ThresholdColorSelect';
+
+import styles from '../../ThresholdsSection.module.scss';
+
+interface ThresholdColorFieldProps {
+	testId: string;
+	value: string;
+	onChange: (hex: string) => void;
+}
+
+/** Labelled color picker, shared by every threshold variant. */
+function ThresholdColorField({
+	testId,
+	value,
+	onChange,
+}: ThresholdColorFieldProps): JSX.Element {
+	return (
+		<div className={styles.field}>
+			<Typography.Text className={styles.fieldLabel}>Color</Typography.Text>
+			<ThresholdColorSelect value={value} testId={testId} onChange={onChange} />
+		</div>
+	);
+}
+
+export default ThresholdColorField;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdRowShell.tsx

@@ -0,0 +1,103 @@
+import type { ReactNode } from 'react';
+import { Check, Pencil, Trash2, X } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+
+import styles from '../../ThresholdsSection.module.scss';
+
+interface ThresholdRowShellProps {
+	index: number;
+	/** testId prefix per variant: `threshold` | `comparison-threshold` | `table-threshold`. */
+	testIdPrefix: string;
+	/** Swatch color shown in view mode. */
+	color: string;
+	isEditing: boolean;
+	/** Compact view-mode summary, rendered between the color dot and the actions. */
+	summary: ReactNode;
+	/** Edit-mode fields. */
+	children: ReactNode;
+	onEdit: () => void;
+	onSave: () => void;
+	onDiscard: () => void;
+	onRemove: () => void;
+}
+
+/**
+ * Shared chrome for a threshold row's V1-style view/edit modes: the view summary with
+ * Edit/Delete, and the edit form's Discard/Save actions. Each variant supplies its own
+ * `summary` and field `children`; everything else (layout, buttons, testIds) is shared.
+ */
+function ThresholdRowShell({
+	index,
+	testIdPrefix,
+	color,
+	isEditing,
+	summary,
+	children,
+	onEdit,
+	onSave,
+	onDiscard,
+	onRemove,
+}: ThresholdRowShellProps): JSX.Element {
+	if (!isEditing) {
+		return (
+			<div className={styles.viewRow}>
+				<span className={styles.dot} style={{ backgroundColor: color }} />
+				{summary}
+				<div className={styles.spacer} />
+				<Button
+					type="button"
+					variant="ghost"
+					color="secondary"
+					size="icon"
+					aria-label={`Edit threshold ${index + 1}`}
+					data-testid={`${testIdPrefix}-edit-${index}`}
+					onClick={onEdit}
+				>
+					<Pencil size={14} />
+				</Button>
+				<Button
+					type="button"
+					variant="ghost"
+					color="destructive"
+					size="icon"
+					aria-label={`Remove threshold ${index + 1}`}
+					data-testid={`${testIdPrefix}-remove-${index}`}
+					onClick={onRemove}
+				>
+					<Trash2 size={14} />
+				</Button>
+			</div>
+		);
+	}
+
+	return (
+		<div className={styles.editRow}>
+			{children}
+
+			<div className={styles.actions}>
+				<Button
+					type="button"
+					variant="outlined"
+					color="secondary"
+					prefix={<X size={14} />}
+					data-testid={`${testIdPrefix}-discard-${index}`}
+					onClick={onDiscard}
+				>
+					Discard
+				</Button>
+				<Button
+					type="button"
+					variant="solid"
+					color="primary"
+					prefix={<Check size={14} />}
+					data-testid={`${testIdPrefix}-save-${index}`}
+					onClick={onSave}
+				>
+					Save
+				</Button>
+			</div>
+		</div>
+	);
+}
+
+export default ThresholdRowShell;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdSelectField.tsx

@@ -0,0 +1,44 @@
+import { Typography } from '@signozhq/ui/typography';
+
+import ConfigSelect, {
+	type ConfigSelectItem,
+} from '../../../../controls/ConfigSelect/ConfigSelect';
+
+import styles from '../../ThresholdsSection.module.scss';
+
+interface ThresholdSelectFieldProps {
+	label: string;
+	testId: string;
+	placeholder?: string;
+	value: string | undefined;
+	items: ConfigSelectItem[];
+	onChange: (value: string) => void;
+}
+
+/**
+ * Labelled single-select, shared by the threshold variants' enum fields
+ * (operator / display format / column).
+ */
+function ThresholdSelectField({
+	label,
+	testId,
+	placeholder,
+	value,
+	items,
+	onChange,
+}: ThresholdSelectFieldProps): JSX.Element {
+	return (
+		<div className={styles.field}>
+			<Typography.Text className={styles.fieldLabel}>{label}</Typography.Text>
+			<ConfigSelect
+				testId={testId}
+				placeholder={placeholder}
+				value={value}
+				items={items}
+				onChange={onChange}
+			/>
+		</div>
+	);
+}
+
+export default ThresholdSelectField;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdUnitField.tsx

@@ -0,0 +1,57 @@
+import { Typography } from '@signozhq/ui/typography';
+import YAxisUnitSelector from 'components/YAxisUnitSelector';
+import { YAxisSource } from 'components/YAxisUnitSelector/types';
+
+import {
+	isThresholdUnitIncompatible,
+	thresholdUnitCategories,
+} from '../../thresholdUnitCategories';
+
+import styles from '../../ThresholdsSection.module.scss';
+
+interface ThresholdUnitFieldProps {
+	testId: string;
+	invalidTestId: string;
+	value: string | undefined;
+	/** Unit whose category scopes the picker (panel y-axis unit, or the column's unit). */
+	scopeUnit: string | undefined;
+	/** How the scope reads in the mismatch message, e.g. "y-axis unit" / "column unit". */
+	scopeLabel: string;
+	onChange: (unit: string) => void;
+}
+
+/**
+ * Labelled unit picker, scoped to `scopeUnit`'s category (V1 parity) and flagging a
+ * threshold unit that resolves to a different category. Shared by every variant; only
+ * the scope source and its wording differ.
+ */
+function ThresholdUnitField({
+	testId,
+	invalidTestId,
+	value,
+	scopeUnit,
+	scopeLabel,
+	onChange,
+}: ThresholdUnitFieldProps): JSX.Element {
+	return (
+		<div className={styles.field}>
+			<Typography.Text className={styles.fieldLabel}>Unit</Typography.Text>
+			<YAxisUnitSelector
+				containerClassName={styles.unitSelector}
+				data-testid={testId}
+				placeholder="Select unit"
+				source={YAxisSource.DASHBOARDS}
+				categoriesOverride={thresholdUnitCategories(scopeUnit)}
+				value={value}
+				onChange={onChange}
+			/>
+			{isThresholdUnitIncompatible(value, scopeUnit) && (
+				<Typography.Text className={styles.invalidUnit} data-testid={invalidTestId}>
+					Threshold unit ({value}) is not valid with the {scopeLabel} ({scopeUnit})
+				</Typography.Text>
+			)}
+		</div>
+	);
+}
+
+export default ThresholdUnitField;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/ThresholdValueField.tsx

@@ -0,0 +1,33 @@
+import { Typography } from '@signozhq/ui/typography';
+import { Input } from 'antd';
+
+import styles from '../../ThresholdsSection.module.scss';
+
+interface ThresholdValueFieldProps {
+	testId: string;
+	value: number;
+	/** Receives the raw input string; the draft hook parses it. */
+	onChange: (raw: string) => void;
+}
+
+/** Labelled numeric "Value" input, shared by every threshold variant. */
+function ThresholdValueField({
+	testId,
+	value,
+	onChange,
+}: ThresholdValueFieldProps): JSX.Element {
+	return (
+		<div className={styles.field}>
+			<Typography.Text className={styles.fieldLabel}>Value</Typography.Text>
+			<Input
+				data-testid={testId}
+				type="number"
+				placeholder="Value"
+				value={value}
+				onChange={(e): void => onChange(e.target.value)}
+			/>
+		</div>
+	);
+}
+
+export default ThresholdValueField;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/rows/shared/useThresholdDraft.ts

@@ -0,0 +1,34 @@
+import { type Dispatch, type SetStateAction, useEffect, useState } from 'react';
+
+interface ThresholdDraft<T> {
+	draft: T;
+	setDraft: Dispatch<SetStateAction<T>>;
+	/** Parse a raw input string into `value`, ignoring transient non-numeric input. */
+	setValue: (raw: string) => void;
+}
+
+/**
+ * Local draft for a threshold row, shared by every variant. Snapshots the saved
+ * threshold on each entry into edit mode (so Discard simply drops the draft and the
+ * next edit starts clean) and exposes the numeric `value` setter all variants use.
+ */
+export function useThresholdDraft<T extends { value: number }>(
+	threshold: T,
+	isEditing: boolean,
+): ThresholdDraft<T> {
+	const [draft, setDraft] = useState<T>(threshold);
+
+	useEffect(() => {
+		if (isEditing) {
+			setDraft(threshold);
+		}
+		// eslint-disable-next-line react-hooks/exhaustive-deps -- snapshot only on edit entry
+	}, [isEditing]);
+
+	const setValue = (raw: string): void => {
+		const next = Number(raw);
+		setDraft((d) => ({ ...d, value: Number.isNaN(next) ? d.value : next }));
+	};
+
+	return { draft, setDraft, setValue };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/thresholdOptions.ts

@@ -0,0 +1,47 @@
+import {
+	DashboardtypesComparisonOperatorDTO,
+	DashboardtypesThresholdFormatDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import type { ConfigSelectItem } from '../../controls/ConfigSelect/ConfigSelect';
+
+// Comparison operators offered in the "If value is" condition picker. Labels pair a
+// word with its math symbol so the dropdown reads clearly while the view row can show
+// the compact symbol (OPERATOR_SYMBOL below).
+export const OPERATOR_OPTIONS: ConfigSelectItem[] = [
+	{ value: DashboardtypesComparisonOperatorDTO.above, label: 'Above (>)' },
+	{
+		value: DashboardtypesComparisonOperatorDTO.above_or_equal,
+		label: 'Above or equal (≥)',
+	},
+	{ value: DashboardtypesComparisonOperatorDTO.below, label: 'Below (<)' },
+	{
+		value: DashboardtypesComparisonOperatorDTO.below_or_equal,
+		label: 'Below or equal (≤)',
+	},
+	{ value: DashboardtypesComparisonOperatorDTO.equal, label: 'Equal (=)' },
+	{
+		value: DashboardtypesComparisonOperatorDTO.not_equal,
+		label: 'Not equal (≠)',
+	},
+];
+
+// Compact symbol shown in the collapsed (view-mode) summary row.
+export const OPERATOR_SYMBOL: Record<
+	DashboardtypesComparisonOperatorDTO,
+	string
+> = {
+	[DashboardtypesComparisonOperatorDTO.above]: '>',
+	[DashboardtypesComparisonOperatorDTO.above_or_equal]: '≥',
+	[DashboardtypesComparisonOperatorDTO.below]: '<',
+	[DashboardtypesComparisonOperatorDTO.below_or_equal]: '≤',
+	[DashboardtypesComparisonOperatorDTO.equal]: '=',
+	[DashboardtypesComparisonOperatorDTO.not_equal]: '≠',
+};
+
+// How the threshold recolors the panel: just the number ("text") or the whole tile
+// ("background").
+export const FORMAT_OPTIONS: ConfigSelectItem[] = [
+	{ value: DashboardtypesThresholdFormatDTO.background, label: 'Background' },
+	{ value: DashboardtypesThresholdFormatDTO.text, label: 'Text' },
+];

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/ThresholdsSection/thresholdUnitCategories.ts

@@ -0,0 +1,54 @@
+import {
+	type YAxisCategory,
+	YAxisSource,
+} from 'components/YAxisUnitSelector/types';
+import {
+	getYAxisCategories,
+	mapMetricUnitToUniversalUnit,
+} from 'components/YAxisUnitSelector/utils';
+
+// The unit category (Time, Data, …) a unit belongs to, or undefined if unrecognized.
+function categoryForUnit(unit: string): YAxisCategory | undefined {
+	const universal = mapMetricUnitToUniversalUnit(unit);
+	return getYAxisCategories(YAxisSource.DASHBOARDS).find((c) =>
+		c.units.some((u) => u.id === universal),
+	);
+}
+
+/**
+ * Restricts the threshold unit picker to the panel's y-axis unit family, mirroring V1:
+ * a threshold is only meaningfully comparable to the axis when it shares its category
+ * (e.g. an `ms` axis → only Time units). Returns the single matching category, or
+ * `undefined` (all categories) when the panel has no unit set or it can't be mapped.
+ */
+export function thresholdUnitCategories(
+	yAxisUnit: string | undefined,
+): YAxisCategory[] | undefined {
+	if (!yAxisUnit) {
+		return undefined;
+	}
+	const category = categoryForUnit(yAxisUnit);
+	return category ? [category] : undefined;
+}
+
+/**
+ * True when a threshold's unit belongs to a different category than the panel's y-axis
+ * unit (so the values can't be compared) — drives the V1-style mismatch message. Only
+ * flags when both units are set and resolve to distinct categories (e.g. a stale `ms`
+ * threshold left over after the axis unit was changed to bytes).
+ */
+export function isThresholdUnitIncompatible(
+	thresholdUnit: string | undefined,
+	yAxisUnit: string | undefined,
+): boolean {
+	if (!thresholdUnit || !yAxisUnit) {
+		return false;
+	}
+	const thresholdCategory = categoryForUnit(thresholdUnit);
+	const axisCategory = categoryForUnit(yAxisUnit);
+	return Boolean(
+		thresholdCategory &&
+		axisCategory &&
+		thresholdCategory.name !== axisCategory.name,
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/VisualizationSection/VisualizationSection.module.scss

@@ -0,0 +1,5 @@
+.field {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/VisualizationSection/VisualizationSection.tsx

@@ -0,0 +1,91 @@
+import { Typography } from '@signozhq/ui/typography';
+import {
+	DashboardtypesTimePreferenceDTO,
+	TelemetrytypesSignalDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import type { SectionEditorProps } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+import type { PanelKind } from '../../../../Panels/types/panelKind';
+import ConfigSelect from '../../controls/ConfigSelect/ConfigSelect';
+import ConfigSwitch from '../../controls/ConfigSwitch/ConfigSwitch';
+import PanelTypeSwitcher from '../../PanelTypeSwitcher/PanelTypeSwitcher';
+import { TIME_PREFERENCE_OPTIONS } from './timePreferenceOptions';
+
+import styles from './VisualizationSection.module.scss';
+
+type VisualizationSectionProps = SectionEditorProps<'visualization'> & {
+	/** Current panel kind + switch handler, forwarded by SectionSlot for the type switcher. */
+	panelKind?: PanelKind;
+	onChangePanelKind?: (kind: PanelKind) => void;
+	/** Panel's datasource, forwarded by SectionSlot — scopes the switcher's disabled types. */
+	signal?: TelemetrytypesSignalDTO;
+};
+
+/**
+ * Edits the `visualization` slice: the panel-type switcher (`switchPanelKind`, every
+ * kind), the per-panel time preference, bar stacking (`stackedBarChart`, Bar only), and
+ * gap filling (`fillSpans`, TimeSeries only). Each control is gated by its `controls`
+ * flag, so a kind only renders — and only writes — the fields its spec supports.
+ */
+function VisualizationSection({
+	value,
+	controls,
+	onChange,
+	panelKind,
+	onChangePanelKind,
+	signal,
+}: VisualizationSectionProps): JSX.Element {
+	return (
+		<>
+			{controls.switchPanelKind && panelKind && onChangePanelKind && (
+				<PanelTypeSwitcher
+					panelKind={panelKind}
+					signal={signal}
+					onChange={onChangePanelKind}
+				/>
+			)}
+
+			{controls.timePreference && (
+				<div className={styles.field}>
+					<Typography.Text>Panel time preference</Typography.Text>
+					<ConfigSelect
+						testId="panel-editor-v2-time-preference"
+						placeholder="Select time scope…"
+						value={value?.timePreference}
+						items={TIME_PREFERENCE_OPTIONS}
+						onChange={(next): void =>
+							onChange({
+								...value,
+								timePreference: next as DashboardtypesTimePreferenceDTO,
+							})
+						}
+					/>
+				</div>
+			)}
+
+			{controls.stacking && (
+				<ConfigSwitch
+					testId="panel-editor-v2-stacked-bar-chart"
+					title="Stack series"
+					description="Stack bars from all series on top of each other"
+					value={value?.stackedBarChart ?? false}
+					onChange={(checked): void =>
+						onChange({ ...value, stackedBarChart: checked })
+					}
+				/>
+			)}
+
+			{controls.fillSpans && (
+				<ConfigSwitch
+					testId="panel-editor-v2-fill-spans"
+					title="Fill gaps"
+					description="Fill gaps in data with 0 for continuity"
+					value={value?.fillSpans ?? false}
+					onChange={(checked): void => onChange({ ...value, fillSpans: checked })}
+				/>
+			)}
+		</>
+	);
+}
+
+export default VisualizationSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/VisualizationSection/__tests__/VisualizationSection.test.tsx

@@ -0,0 +1,168 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { DashboardtypesTimePreferenceDTO } from 'api/generated/services/sigNoz.schemas';
+
+import VisualizationSection from '../VisualizationSection';
+
+// The type switcher resolves each kind's supported signals; stub it so the test
+// doesn't pull the whole panel registry (renderers, chart libs).
+jest.mock('pages/DashboardPageV2/DashboardContainer/Panels/registry', () => ({
+	getPanelDefinition: jest.fn(() => ({
+		supportedSignals: ['metrics', 'logs', 'traces'],
+	})),
+}));
+
+// Open the antd Select by clicking its selector, then pick the option by label.
+async function pickOption(triggerTestId: string, label: string): Promise<void> {
+	const user = userEvent.setup();
+	const trigger = screen.getByTestId(triggerTestId);
+	await user.click(trigger.querySelector('.ant-select-selector') as HTMLElement);
+	await user.click(await screen.findByRole('option', { name: label }));
+}
+
+describe('VisualizationSection', () => {
+	it('renders every control that is enabled', () => {
+		render(
+			<VisualizationSection
+				value={undefined}
+				controls={{
+					switchPanelKind: true,
+					timePreference: true,
+					stacking: true,
+					fillSpans: true,
+				}}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-time-preference'),
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('panel-editor-v2-stacked-bar-chart'),
+		).toBeInTheDocument();
+		expect(screen.getByTestId('panel-editor-v2-fill-spans')).toBeInTheDocument();
+	});
+
+	it('renders only the controls whose flag is set', () => {
+		render(
+			<VisualizationSection
+				value={undefined}
+				controls={{
+					switchPanelKind: true,
+					timePreference: true,
+				}}
+				onChange={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-time-preference'),
+		).toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-stacked-bar-chart'),
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('panel-editor-v2-fill-spans'),
+		).not.toBeInTheDocument();
+	});
+
+	it('writes the chosen time preference through the dropdown', async () => {
+		const onChange = jest.fn();
+		render(
+			<VisualizationSection
+				value={undefined}
+				controls={{
+					switchPanelKind: true,
+					timePreference: true,
+				}}
+				onChange={onChange}
+			/>,
+		);
+
+		await pickOption('panel-editor-v2-time-preference', 'Last 1 hr');
+
+		expect(onChange).toHaveBeenCalledWith({ timePreference: 'last_1_hr' });
+	});
+
+	it('toggles bar stacking through onChange, preserving other fields', () => {
+		const onChange = jest.fn();
+		render(
+			<VisualizationSection
+				value={{
+					timePreference: DashboardtypesTimePreferenceDTO.global_time,
+					stackedBarChart: false,
+				}}
+				controls={{
+					switchPanelKind: true,
+					stacking: true,
+				}}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-stacked-bar-chart'));
+
+		expect(onChange).toHaveBeenCalledWith({
+			timePreference: 'global_time',
+			stackedBarChart: true,
+		});
+	});
+
+	it('toggles fill spans through onChange', () => {
+		const onChange = jest.fn();
+		render(
+			<VisualizationSection
+				value={{ fillSpans: false }}
+				controls={{
+					switchPanelKind: true,
+					fillSpans: true,
+				}}
+				onChange={onChange}
+			/>,
+		);
+
+		fireEvent.click(screen.getByTestId('panel-editor-v2-fill-spans'));
+
+		expect(onChange).toHaveBeenCalledWith({ fillSpans: true });
+	});
+
+	it('renders the type switcher and switches kind when switchPanelKind is set', async () => {
+		const onChangePanelKind = jest.fn();
+		render(
+			<VisualizationSection
+				value={undefined}
+				controls={{ switchPanelKind: true }}
+				onChange={jest.fn()}
+				panelKind="signoz/TimeSeriesPanel"
+				onChangePanelKind={onChangePanelKind}
+			/>,
+		);
+
+		expect(
+			screen.getByTestId('panel-editor-v2-type-switcher'),
+		).toBeInTheDocument();
+
+		await pickOption('panel-editor-v2-type-switcher', 'Table');
+		expect(onChangePanelKind).toHaveBeenCalledWith('signoz/TablePanel');
+	});
+
+	it('hides the type switcher when switchPanelKind is not set', () => {
+		render(
+			<VisualizationSection
+				value={undefined}
+				controls={{
+					switchPanelKind: false,
+					timePreference: true,
+				}}
+				onChange={jest.fn()}
+				panelKind="signoz/TimeSeriesPanel"
+				onChangePanelKind={jest.fn()}
+			/>,
+		);
+
+		expect(
+			screen.queryByTestId('panel-editor-v2-type-switcher'),
+		).not.toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ConfigPane/sections/VisualizationSection/timePreferenceOptions.ts

@@ -0,0 +1,18 @@
+import { DashboardtypesTimePreferenceDTO } from 'api/generated/services/sigNoz.schemas';
+
+import type { ConfigSelectItem } from '../../controls/ConfigSelect/ConfigSelect';
+
+// Per-panel time scope. "Global Time" follows the dashboard's time picker; the rest pin
+// the panel to a fixed relative window regardless of the dashboard range (V1 parity).
+export const TIME_PREFERENCE_OPTIONS: ConfigSelectItem[] = [
+	{ value: DashboardtypesTimePreferenceDTO.global_time, label: 'Global Time' },
+	{ value: DashboardtypesTimePreferenceDTO.last_5_min, label: 'Last 5 min' },
+	{ value: DashboardtypesTimePreferenceDTO.last_15_min, label: 'Last 15 min' },
+	{ value: DashboardtypesTimePreferenceDTO.last_30_min, label: 'Last 30 min' },
+	{ value: DashboardtypesTimePreferenceDTO.last_1_hr, label: 'Last 1 hr' },
+	{ value: DashboardtypesTimePreferenceDTO.last_6_hr, label: 'Last 6 hr' },
+	{ value: DashboardtypesTimePreferenceDTO.last_1_day, label: 'Last 1 day' },
+	{ value: DashboardtypesTimePreferenceDTO.last_3_days, label: 'Last 3 days' },
+	{ value: DashboardtypesTimePreferenceDTO.last_1_week, label: 'Last 1 week' },
+	{ value: DashboardtypesTimePreferenceDTO.last_1_month, label: 'Last 1 month' },
+];

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/Header/Header.module.scss

@@ -0,0 +1,22 @@
+.header {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 12px;
+	padding: 12px 16px;
+	background-color: var(--l1-background-60);
+	border-bottom: 1px solid var(--l1-border);
+}
+
+.title {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	min-width: 0;
+}
+
+.actions {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/Header/Header.tsx

@@ -0,0 +1,86 @@
+import { useCallback } from 'react';
+import { SolidAlertTriangle, X } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import { ConfirmDialog } from '@signozhq/ui/dialog';
+import { Divider } from '@signozhq/ui/divider';
+import { Typography } from '@signozhq/ui/typography';
+import { useConfirmableAction } from 'hooks/useConfirmableAction';
+
+import styles from './Header.module.scss';
+
+interface HeaderProps {
+	isDirty: boolean;
+	isSaving: boolean;
+	onSave: () => void;
+	onClose: () => void;
+}
+
+function Header({
+	isDirty,
+	isSaving,
+	onSave,
+	onClose,
+}: HeaderProps): JSX.Element {
+	const discard = useConfirmableAction(
+		useCallback(async (): Promise<void> => onClose(), [onClose]),
+	);
+
+	// Confirm before closing with unsaved edits; a pristine panel closes straight away.
+	const handleCloseClick = useCallback((): void => {
+		if (isDirty) {
+			discard.request();
+		} else {
+			onClose();
+		}
+	}, [isDirty, onClose, discard]);
+
+	return (
+		<div className={styles.header}>
+			<div className={styles.title}>
+				<Button
+					variant="ghost"
+					color="secondary"
+					size="icon"
+					suffix={<X size={14} />}
+					data-testid="panel-editor-v2-close"
+					onClick={handleCloseClick}
+				/>
+				<Divider type="vertical" />
+				<Typography.Text>Configure panel</Typography.Text>
+			</div>
+			<div className={styles.actions}>
+				<Button
+					variant="solid"
+					color="primary"
+					data-testid="panel-editor-v2-save"
+					disabled={!isDirty || isSaving}
+					loading={isSaving}
+					onClick={onSave}
+				>
+					Save changes
+				</Button>
+			</div>
+
+			<ConfirmDialog
+				open={discard.open}
+				onOpenChange={(next): void => {
+					if (!next) {
+						discard.cancel();
+					}
+				}}
+				title="Discard changes?"
+				titleIcon={<SolidAlertTriangle size={14} color="#fdd600" />}
+				confirmText="Discard"
+				confirmColor="destructive"
+				cancelText="Keep editing"
+				onConfirm={discard.confirm}
+				onCancel={discard.cancel}
+				data-testid="panel-editor-v2-discard-modal"
+			>
+				<Typography>Your unsaved edits to this panel will be lost.</Typography>
+			</ConfirmDialog>
+		</div>
+	);
+}
+
+export default Header;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/ListColumnsEditor.module.scss

@@ -0,0 +1,38 @@
+.editor {
+	display: flex;
+	flex-direction: column;
+	gap: 8px;
+	padding: 12px;
+	border-top: 1px solid var(--l2-border);
+	background-color: var(--l1-background);
+}
+
+.header {
+	display: flex;
+	align-items: center;
+}
+
+.title {
+	font-size: 12px;
+	font-weight: 500;
+	color: var(--l2-foreground);
+}
+
+.body {
+	display: flex;
+	flex-wrap: wrap;
+	align-items: center;
+	gap: 8px;
+}
+
+.chips {
+	display: flex;
+	flex-wrap: wrap;
+	align-items: center;
+	gap: 8px;
+}
+
+.hint {
+	font-size: 11px;
+	color: var(--l3-foreground);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/ListColumnsEditor.tsx

@@ -0,0 +1,122 @@
+import { useMemo } from 'react';
+import {
+	closestCenter,
+	DndContext,
+	type DragEndEvent,
+	KeyboardSensor,
+	PointerSensor,
+	useSensor,
+	useSensors,
+} from '@dnd-kit/core';
+import {
+	arrayMove,
+	horizontalListSortingStrategy,
+	SortableContext,
+	sortableKeyboardCoordinates,
+} from '@dnd-kit/sortable';
+import { Typography } from '@signozhq/ui/typography';
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+	TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import AddColumnDropdown from './components/AddColumnDropdown/AddColumnDropdown';
+import SortableColumnChip from './components/SortableColumnChip/SortableColumnChip';
+import { readSelectFields, writeSelectFields } from './selectFields';
+import styles from './ListColumnsEditor.module.scss';
+
+interface ListColumnsEditorProps {
+	spec: DashboardtypesPanelSpecDTO;
+	onChangeSpec: (next: DashboardtypesPanelSpecDTO) => void;
+	/** Committed query's signal — scopes the add-dropdown's field suggestions. */
+	signal: TelemetrytypesSignalDTO | undefined;
+}
+
+/**
+ * The List panel's columns control, rendered below the query builder (V1 parity).
+ * Columns are `spec.plugin.spec.selectFields`, shown as draggable chips that can
+ * be reordered, removed, or added from a field-search dropdown. Empty means the
+ * renderer shows every field the query returns.
+ */
+function ListColumnsEditor({
+	spec,
+	onChangeSpec,
+	signal,
+}: ListColumnsEditorProps): JSX.Element {
+	const fields = useMemo(() => readSelectFields(spec), [spec]);
+	const names = useMemo(() => fields.map((field) => field.name), [fields]);
+	const selectedNames = useMemo(() => new Set(names), [names]);
+
+	const sensors = useSensors(
+		useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+		useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
+	);
+
+	const commit = (next: TelemetrytypesTelemetryFieldKeyDTO[]): void =>
+		onChangeSpec(writeSelectFields(spec, next));
+
+	const handleDragEnd = (event: DragEndEvent): void => {
+		const { active, over } = event;
+		if (!over || active.id === over.id) {
+			return;
+		}
+		const oldIndex = names.indexOf(active.id as string);
+		const newIndex = names.indexOf(over.id as string);
+		if (oldIndex === -1 || newIndex === -1) {
+			return;
+		}
+		commit(arrayMove(fields, oldIndex, newIndex));
+	};
+
+	const handleRemove = (name: string): void =>
+		commit(fields.filter((field) => field.name !== name));
+
+	const handleToggle = (field: TelemetrytypesTelemetryFieldKeyDTO): void => {
+		if (selectedNames.has(field.name)) {
+			handleRemove(field.name);
+			return;
+		}
+		commit([...fields, field]);
+	};
+
+	return (
+		<div className={styles.editor} data-testid="list-columns-editor">
+			<div className={styles.header}>
+				<Typography.Text className={styles.title}>Columns</Typography.Text>
+			</div>
+			<div className={styles.body}>
+				<DndContext
+					sensors={sensors}
+					collisionDetection={closestCenter}
+					onDragEnd={handleDragEnd}
+				>
+					<SortableContext items={names} strategy={horizontalListSortingStrategy}>
+						<div className={styles.chips}>
+							{fields.map((field) => (
+								<SortableColumnChip
+									key={field.name}
+									id={field.name}
+									name={field.name}
+									onRemove={handleRemove}
+								/>
+							))}
+						</div>
+					</SortableContext>
+				</DndContext>
+				<AddColumnDropdown
+					signal={signal}
+					selectedNames={selectedNames}
+					onToggle={handleToggle}
+				/>
+			</div>
+			{fields.length === 0 && (
+				<Typography.Text className={styles.hint}>
+					Leave empty to show all fields returned by the query.
+				</Typography.Text>
+			)}
+		</div>
+	);
+}
+
+export default ListColumnsEditor;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/__tests__/ListColumnsEditor.test.tsx

@@ -0,0 +1,134 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import {
+	TelemetrytypesSignalDTO,
+	type DashboardtypesPanelSpecDTO,
+	type TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import ListColumnsEditor from '../ListColumnsEditor';
+import { readSelectFields } from '../selectFields';
+
+// The add-dropdown fetches field-key suggestions; stub the generated hook so the
+// editor renders without a query client. Each test can override the return value.
+const mockUseGetFieldsKeys = jest.fn(
+	(..._args: unknown[]): { data: unknown; isFetching: boolean } => ({
+		data: undefined,
+		isFetching: false,
+	}),
+);
+jest.mock('api/generated/services/fields', () => ({
+	useGetFieldsKeys: (
+		...args: unknown[]
+	): { data: unknown; isFetching: boolean } => mockUseGetFieldsKeys(...args),
+}));
+
+const FIELDS = [
+	{ name: 'body', fieldContext: 'attribute' },
+	{ name: 'level' },
+] as TelemetrytypesTelemetryFieldKeyDTO[];
+
+function specWith(
+	selectFields: TelemetrytypesTelemetryFieldKeyDTO[] | undefined,
+): DashboardtypesPanelSpecDTO {
+	return {
+		plugin: { kind: 'signoz/ListPanel', spec: { selectFields } },
+	} as unknown as DashboardtypesPanelSpecDTO;
+}
+
+describe('ListColumnsEditor', () => {
+	beforeEach(() => {
+		mockUseGetFieldsKeys.mockClear();
+		mockUseGetFieldsKeys.mockReturnValue({ data: undefined, isFetching: false });
+	});
+
+	it('renders the selected columns as chips', () => {
+		render(
+			<ListColumnsEditor
+				spec={specWith(FIELDS)}
+				onChangeSpec={jest.fn()}
+				signal={TelemetrytypesSignalDTO.logs}
+			/>,
+		);
+
+		expect(screen.getByText('body')).toBeInTheDocument();
+		expect(screen.getByText('level')).toBeInTheDocument();
+	});
+
+	it('shows the empty-state hint when no columns are selected', () => {
+		render(
+			<ListColumnsEditor
+				spec={specWith([])}
+				onChangeSpec={jest.fn()}
+				signal={TelemetrytypesSignalDTO.logs}
+			/>,
+		);
+
+		expect(
+			screen.getByText(/Leave empty to show all fields/),
+		).toBeInTheDocument();
+	});
+
+	it('scopes the field-key suggestions to the panel signal', () => {
+		render(
+			<ListColumnsEditor
+				spec={specWith(FIELDS)}
+				onChangeSpec={jest.fn()}
+				signal={TelemetrytypesSignalDTO.traces}
+			/>,
+		);
+
+		expect(mockUseGetFieldsKeys).toHaveBeenCalledWith(
+			expect.objectContaining({ signal: TelemetrytypesSignalDTO.traces }),
+			expect.anything(),
+		);
+	});
+
+	it('removing a chip writes the spec without that column', async () => {
+		const user = userEvent.setup();
+		const onChangeSpec = jest.fn();
+		render(
+			<ListColumnsEditor
+				spec={specWith(FIELDS)}
+				onChangeSpec={onChangeSpec}
+				signal={TelemetrytypesSignalDTO.logs}
+			/>,
+		);
+
+		await user.click(screen.getByLabelText('Remove body'));
+
+		expect(onChangeSpec).toHaveBeenCalledTimes(1);
+		const nextSpec = onChangeSpec.mock.calls[0][0] as DashboardtypesPanelSpecDTO;
+		const fields = readSelectFields(nextSpec);
+		expect(fields.map((field) => field.name)).toStrictEqual(['level']);
+	});
+
+	it('adds a suggestion picked from the dropdown', async () => {
+		const user = userEvent.setup();
+		mockUseGetFieldsKeys.mockReturnValue({
+			data: { data: { keys: { group: [{ name: 'status' }] } } },
+			isFetching: false,
+		});
+		const onChangeSpec = jest.fn();
+		render(
+			<ListColumnsEditor
+				spec={specWith(FIELDS)}
+				onChangeSpec={onChangeSpec}
+				signal={TelemetrytypesSignalDTO.logs}
+			/>,
+		);
+
+		await user.click(screen.getByTestId('list-columns-add'));
+		const suggestion = await screen.findByText('status');
+		await user.click(suggestion);
+
+		expect(onChangeSpec).toHaveBeenCalledTimes(1);
+		const nextSpec = onChangeSpec.mock.calls[0][0] as DashboardtypesPanelSpecDTO;
+		const fields = readSelectFields(nextSpec);
+		expect(fields.map((field) => field.name)).toStrictEqual([
+			'body',
+			'level',
+			'status',
+		]);
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/__tests__/selectFields.test.ts

@@ -0,0 +1,58 @@
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import {
+	readSelectFields,
+	sanitizeSelectFields,
+	writeSelectFields,
+} from '../selectFields';
+
+// The fields API and default-column constants carry extra runtime keys (e.g.
+// `isIndexed`) the save contract rejects; only the DTO keys may be persisted.
+const DIRTY_FIELD = {
+	name: 'body',
+	signal: 'logs',
+	fieldContext: 'log',
+	fieldDataType: '',
+	isIndexed: false,
+} as unknown as TelemetrytypesTelemetryFieldKeyDTO;
+
+describe('selectFields', () => {
+	describe('sanitizeSelectFields', () => {
+		it('drops keys outside the field-key DTO (isIndexed)', () => {
+			const [cleaned] = sanitizeSelectFields([DIRTY_FIELD]);
+
+			expect('isIndexed' in cleaned).toBe(false);
+			expect(cleaned).toStrictEqual({
+				name: 'body',
+				signal: 'logs',
+				fieldContext: 'log',
+				fieldDataType: '',
+			});
+		});
+
+		it('omits absent optional keys rather than emitting undefined', () => {
+			const [cleaned] = sanitizeSelectFields([
+				{ name: 'level' } as TelemetrytypesTelemetryFieldKeyDTO,
+			]);
+
+			expect(cleaned).toStrictEqual({ name: 'level' });
+		});
+	});
+
+	describe('writeSelectFields', () => {
+		it('sanitizes columns as it writes them onto the spec', () => {
+			const spec = {
+				plugin: { kind: 'signoz/ListPanel', spec: {} },
+			} as unknown as DashboardtypesPanelSpecDTO;
+
+			const next = writeSelectFields(spec, [DIRTY_FIELD]);
+
+			expect(readSelectFields(next)).toStrictEqual([
+				{ name: 'body', signal: 'logs', fieldContext: 'log', fieldDataType: '' },
+			]);
+		});
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/components/AddColumnDropdown/AddColumnDropdown.module.scss

@@ -0,0 +1,10 @@
+// Shrink the icon Button from its 2rem default to the editor's 28px control row.
+.addBtn {
+	--button-height: 28px;
+	--button-width: 28px;
+	flex-shrink: 0;
+}
+
+.dropdown {
+	width: 260px;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/components/AddColumnDropdown/AddColumnDropdown.tsx

@@ -0,0 +1,106 @@
+import { useState } from 'react';
+import { Button } from '@signozhq/ui/button';
+import {
+	Combobox,
+	ComboboxCommand,
+	ComboboxContent,
+	ComboboxEmpty,
+	ComboboxInput,
+	ComboboxItem,
+	ComboboxList,
+	ComboboxLoading,
+	ComboboxTrigger,
+} from '@signozhq/ui/combobox';
+import { Plus } from '@signozhq/icons';
+import type {
+	TelemetrytypesSignalDTO,
+	TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+
+import { useListColumnSuggestions } from '../../hooks/useListColumnSuggestions';
+import styles from './AddColumnDropdown.module.scss';
+
+interface AddColumnDropdownProps {
+	signal: TelemetrytypesSignalDTO | undefined;
+	/** Names already chosen — drives the checked state + toggle behavior. */
+	selectedNames: Set<string>;
+	onToggle: (field: TelemetrytypesTelemetryFieldKeyDTO) => void;
+}
+
+/**
+ * The "+" affordance for the List columns editor: a searchable combobox of
+ * field-key suggestions. Picking a suggestion toggles it (checkmark = selected);
+ * a non-matching search term can be added verbatim so not-yet-indexed fields are
+ * still selectable. Search is server-side, so cmdk filtering is disabled.
+ */
+function AddColumnDropdown({
+	signal,
+	selectedNames,
+	onToggle,
+}: AddColumnDropdownProps): JSX.Element {
+	const [open, setOpen] = useState(false);
+	const { searchText, setSearchText, suggestions, isFetching } =
+		useListColumnSuggestions(signal);
+
+	const trimmed = searchText.trim();
+	const hasExactMatch = suggestions.some((field) => field.name === trimmed);
+	const showCustomAdd = trimmed.length > 0 && !hasExactMatch;
+
+	return (
+		<Combobox open={open} onOpenChange={setOpen}>
+			<ComboboxTrigger asChild>
+				<Button
+					type="button"
+					variant="outlined"
+					color="secondary"
+					size="icon"
+					className={styles.addBtn}
+					aria-label="Add column"
+					// `data-testid` (not the `testId` prop) survives the trigger's
+					// `asChild` Slot merge, which otherwise resets it to undefined.
+					data-testid="list-columns-add"
+				>
+					<Plus size={16} />
+				</Button>
+			</ComboboxTrigger>
+			<ComboboxContent arrow side="top" align="end" className={styles.dropdown}>
+				<ComboboxCommand shouldFilter={false}>
+					<ComboboxInput
+						value={searchText}
+						onValueChange={setSearchText}
+						placeholder="Search fields"
+						testId="list-columns-search"
+					/>
+					<ComboboxList>
+						{showCustomAdd && (
+							<ComboboxItem
+								value={trimmed}
+								onSelect={(): void => onToggle({ name: trimmed })}
+								data-testid="list-columns-add-custom"
+							>
+								Add &quot;{trimmed}&quot;
+							</ComboboxItem>
+						)}
+						{suggestions.map((field) => (
+							<ComboboxItem
+								key={field.name}
+								value={field.name}
+								isSelected={selectedNames.has(field.name)}
+								onSelect={(): void => onToggle(field)}
+								data-testid="list-columns-suggestion"
+							>
+								{field.name}
+							</ComboboxItem>
+						))}
+						{isFetching && <ComboboxLoading>Loading…</ComboboxLoading>}
+						{!isFetching && !showCustomAdd && suggestions.length === 0 && (
+							<ComboboxEmpty>No fields found</ComboboxEmpty>
+						)}
+					</ComboboxList>
+				</ComboboxCommand>
+			</ComboboxContent>
+		</Combobox>
+	);
+}
+
+export default AddColumnDropdown;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/components/SortableColumnChip/SortableColumnChip.module.scss

@@ -0,0 +1,41 @@
+.chip {
+	display: inline-flex;
+	align-items: center;
+	gap: 6px;
+	height: 28px;
+	padding: 0 8px;
+	border: 1px solid var(--l2-border);
+	border-radius: 4px;
+	background-color: var(--l2-background);
+}
+
+// Shrink the icon Button to the chip's compact footprint (defaults are 2rem
+// square with 0.5rem padding) via the component's CSS-custom-property hooks.
+.grip {
+	--button-height: 16px;
+	--button-width: 16px;
+	--button-padding: 0;
+	cursor: grab;
+
+	&:active {
+		cursor: grabbing;
+	}
+}
+
+.chipName {
+	max-width: 180px;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	font-size: 12px;
+	color: var(--l1-foreground);
+}
+
+.remove {
+	--button-height: 16px;
+	--button-width: 16px;
+	--button-padding: 0;
+	// Keep the V1 affordance: neutral by default, cherry-red on hover.
+	--button-variant-ghost-hover-color: var(--bg-cherry-400);
+	--button-variant-ghost-hover-background-color: transparent;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/components/SortableColumnChip/SortableColumnChip.tsx

@@ -0,0 +1,70 @@
+import { useSortable } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { Button } from '@signozhq/ui/button';
+import { GripVertical, X } from '@signozhq/icons';
+
+import styles from './SortableColumnChip.module.scss';
+
+interface SortableColumnChipProps {
+	/** Stable sortable id (the column name). */
+	id: string;
+	name: string;
+	onRemove: (name: string) => void;
+}
+
+/** A single draggable column chip: grip handle, field name, remove button. */
+function SortableColumnChip({
+	id,
+	name,
+	onRemove,
+}: SortableColumnChipProps): JSX.Element {
+	const {
+		attributes,
+		listeners,
+		setNodeRef,
+		transform,
+		transition,
+		isDragging,
+	} = useSortable({ id });
+
+	// dnd-kit drives the drag transform per-frame, so this must be inline.
+	const style: React.CSSProperties = {
+		transform: CSS.Transform.toString(transform),
+		transition,
+		opacity: isDragging ? 0.5 : undefined,
+	};
+
+	return (
+		<div ref={setNodeRef} style={style} className={styles.chip}>
+			<Button
+				type="button"
+				variant="ghost"
+				color="secondary"
+				size="icon"
+				className={styles.grip}
+				aria-label={`Reorder ${name}`}
+				{...attributes}
+				{...listeners}
+			>
+				<GripVertical size={12} />
+			</Button>
+			<span className={styles.chipName} title={name}>
+				{name}
+			</span>
+			<Button
+				type="button"
+				variant="ghost"
+				color="secondary"
+				size="icon"
+				className={styles.remove}
+				aria-label={`Remove ${name}`}
+				testId="list-column-remove"
+				onClick={(): void => onRemove(name)}
+			>
+				<X size={12} />
+			</Button>
+		</div>
+	);
+}
+
+export default SortableColumnChip;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/hooks/useListColumnSuggestions.ts

@@ -0,0 +1,50 @@
+import { useMemo, useState } from 'react';
+import type {
+	TelemetrytypesSignalDTO,
+	TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { useGetFieldsKeys } from 'api/generated/services/fields';
+import useDebounce from 'hooks/useDebounce';
+
+interface UseListColumnSuggestions {
+	searchText: string;
+	setSearchText: (value: string) => void;
+	suggestions: TelemetrytypesTelemetryFieldKeyDTO[];
+	/** Suggestion field keyed by name — enriches a freshly-picked column with its metadata. */
+	suggestionByName: Map<string, TelemetrytypesTelemetryFieldKeyDTO>;
+	isFetching: boolean;
+}
+
+/**
+ * Server-side telemetry field-key search scoped to the panel's signal, shared by
+ * the List columns editor's add-dropdown. Suggestions arrive grouped by name; we
+ * flatten them and index by name so picks can carry their context/data-type.
+ */
+export function useListColumnSuggestions(
+	signal: TelemetrytypesSignalDTO | undefined,
+): UseListColumnSuggestions {
+	const [searchText, setSearchText] = useState('');
+	const debouncedSearch = useDebounce(searchText, 300);
+
+	const { data, isFetching } = useGetFieldsKeys(
+		{ signal, searchText: debouncedSearch },
+		{ query: { enabled: !!signal } },
+	);
+
+	const suggestions = useMemo(
+		() => Object.values(data?.data.keys ?? {}).flat(),
+		[data],
+	);
+	const suggestionByName = useMemo(
+		() => new Map(suggestions.map((field) => [field.name, field])),
+		[suggestions],
+	);
+
+	return {
+		searchText,
+		setSearchText,
+		suggestions,
+		suggestionByName,
+		isFetching,
+	};
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/ListColumnsEditor/selectFields.ts

@@ -0,0 +1,75 @@
+import {
+	type DashboardtypesListPanelSpecDTO,
+	type DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+	type TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import {
+	defaultLogsSelectedColumns,
+	defaultTraceSelectedColumns,
+} from 'container/OptionsMenu/constants';
+
+/**
+ * Reduce each column to the field-key DTO shape: the suggestions API and default
+ * constants carry extra runtime fields (e.g. `isIndexed`) the save contract rejects.
+ */
+function toFieldKeyDTO(
+	field: TelemetrytypesTelemetryFieldKeyDTO,
+): TelemetrytypesTelemetryFieldKeyDTO {
+	const { name, description, fieldContext, fieldDataType, signal, unit } = field;
+	return {
+		name,
+		...(description !== undefined && { description }),
+		...(fieldContext !== undefined && { fieldContext }),
+		...(fieldDataType !== undefined && { fieldDataType }),
+		...(signal !== undefined && { signal }),
+		...(unit !== undefined && { unit }),
+	};
+}
+
+export function sanitizeSelectFields(
+	fields: TelemetrytypesTelemetryFieldKeyDTO[],
+): TelemetrytypesTelemetryFieldKeyDTO[] {
+	return fields.map(toFieldKeyDTO);
+}
+
+/**
+ * logs/traces List-column defaults (V1 parity), sanitized to the field-key DTO.
+ */
+export function defaultColumnsForSignal(
+	signal: TelemetrytypesSignalDTO,
+): TelemetrytypesTelemetryFieldKeyDTO[] {
+	if (signal === TelemetrytypesSignalDTO.logs) {
+		return sanitizeSelectFields(
+			defaultLogsSelectedColumns as TelemetrytypesTelemetryFieldKeyDTO[],
+		);
+	}
+	if (signal === TelemetrytypesSignalDTO.traces) {
+		return sanitizeSelectFields(
+			defaultTraceSelectedColumns as TelemetrytypesTelemetryFieldKeyDTO[],
+		);
+	}
+	return [];
+}
+
+// `spec.plugin.spec` is a discriminated union over panel kinds; these List-only
+// helpers narrow to the List variant via a single localized cast at the boundary.
+export function readSelectFields(
+	spec: DashboardtypesPanelSpecDTO,
+): TelemetrytypesTelemetryFieldKeyDTO[] {
+	return (spec.plugin.spec as DashboardtypesListPanelSpecDTO).selectFields ?? [];
+}
+
+export function writeSelectFields(
+	spec: DashboardtypesPanelSpecDTO,
+	selectFields: TelemetrytypesTelemetryFieldKeyDTO[],
+): DashboardtypesPanelSpecDTO {
+	const listSpec: DashboardtypesListPanelSpecDTO = {
+		...(spec.plugin.spec as DashboardtypesListPanelSpecDTO),
+		selectFields: sanitizeSelectFields(selectFields),
+	};
+	return {
+		...spec,
+		plugin: { ...spec.plugin, spec: listSpec },
+	} as DashboardtypesPanelSpecDTO;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PanelEditor.module.scss

@@ -0,0 +1,28 @@
+// Full-page editor: fills the route's content area as a header-over-split
+// column (the editor is its own page now, not a modal overlay).
+.page {
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	min-height: 0;
+	overflow: hidden;
+	background: var(--l1-background);
+}
+
+.left {
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	min-height: 0;
+}
+
+.right {
+	display: flex;
+}
+
+.handle {
+	background: var(--l1-border);
+	&:hover {
+		background: var(--l2-border);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PanelEditorQueryBuilder/PanelEditorQueryBuilder.module.scss

@@ -0,0 +1,45 @@
+@use '../../../../../styles/scrollbar' as *;
+.container {
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	min-height: 0;
+	overflow: auto;
+	background-color: var(--l1-background);
+	@include custom-scrollbar;
+}
+
+.scrollArea {
+	padding: 12px;
+}
+
+.tabsContainer {
+	width: 100%;
+
+	:global(.ant-tabs-tab) {
+		background-color: var(--l2-background) !important;
+		border-color: var(--l2-border) !important;
+	}
+	:global(.ant-tabs-tab-active) {
+		background-color: var(--l1-background) !important;
+	}
+	:global(.ant-tabs-nav) {
+		&::before {
+			border-color: var(--l2-border);
+		}
+	}
+}
+.queryTypeTab {
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 4px;
+}
+.runQueryBtnContainer {
+	padding: 4px 0 8px 0;
+	display: flex;
+	flex-direction: row;
+	align-items: center;
+	justify-content: center;
+	gap: 1rem;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PanelEditorQueryBuilder/PanelEditorQueryBuilder.tsx

@@ -0,0 +1,165 @@
+import {
+	type KeyboardEvent,
+	type ReactNode,
+	useCallback,
+	useMemo,
+} from 'react';
+import { Color } from '@signozhq/design-tokens';
+import { Atom, Terminal } from '@signozhq/icons';
+import { Tabs } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+import PromQLIcon from 'assets/Dashboard/PromQl';
+import { QueryBuilderV2 } from 'components/QueryBuilderV2/QueryBuilderV2';
+import TextToolTip from 'components/TextToolTip';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import ClickHouseQueryContainer from 'container/NewWidget/LeftContainer/QuerySection/QueryBuilder/ClickHouse';
+import PromQLQueryContainer from 'container/NewWidget/LeftContainer/QuerySection/QueryBuilder/promQL';
+import { PANEL_TYPE_TO_QUERY_TYPES } from 'container/NewWidget/utils';
+import RunQueryBtn from 'container/QueryBuilder/components/RunQueryBtn/RunQueryBtn';
+import { QueryBuilderProps } from 'container/QueryBuilder/QueryBuilder.interfaces';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import { EQueryType } from 'types/common/dashboard';
+
+import styles from './PanelEditorQueryBuilder.module.scss';
+
+interface PanelEditorQueryBuilderProps {
+	panelType: PANEL_TYPES;
+	/** Preview fetch in flight — drives the Stage & Run button's loading/cancel state. */
+	isLoadingQueries: boolean;
+	/** Run the current query (Stage & Run button / ⌘↵). Always re-runs. */
+	onStageRunQuery: () => void;
+	/** Abort the in-flight preview fetch (the button's cancel action). */
+	onCancelQuery: () => void;
+	/** Optional content pinned below the builder (e.g. the List columns editor). */
+	footer?: ReactNode;
+}
+
+/**
+ * Builder UI for the V2 panel editor's left pane: queryType tabs (Query Builder /
+ * ClickHouse / PromQL) plus the Stage & Run button, all reading/writing the global
+ * `QueryBuilderProvider`. `usePanelEditorQuerySync` owns the panel↔provider sync.
+ */
+function PanelEditorQueryBuilder({
+	panelType,
+	isLoadingQueries,
+	onStageRunQuery,
+	onCancelQuery,
+	footer,
+}: PanelEditorQueryBuilderProps): JSX.Element {
+	const { currentQuery, redirectWithQueryBuilderData } = useQueryBuilder();
+	const isDarkMode = useIsDarkMode();
+
+	const handleQueryCategoryChange = useCallback(
+		(queryType: string): void => {
+			redirectWithQueryBuilderData({
+				...currentQuery,
+				queryType: queryType as EQueryType,
+			});
+		},
+		[currentQuery, redirectWithQueryBuilderData],
+	);
+
+	// ⌘↵ / Ctrl+↵ stages and runs the query. Handled locally because the global
+	// hotkeys provider ignores keydowns from inputs / the query editor, and on the
+	// capture phase so it still fires for fields that stop bubbling (filter search,
+	// CodeMirror).
+	const handleKeyDownCapture = useCallback(
+		(event: KeyboardEvent<HTMLDivElement>): void => {
+			if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+				event.preventDefault();
+				onStageRunQuery();
+			}
+		},
+		[onStageRunQuery],
+	);
+
+	const filterConfigs: QueryBuilderProps['filterConfigs'] = useMemo(
+		() => ({ stepInterval: { isHidden: false, isDisabled: false } }),
+		[],
+	);
+
+	const items = useMemo(() => {
+		const supportedQueryTypes = PANEL_TYPE_TO_QUERY_TYPES[panelType] || [];
+
+		const queryTypeComponents = {
+			[EQueryType.QUERY_BUILDER]: {
+				icon: <Atom size={14} />,
+				label: 'Query Builder',
+				component: (
+					<div className="query-builder-v2-container">
+						<QueryBuilderV2
+							panelType={panelType}
+							filterConfigs={filterConfigs}
+							showTraceOperator={panelType !== PANEL_TYPES.LIST}
+							version="v3"
+							isListViewPanel={panelType === PANEL_TYPES.LIST}
+							queryComponents={{}}
+							signalSourceChangeEnabled
+							savePreviousQuery
+						/>
+					</div>
+				),
+			},
+			[EQueryType.CLICKHOUSE]: {
+				icon: <Terminal size={14} />,
+				label: 'ClickHouse Query',
+				component: <ClickHouseQueryContainer />,
+			},
+			[EQueryType.PROM]: {
+				icon: (
+					<PromQLIcon
+						fillColor={isDarkMode ? Color.BG_VANILLA_200 : Color.BG_INK_300}
+					/>
+				),
+				label: 'PromQL',
+				component: <PromQLQueryContainer />,
+			},
+		};
+
+		return supportedQueryTypes.map((queryType) => ({
+			key: queryType,
+			label: (
+				<div className={styles.queryTypeTab}>
+					{queryTypeComponents[queryType].icon}
+					<Typography>{queryTypeComponents[queryType].label}</Typography>
+				</div>
+			),
+			children: queryTypeComponents[queryType].component,
+		}));
+	}, [panelType, filterConfigs, isDarkMode]);
+
+	return (
+		<div
+			className={styles.container}
+			data-testid="panel-editor-v2-query-builder"
+			onKeyDownCapture={handleKeyDownCapture}
+			role="presentation"
+		>
+			<div className={styles.scrollArea}>
+				<Tabs
+					type="card"
+					className={styles.tabsContainer}
+					activeKey={currentQuery.queryType}
+					onChange={handleQueryCategoryChange}
+					tabBarExtraContent={
+						<span className={styles.runQueryBtnContainer}>
+							<TextToolTip text="This will temporarily save the current query and graph state. This will persist across tab change" />
+							<RunQueryBtn
+								className="run-query-dashboard-btn"
+								label="Stage & Run Query"
+								onStageRunQuery={onStageRunQuery}
+								isLoadingQueries={isLoadingQueries}
+								handleCancelQuery={onCancelQuery}
+							/>
+						</span>
+					}
+					items={items}
+				/>
+			</div>
+			{footer}
+		</div>
+	);
+}
+
+export default PanelEditorQueryBuilder;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PreviewPane/PlotTag.tsx

@@ -0,0 +1,35 @@
+import { Spline } from '@signozhq/icons';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import QueryTypeTag from 'container/NewWidget/LeftContainer/QueryTypeTag';
+import { EQueryType } from 'types/common/dashboard';
+
+interface PlotTagProps {
+	/** Authoring mode of the panel's query; undefined when no query exists yet. */
+	queryType: EQueryType | undefined;
+	panelType: PANEL_TYPES;
+	className?: string;
+}
+
+/**
+ * "Plotted with <query mode>" chip for the editor preview; V2 counterpart of V1's
+ * PlotTag (duplicated per the split policy). Hidden for list panels and before a
+ * query exists, where the mode is irrelevant.
+ */
+function PlotTag({
+	queryType,
+	panelType,
+	className,
+}: PlotTagProps): JSX.Element | null {
+	if (queryType === undefined || panelType === PANEL_TYPES.LIST) {
+		return null;
+	}
+
+	return (
+		<div className={className} data-testid="panel-editor-plot-tag">
+			<Spline size={14} />
+			Plotted with <QueryTypeTag queryType={queryType} />
+		</div>
+	);
+}
+
+export default PlotTag;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PreviewPane/PreviewPane.module.scss

@@ -0,0 +1,65 @@
+.preview {
+	display: flex;
+	flex-direction: column;
+	height: 100%;
+	gap: 16px;
+	padding: 24px;
+	background-image: radial-gradient(var(--l2-border) 1px, transparent 0);
+	background-size: 20px 20px;
+	border-bottom: 1px solid var(--l1-border);
+}
+
+.header {
+	width: 100%;
+	box-sizing: border-box;
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+}
+
+.queryType {
+	display: inline-flex;
+	padding: 4px 8px 4px 6px;
+	align-items: center;
+	gap: 6px;
+	border-radius: 4px;
+	background: var(--l3-background);
+	backdrop-filter: blur(6px);
+	width: fit-content;
+}
+
+.container {
+	display: flex;
+	flex: 1;
+	min-width: 0;
+	min-height: 0;
+}
+
+.surface {
+	flex: 1;
+	min-width: 0;
+	min-height: 0;
+	border: 1px solid var(--l2-border);
+	border-radius: 4px;
+	overflow: hidden;
+	display: flex;
+	// Header stacks above the body, flush to the border — mirrors the dashboard
+	// grid's `.panel` so the preview reads as the real panel chrome.
+	flex-direction: column;
+	background: var(--l2-background);
+}
+
+.state {
+	flex: 1;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	padding: 24px;
+	color: var(--l2-forground);
+	font-size: 13px;
+	text-align: center;
+}
+
+.dateTimeSelector {
+	margin-left: auto;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PreviewPane/PreviewPane.tsx

@@ -0,0 +1,107 @@
+import { useState } from 'react';
+import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
+import { PanelMode } from 'container/DashboardContainer/visualization/panels/types';
+import DateTimeSelectionV2 from 'container/TopNav/DateTimeSelectionV2';
+import PanelBody from 'pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelBody/PanelBody';
+import PanelHeader from 'pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelHeader/PanelHeader';
+import type { RenderablePanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelDefinition';
+import { PANEL_KIND_TO_PANEL_TYPE } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
+import { getPanelQueryType } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/getPanelQueryType';
+import type {
+	PanelPagination,
+	PanelQueryData,
+} from 'pages/DashboardPageV2/DashboardContainer/queryV5/types';
+
+import PlotTag from './PlotTag';
+import styles from './PreviewPane.module.scss';
+
+interface PreviewPaneProps {
+	panelId: string;
+	panel: DashboardtypesPanelDTO;
+	/** Resolved definition for the panel kind; */
+	panelDefinition: RenderablePanelDefinition;
+	data: PanelQueryData;
+	isLoading: boolean;
+	/** Background refresh in flight — drives the header's subtle refetch spinner. */
+	isFetching: boolean;
+	error: Error | null;
+	/** Re-run the query (drives PanelBody's error-state retry). */
+	refetch: () => void;
+	/** Drag-to-zoom on a time-axis chart → updates the (URL-synced) time window. */
+	onDragSelect: (start: number, end: number) => void;
+	/** Server-side pager for raw/list panels; absent for non-paginated panels. */
+	pagination?: PanelPagination;
+}
+
+/**
+ * Live preview for the panel editor: renders the draft through the same `PanelBody`
+ * the dashboard grid uses (only `panelMode` differs), so the preview is the
+ * production render path. The query result is owned by the editor root.
+ */
+function PreviewPane({
+	panelId,
+	panel,
+	panelDefinition,
+	data,
+	isLoading,
+	isFetching,
+	error,
+	refetch,
+	onDragSelect,
+	pagination,
+}: PreviewPaneProps): JSX.Element {
+	const panelType = PANEL_KIND_TO_PANEL_TYPE[panel.spec.plugin.kind];
+	const queryType = getPanelQueryType(panel);
+
+	// Search term is ephemeral preview state, threaded to header + renderer but
+	// not persisted to the draft spec. Only kinds that declare it render the box.
+	const searchable = !!panelDefinition.actions.search;
+	const [searchTerm, setSearchTerm] = useState('');
+
+	return (
+		<div className={styles.preview}>
+			<div className={styles.header}>
+				<PlotTag
+					queryType={queryType}
+					panelType={panelType}
+					className={styles.queryType}
+				/>
+				<div className={styles.dateTimeSelector}>
+					<DateTimeSelectionV2 showAutoRefresh hideShareModal />
+				</div>
+			</div>
+			<div className={styles.container}>
+				<div className={styles.surface}>
+					<PanelHeader
+						name={panel.spec.display.name}
+						description={panel.spec.display?.description}
+						panelId={panelId}
+						panelKind={panel.spec.plugin.kind}
+						isFetching={isFetching}
+						error={error}
+						warning={data.response?.data?.warning}
+						searchable={searchable}
+						searchTerm={searchTerm}
+						onSearchChange={setSearchTerm}
+						hideActions
+					/>
+					<PanelBody
+						panelDefinition={panelDefinition}
+						panel={panel}
+						panelId={panelId}
+						data={data}
+						isLoading={isLoading}
+						error={error}
+						refetch={refetch}
+						onDragSelect={onDragSelect}
+						panelMode={PanelMode.DASHBOARD_EDIT}
+						searchTerm={searchable ? searchTerm : undefined}
+						pagination={pagination}
+					/>
+				</div>
+			</div>
+		</div>
+	);
+}
+
+export default PreviewPane;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/PreviewPane/__tests__/PlotTag.test.tsx

@@ -0,0 +1,30 @@
+import { render, screen } from '@testing-library/react';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { EQueryType } from 'types/common/dashboard';
+
+import PlotTag from '../PlotTag';
+
+describe('PlotTag', () => {
+	it('renders the resolved query mode', () => {
+		render(
+			<PlotTag queryType={EQueryType.PROM} panelType={PANEL_TYPES.TIME_SERIES} />,
+		);
+		expect(screen.getByTestId('panel-editor-plot-tag')).toBeInTheDocument();
+		expect(screen.getByText('PromQL')).toBeInTheDocument();
+	});
+
+	it('renders nothing when there is no query yet', () => {
+		render(<PlotTag queryType={undefined} panelType={PANEL_TYPES.TIME_SERIES} />);
+		expect(screen.queryByTestId('panel-editor-plot-tag')).not.toBeInTheDocument();
+	});
+
+	it('renders nothing for list panels (query mode is irrelevant)', () => {
+		render(
+			<PlotTag
+				queryType={EQueryType.QUERY_BUILDER}
+				panelType={PANEL_TYPES.LIST}
+			/>,
+		);
+		expect(screen.queryByTestId('panel-editor-plot-tag')).not.toBeInTheDocument();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/__tests__/getSwitchedPluginSpec.test.ts

@@ -0,0 +1,90 @@
+import {
+	TelemetrytypesSignalDTO,
+	type DashboardtypesPanelSpecDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { getPanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/registry';
+
+import { defaultColumnsForSignal } from '../ListColumnsEditor/selectFields';
+import { getSwitchedPluginSpec } from '../getSwitchedPluginSpec';
+
+jest.mock('pages/DashboardPageV2/DashboardContainer/Panels/registry', () => ({
+	getPanelDefinition: jest.fn(),
+}));
+jest.mock('../ListColumnsEditor/selectFields', () => ({
+	defaultColumnsForSignal: jest.fn(),
+}));
+
+const mockGetPanelDefinition = getPanelDefinition as unknown as jest.Mock;
+const mockDefaultColumnsForSignal =
+	defaultColumnsForSignal as unknown as jest.Mock;
+
+function specWith(pluginSpec: unknown): DashboardtypesPanelSpecDTO {
+	return {
+		display: { name: 'Panel' },
+		plugin: { kind: 'signoz/TablePanel', spec: pluginSpec },
+		queries: [],
+	} as unknown as DashboardtypesPanelSpecDTO;
+}
+
+describe('getSwitchedPluginSpec', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockDefaultColumnsForSignal.mockReturnValue([]);
+	});
+
+	it('carries only unit + decimalPrecision when the new kind has a formatting section', () => {
+		mockGetPanelDefinition.mockReturnValue({
+			sections: [{ kind: 'formatting', controls: { unit: true, decimals: true } }],
+		});
+		const old = specWith({
+			formatting: { unit: 'ms', decimalPrecision: 2, columnUnits: { A: 'bytes' } },
+			axes: { logScale: true },
+		});
+
+		const result = getSwitchedPluginSpec(old, 'signoz/TimeSeriesPanel');
+
+		expect(result.formatting).toStrictEqual({ unit: 'ms', decimalPrecision: 2 });
+		// Type-specific config from the old kind is dropped.
+		expect((result as { axes?: unknown }).axes).toBeUndefined();
+	});
+
+	it('does not carry formatting when the new kind has no formatting section', () => {
+		mockGetPanelDefinition.mockReturnValue({ sections: [{ kind: 'columns' }] });
+		const old = specWith({ formatting: { unit: 'ms' } });
+
+		const result = getSwitchedPluginSpec(
+			old,
+			'signoz/ListPanel',
+			TelemetrytypesSignalDTO.logs,
+		);
+
+		expect(result.formatting).toBeUndefined();
+	});
+
+	it('seeds List columns from the signal when switching into a List', () => {
+		const columns = [{ name: 'body' }];
+		mockDefaultColumnsForSignal.mockReturnValue(columns);
+		mockGetPanelDefinition.mockReturnValue({ sections: [{ kind: 'columns' }] });
+
+		const result = getSwitchedPluginSpec(
+			specWith({}),
+			'signoz/ListPanel',
+			TelemetrytypesSignalDTO.logs,
+		);
+
+		expect(mockDefaultColumnsForSignal).toHaveBeenCalledWith(
+			TelemetrytypesSignalDTO.logs,
+		);
+		expect(result.selectFields).toBe(columns);
+	});
+
+	it('includes the kind section defaults (e.g. legend position)', () => {
+		mockGetPanelDefinition.mockReturnValue({
+			sections: [{ kind: 'legend', controls: { position: true } }],
+		});
+
+		const result = getSwitchedPluginSpec(specWith({}), 'signoz/PieChartPanel');
+
+		expect(result.legend?.position).toBe('bottom');
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/__tests__/newPanelRoute.test.ts

@@ -0,0 +1,34 @@
+import {
+	NEW_PANEL_ID,
+	newPanelSearch,
+	parseNewPanelKind,
+	parseNewPanelLayoutIndex,
+} from '../newPanelRoute';
+
+describe('newPanelRoute', () => {
+	it('round-trips kind + layoutIndex through the new-panel search', () => {
+		const search = newPanelSearch('signoz/ListPanel', 2);
+		expect(parseNewPanelKind(NEW_PANEL_ID, search)).toBe('signoz/ListPanel');
+		expect(parseNewPanelLayoutIndex(search)).toBe(2);
+	});
+
+	it('omits layoutIndex when not provided', () => {
+		const search = newPanelSearch('signoz/TimeSeriesPanel');
+		expect(parseNewPanelKind(NEW_PANEL_ID, search)).toBe(
+			'signoz/TimeSeriesPanel',
+		);
+		expect(parseNewPanelLayoutIndex(search)).toBeUndefined();
+	});
+
+	it('returns null for an existing panel id (not the new sentinel)', () => {
+		const search = newPanelSearch('signoz/ListPanel');
+		expect(parseNewPanelKind('a1b2c3d4-uuid', search)).toBeNull();
+	});
+
+	it('returns null when the kind param is missing or unknown', () => {
+		expect(parseNewPanelKind(NEW_PANEL_ID, '')).toBeNull();
+		expect(
+			parseNewPanelKind(NEW_PANEL_ID, '?panelKind=NotARealPanel'),
+		).toBeNull();
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/getSwitchedPluginSpec.ts

@@ -0,0 +1,67 @@
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+	TelemetrytypesTelemetryFieldKeyDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { getPanelDefinition } from 'pages/DashboardPageV2/DashboardContainer/Panels/registry';
+import type { PanelKind } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/panelKind';
+import type { PanelFormattingSlice } from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+import {
+	buildDefaultPluginSpec,
+	type DefaultPluginSpec,
+} from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/buildDefaultPluginSpec';
+
+import { defaultColumnsForSignal } from './ListColumnsEditor/selectFields';
+
+/**
+ * Plugin spec produced on a first-time switch to a new kind. A partial cross-section
+ * of the per-kind spec union; the caller assigns it to `plugin.spec` (typed `unknown`)
+ * at the boundary.
+ */
+export interface SwitchedPluginSpec extends DefaultPluginSpec {
+	formatting?: Pick<PanelFormattingSlice, 'unit' | 'decimalPrecision'>;
+	selectFields?: TelemetrytypesTelemetryFieldKeyDTO[];
+}
+
+/**
+ * Builds the plugin spec for a first-visit switch to `newKind`: the kind's declared
+ * section defaults (so the config pane opens populated, matching new-panel seeding) plus
+ * the only cross-kind config worth keeping — unit + decimal precision. Switching into a
+ * List seeds the current signal's default columns so the columns control isn't empty.
+ *
+ * Revisiting a kind restores its stashed spec instead, so this runs only on first visit.
+ */
+export function getSwitchedPluginSpec(
+	oldSpec: DashboardtypesPanelSpecDTO,
+	newKind: PanelKind,
+	signal?: TelemetrytypesSignalDTO,
+): SwitchedPluginSpec {
+	const sections = getPanelDefinition(newKind)?.sections ?? [];
+	const result: SwitchedPluginSpec = buildDefaultPluginSpec(sections);
+
+	if (sections.some((section) => section.kind === 'formatting')) {
+		const oldFormatting = (
+			oldSpec.plugin.spec as {
+				formatting?: PanelFormattingSlice;
+			}
+		).formatting;
+		const carried: Pick<PanelFormattingSlice, 'unit' | 'decimalPrecision'> = {
+			...(oldFormatting?.unit !== undefined && { unit: oldFormatting.unit }),
+			...(oldFormatting?.decimalPrecision !== undefined && {
+				decimalPrecision: oldFormatting.decimalPrecision,
+			}),
+		};
+		if (Object.keys(carried).length > 0) {
+			result.formatting = carried;
+		}
+	}
+
+	if (sections.some((section) => section.kind === 'columns') && signal) {
+		const columns = defaultColumnsForSignal(signal);
+		if (columns.length > 0) {
+			result.selectFields = columns;
+		}
+	}
+
+	return result;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/useLegendSeries.test.ts

@@ -0,0 +1,102 @@
+import { renderHook } from '@testing-library/react';
+import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
+import { useIsDarkMode } from 'hooks/useDarkMode';
+import { generateColor } from 'lib/uPlotLib/utils/generateColor';
+import { resolveSeriesLabelV5 } from 'pages/DashboardPageV2/DashboardContainer/Panels/utils/resolveSeriesLabel';
+import type { PanelQueryData } from 'pages/DashboardPageV2/DashboardContainer/queryV5/types';
+import { flattenTimeSeries } from 'pages/DashboardPageV2/DashboardContainer/queryV5/v5ResponseData';
+
+import { useLegendSeries } from '../useLegendSeries';
+
+jest.mock('hooks/useDarkMode', () => ({ useIsDarkMode: jest.fn() }));
+jest.mock('lib/getLabelName', () => jest.fn(() => 'base'));
+jest.mock('lib/uPlotLib/utils/generateColor', () => ({
+	generateColor: jest.fn((label: string) => `color:${label}`),
+}));
+jest.mock('constants/theme', () => ({
+	themeColors: { chartcolors: ['dark'], lightModeColor: ['light'] },
+}));
+jest.mock(
+	'pages/DashboardPageV2/DashboardContainer/Panels/utils/getBuilderQueries',
+	() => ({ getBuilderQueries: jest.fn(() => []) }),
+);
+jest.mock(
+	'pages/DashboardPageV2/DashboardContainer/Panels/utils/resolveSeriesLabel',
+	() => ({ resolveSeriesLabelV5: jest.fn() }),
+);
+jest.mock(
+	'pages/DashboardPageV2/DashboardContainer/queryV5/v5ResponseData',
+	() => ({
+		flattenTimeSeries: jest.fn(),
+		getTimeSeriesResults: jest.fn(() => []),
+	}),
+);
+
+const mockUseIsDarkMode = useIsDarkMode as unknown as jest.Mock;
+const mockFlatten = flattenTimeSeries as unknown as jest.Mock;
+const mockResolveLabel = resolveSeriesLabelV5 as unknown as jest.Mock;
+const mockGenerateColor = generateColor as unknown as jest.Mock;
+
+const PANEL = {
+	kind: 'Panel',
+	spec: { plugin: { kind: 'signoz/TimeSeriesPanel', spec: {} }, queries: [] },
+} as unknown as DashboardtypesPanelDTO;
+const DATA = { response: {}, legendMap: {} } as unknown as PanelQueryData;
+
+// Each flattened series carries the label resolveSeriesLabelV5 should report.
+function seriesWithLabels(labels: string[]): { __label: string }[] {
+	return labels.map((__label) => ({ __label }));
+}
+
+describe('useLegendSeries', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockUseIsDarkMode.mockReturnValue(true);
+		mockResolveLabel.mockImplementation((s: { __label: string }) => s.__label);
+	});
+
+	it('is empty when there are no series', () => {
+		mockFlatten.mockReturnValue([]);
+		const { result } = renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(result.current).toStrictEqual([]);
+	});
+
+	it('maps each series to a { label, defaultColor } pair', () => {
+		mockFlatten.mockReturnValue(seriesWithLabels(['a', 'b']));
+		const { result } = renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(result.current).toStrictEqual([
+			{ label: 'a', defaultColor: 'color:a' },
+			{ label: 'b', defaultColor: 'color:b' },
+		]);
+	});
+
+	it('dedupes by label, keeping first-seen order', () => {
+		mockFlatten.mockReturnValue(seriesWithLabels(['a', 'b', 'a', 'c']));
+		const { result } = renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(result.current.map((s) => s.label)).toStrictEqual(['a', 'b', 'c']);
+		// The duplicate 'a' must not generate a second color.
+		expect(
+			mockGenerateColor.mock.calls.filter(([label]) => label === 'a'),
+		).toHaveLength(1);
+	});
+
+	it('skips series that resolve to an empty label', () => {
+		mockFlatten.mockReturnValue(seriesWithLabels(['', 'a', '']));
+		const { result } = renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(result.current).toStrictEqual([
+			{ label: 'a', defaultColor: 'color:a' },
+		]);
+	});
+
+	it('uses the dark palette in dark mode and the light palette otherwise', () => {
+		mockFlatten.mockReturnValue(seriesWithLabels(['a']));
+
+		const dark = renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(mockGenerateColor).toHaveBeenLastCalledWith('a', ['dark']);
+		dark.unmount();
+
+		mockUseIsDarkMode.mockReturnValue(false);
+		renderHook(() => useLegendSeries(PANEL, DATA));
+		expect(mockGenerateColor).toHaveBeenLastCalledWith('a', ['light']);
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorDraft.test.ts

@@ -0,0 +1,93 @@
+import { act, renderHook } from '@testing-library/react';
+import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
+
+import { usePanelEditorDraft } from '../usePanelEditorDraft';
+
+function panel(name = 'CPU', description = 'usage'): DashboardtypesPanelDTO {
+	return {
+		kind: 'Panel',
+		spec: {
+			display: { name, description },
+			plugin: { kind: 'signoz/TimeSeriesPanel', spec: {} },
+			queries: [],
+		},
+	} as unknown as DashboardtypesPanelDTO;
+}
+
+describe('usePanelEditorDraft', () => {
+	it('exposes the panel spec and starts clean', () => {
+		const { result } = renderHook(() => usePanelEditorDraft(panel()));
+
+		expect(result.current.spec).toBe(result.current.draft.spec);
+		expect(result.current.spec.display?.name).toBe('CPU');
+		expect(result.current.isSpecDirty).toBe(false);
+	});
+
+	it('flags dirty and writes through on a display (title) edit via setSpec', () => {
+		const { result } = renderHook(() => usePanelEditorDraft(panel()));
+
+		act(() =>
+			result.current.setSpec({
+				...result.current.spec,
+				display: { ...result.current.spec.display, name: 'Memory' },
+			}),
+		);
+
+		expect(result.current.isSpecDirty).toBe(true);
+		expect(result.current.draft.spec?.display?.name).toBe('Memory');
+	});
+
+	it('flags dirty on a plugin-spec (non-display) edit', () => {
+		const { result } = renderHook(() => usePanelEditorDraft(panel()));
+
+		act(() =>
+			result.current.setSpec({
+				...result.current.spec,
+				plugin: {
+					kind: 'signoz/TimeSeriesPanel',
+					spec: { formatting: { unit: 'bytes' } },
+				},
+			} as typeof result.current.spec),
+		);
+
+		expect(result.current.isSpecDirty).toBe(true);
+		expect(
+			(
+				result.current.draft.spec?.plugin?.spec as {
+					formatting?: { unit?: string };
+				}
+			)?.formatting?.unit,
+		).toBe('bytes');
+	});
+
+	it('does not flag spec-dirty when only spec.queries changes (owned by the builder)', () => {
+		const { result } = renderHook(() => usePanelEditorDraft(panel()));
+
+		act(() =>
+			result.current.setSpec({
+				...result.current.spec,
+				queries: [{ id: 'committed-by-builder' }],
+			} as unknown as typeof result.current.spec),
+		);
+
+		expect(result.current.isSpecDirty).toBe(false);
+	});
+
+	it('reset restores the spec and clears dirty after an edit', () => {
+		const { result } = renderHook(() => usePanelEditorDraft(panel()));
+
+		act(() =>
+			result.current.setSpec({
+				...result.current.spec,
+				plugin: {
+					kind: 'signoz/TimeSeriesPanel',
+					spec: { formatting: { unit: 'ms' } },
+				},
+			} as typeof result.current.spec),
+		);
+		act(() => result.current.reset());
+
+		expect(result.current.isSpecDirty).toBe(false);
+		expect(result.current.spec.display?.name).toBe('CPU');
+	});
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelEditor/hooks/__tests__/usePanelEditorQuerySync.test.ts

@@ -0,0 +1,331 @@
+import { renderHook } from '@testing-library/react';
+import type {
+	DashboardtypesPanelDTO,
+	DashboardtypesPanelSpecDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { getIsQueryModified } from 'container/NewWidget/utils';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useShareBuilderUrl } from 'hooks/queryBuilder/useShareBuilderUrl';
+import type { Query } from 'types/api/queryBuilder/queryBuilderData';
+
+import { fromPerses, toPerses } from '../../../queryV5/persesQueryAdapters';
+import { usePanelEditorQuerySync } from '../usePanelEditorQuerySync';
+
+jest.mock('hooks/queryBuilder/useQueryBuilder', () => ({
+	useQueryBuilder: jest.fn(),
+}));
+jest.mock('hooks/queryBuilder/useShareBuilderUrl', () => ({
+	useShareBuilderUrl: jest.fn(),
+}));
+jest.mock('container/NewWidget/utils', () => ({
+	getIsQueryModified: jest.fn(),
+}));
+jest.mock('../../../queryV5/persesQueryAdapters', () => ({
+	fromPerses: jest.fn(),
+	toPerses: jest.fn(),
+}));
+// commitQuery's no-op guard compares queries at the envelope level; with the
+// adapters mocked, unwrap identity-style so the opaque fixtures stay distinct
+// (CONVERTED vs SAVED) and the commit decisions are what's under test.
+jest.mock('../../../queryV5/buildQueryRangeRequest', () => ({
+	toQueryEnvelopes: jest.fn((queries: unknown) => queries),
+}));
+
+const mockUseQueryBuilder = useQueryBuilder as unknown as jest.Mock;
+const mockUseShareBuilderUrl = useShareBuilderUrl as unknown as jest.Mock;
+const mockGetIsQueryModified = getIsQueryModified as unknown as jest.Mock;
+const mockFromPerses = fromPerses as unknown as jest.Mock;
+const mockToPerses = toPerses as unknown as jest.Mock;
+
+// Opaque fixtures — the adapters are mocked, so only identity matters here.
+const SAVED_QUERIES = [{ id: 'saved' }] as unknown as NonNullable<
+	DashboardtypesPanelSpecDTO['queries']
+>;
+const CONVERTED_QUERIES = [{ id: 'converted' }] as unknown as NonNullable<
+	DashboardtypesPanelSpecDTO['queries']
+>;
+const SEED_V1 = { id: 'seed', queryType: 'builder' } as unknown as Query;
+const STAGED_V1 = { id: 'staged', queryType: 'builder' } as unknown as Query;
+
+function makeDraft(
+	queries = SAVED_QUERIES,
+	kind = 'signoz/TimeSeriesPanel',
+): DashboardtypesPanelDTO {
+	return {
+		kind: 'Panel',
+		spec: {
+			display: { name: 'Panel' },
+			plugin: { kind, spec: {} },
+			queries,
+		},
+	} as unknown as DashboardtypesPanelDTO;
+}
+
+function builderState(
+	overrides: Partial<{
+		currentQuery: Query;
+		stagedQuery: Query | null;
+		handleRunQuery: jest.Mock;
+	}> = {},
+): {
+	currentQuery: Query;
+	stagedQuery: Query | null;
+	handleRunQuery: jest.Mock;
+} {
+	return {
+		currentQuery: { id: 'current', queryType: 'builder' } as unknown as Query,
+		stagedQuery: STAGED_V1,
+		handleRunQuery: jest.fn(),
+		...overrides,
+	};
+}
+
+describe('usePanelEditorQuerySync', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+		mockFromPerses.mockReturnValue(SEED_V1);
+		mockToPerses.mockReturnValue(CONVERTED_QUERIES);
+		mockGetIsQueryModified.mockReturnValue(false);
+		mockUseQueryBuilder.mockReturnValue(builderState());
+	});
+
+	function setup(
+		opts: {
+			draft?: DashboardtypesPanelDTO;
+			setSpec?: jest.Mock;
+			refetch?: jest.Mock;
+		} = {},
+	): {
+		result: {
+			current: {
+				runQuery: () => void;
+				isQueryDirty: boolean;
+				buildSaveSpec: (
+					spec: DashboardtypesPanelSpecDTO,
+				) => DashboardtypesPanelSpecDTO;
+			};
+		};
+		setSpec: jest.Mock;
+		refetch: jest.Mock;
+		rerender: () => void;
+	} {
+		const setSpec = opts.setSpec ?? jest.fn();
+		const refetch = opts.refetch ?? jest.fn();
+		const draft = opts.draft ?? makeDraft();
+		const { result, rerender } = renderHook(() =>
+			usePanelEditorQuerySync({
+				draft,
+				panelType: PANEL_TYPES.TIME_SERIES,
+				setSpec,
+				refetch,
+			}),
+		);
+		return { result, setSpec, refetch, rerender };
+	}
+
+	it('force-resets the builder to the saved queries on mount (discards stale URL)', () => {
+		setup();
+		expect(mockFromPerses).toHaveBeenCalledWith(
+			SAVED_QUERIES,
+			PANEL_TYPES.TIME_SERIES,
+		);
+		expect(mockUseShareBuilderUrl).toHaveBeenCalledWith({
+			defaultValue: SEED_V1,
+			forceReset: true,
+		});
+	});
+
+	it('does not touch the draft on mount for an unedited panel', () => {
+		const { setSpec, refetch } = setup();
+		// Mount runs the type-change effect once; an unedited query must no-op.
+		expect(setSpec).not.toHaveBeenCalled();
+		expect(refetch).not.toHaveBeenCalled();
+	});
+
+	it('compares the live query against the saved query (seed), not the staged query', () => {
+		const currentQuery = { id: 'current', queryType: 'builder' } as Query;
+		mockUseQueryBuilder.mockReturnValue(builderState({ currentQuery }));
+
+		const { result } = setup();
+		result.current.runQuery();
+
+		// Baseline is the saved seed — a stale staged/URL query must not be the
+		// reference, or a real datasource switch would read as "unchanged".
+		expect(mockGetIsQueryModified).toHaveBeenCalledWith(currentQuery, SEED_V1);
+	});
+
+	describe('runQuery', () => {
+		it('stages the query (handleRunQuery)', () => {
+			const handleRunQuery = jest.fn();
+			mockUseQueryBuilder.mockReturnValue(builderState({ handleRunQuery }));
+			const { result } = setup();
+
+			result.current.runQuery();
+
+			expect(handleRunQuery).toHaveBeenCalledTimes(1);
+		});
+
+		it('commits a modified query into the draft and does not force a refetch', () => {
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result, setSpec, refetch } = setup();
+
+			result.current.runQuery();
+
+			expect(setSpec).toHaveBeenCalledWith({
+				...makeDraft().spec,
+				queries: CONVERTED_QUERIES,
+			});
+			expect(refetch).not.toHaveBeenCalled();
+		});
+
+		it('forces a refetch and leaves the draft alone when the query is unchanged', () => {
+			mockGetIsQueryModified.mockReturnValue(false);
+			const { result, setSpec, refetch } = setup();
+
+			result.current.runQuery();
+
+			expect(setSpec).not.toHaveBeenCalled();
+			expect(refetch).toHaveBeenCalledTimes(1);
+		});
+
+		it('commits a datasource switch even when the staged query is stale (no revert to saved)', () => {
+			// A stale staged query (e.g. URL-restored after refresh) must not be used
+			// as the baseline; the switch is detected against the saved seed and the
+			// live query is committed so the preview fetches it.
+			mockUseQueryBuilder.mockReturnValue(builderState({ stagedQuery: null }));
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result, setSpec, refetch } = setup();
+
+			result.current.runQuery();
+
+			expect(setSpec).toHaveBeenCalledWith({
+				...makeDraft().spec,
+				queries: CONVERTED_QUERIES,
+			});
+			expect(refetch).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('query-type switch', () => {
+		it('commits the active query when the query type changes', () => {
+			const state = builderState({
+				currentQuery: { id: 'a', queryType: 'builder' } as Query,
+			});
+			mockUseQueryBuilder.mockImplementation(() => state);
+			mockGetIsQueryModified.mockReturnValue(true);
+
+			const { setSpec, rerender } = setup();
+			setSpec.mockClear();
+
+			// Switch query type → the effect should commit.
+			state.currentQuery = { id: 'b', queryType: 'promql' } as Query;
+			rerender();
+
+			expect(setSpec).toHaveBeenCalledWith({
+				...makeDraft().spec,
+				queries: CONVERTED_QUERIES,
+			});
+		});
+
+		it('does not commit when the active query type is unchanged', () => {
+			const state = builderState({
+				currentQuery: { id: 'a', queryType: 'builder' } as Query,
+			});
+			mockUseQueryBuilder.mockImplementation(() => state);
+			mockGetIsQueryModified.mockReturnValue(true);
+
+			const { setSpec, rerender } = setup();
+			setSpec.mockClear();
+
+			// Same query type, different object → effect must not re-fire.
+			state.currentQuery = { id: 'b', queryType: 'builder' } as Query;
+			rerender();
+
+			expect(setSpec).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('datasource switch', () => {
+		const withSource = (id: string, dataSource: string): Query =>
+			({
+				id,
+				queryType: 'builder',
+				builder: { queryData: [{ dataSource }] },
+			}) as unknown as Query;
+
+		it('commits the active query when a query datasource changes', () => {
+			const state = builderState({ currentQuery: withSource('a', 'logs') });
+			mockUseQueryBuilder.mockImplementation(() => state);
+			mockGetIsQueryModified.mockReturnValue(true);
+
+			const { setSpec, rerender } = setup();
+			setSpec.mockClear();
+
+			// Switch datasource logs → traces → the effect should commit (→ refetch).
+			state.currentQuery = withSource('b', 'traces');
+			rerender();
+
+			expect(setSpec).toHaveBeenCalledWith({
+				...makeDraft().spec,
+				queries: CONVERTED_QUERIES,
+			});
+		});
+
+		it('does not commit when the datasource is unchanged', () => {
+			const state = builderState({ currentQuery: withSource('a', 'logs') });
+			mockUseQueryBuilder.mockImplementation(() => state);
+			mockGetIsQueryModified.mockReturnValue(true);
+
+			const { setSpec, rerender } = setup();
+			setSpec.mockClear();
+
+			// Same datasource, different object → effect must not re-fire.
+			state.currentQuery = withSource('b', 'logs');
+			rerender();
+
+			expect(setSpec).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('query dirty + save', () => {
+		it('compares the live query against the builder baseline (first staged query), not the raw seed', () => {
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result } = setup();
+
+			// Baseline is the builder's own normalized staged query — immune to the
+			// raw-seed vs builder-normalized serialization drift.
+			expect(mockGetIsQueryModified).toHaveBeenCalledWith(
+				expect.anything(),
+				STAGED_V1,
+			);
+			expect(result.current.isQueryDirty).toBe(true);
+		});
+
+		it('is not query-dirty when the live query matches the baseline', () => {
+			mockGetIsQueryModified.mockReturnValue(false);
+			const { result } = setup();
+
+			expect(result.current.isQueryDirty).toBe(false);
+		});
+
+		it('buildSaveSpec bakes the live query in when dirty', () => {
+			mockGetIsQueryModified.mockReturnValue(true);
+			const { result } = setup();
+			const { spec } = makeDraft();
+
+			expect(result.current.buildSaveSpec(spec)).toStrictEqual({
+				...spec,
+				queries: CONVERTED_QUERIES,
+			});
+		});
+
+		it('buildSaveSpec returns the spec untouched when the query is unchanged', () => {
+			mockGetIsQueryModified.mockReturnValue(false);
+			const { result } = setup();
+			const { spec } = makeDraft();
+
+			expect(result.current.buildSaveSpec(spec)).toBe(spec);
+		});
+	});
+});