feat(dashboards-v2): resizable, persisted table columns

Replace the plain status tooltip with a card: variant-coloured icon, the
error/warning code and message, an optional Open Docs link, a MESSAGES
count pill, and the per-item message list. Hosted in @signozhq/ui
TooltipSimple with its padding/width cap stripped so the card owns its
own layout. Bump the header actions gap so the status icon sits clear of
its neighbours.

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.129.0
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.129.0
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.129.0}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.129.0}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

docs/api/openapi.yml

@@ -6992,16 +6992,6 @@ components:
       required:
       - items
       type: object
-    SpantypesGettableSpanMapperTest:
-      properties:
-        spans:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanMapperTestSpan'
-          nullable: true
-          type: array
-      required:
-      - spans
-      type: object
     SpantypesGettableTraceAggregations:
       properties:
         aggregations:
@@ -7089,39 +7079,6 @@ components:
       - name
       - condition
       type: object
-    SpantypesPostableSpanMapperTest:
-      properties:
-        groups:
-          items:
-            $ref: '#/components/schemas/SpantypesPostableSpanMapperTestGroup'
-          nullable: true
-          type: array
-        spans:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanMapperTestSpan'
-          nullable: true
-          type: array
-      required:
-      - spans
-      - groups
-      type: object
-    SpantypesPostableSpanMapperTestGroup:
-      properties:
-        condition:
-          $ref: '#/components/schemas/SpantypesSpanMapperGroupCondition'
-        enabled:
-          type: boolean
-        mappers:
-          items:
-            $ref: '#/components/schemas/SpantypesPostableSpanMapper'
-          nullable: true
-          type: array
-        name:
-          type: string
-      required:
-      - name
-      - condition
-      type: object
     SpantypesPostableTraceAggregations:
       properties:
         aggregations:
@@ -7283,17 +7240,6 @@ components:
       - operation
       - priority
       type: object
-    SpantypesSpanMapperTestSpan:
-      properties:
-        attributes:
-          additionalProperties: {}
-          nullable: true
-          type: object
-        resource:
-          additionalProperties: {}
-          nullable: true
-          type: object
-      type: object
     SpantypesUpdatableSpanMapper:
       properties:
         config:
@@ -12851,69 +12797,6 @@ paths:
       summary: Update a span mapper
       tags:
       - spanmapper
-  /api/v1/span_mapper_groups/test:
-    post:
-      deprecated: false
-      description: Tests how span mappers would transform sample spans
-      operationId: TestSpanMappers
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableSpanMapperTest'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableSpanMapperTest'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Test span mappers against sample spans
-      tags:
-      - spanmapper
   /api/v1/stats:
     get:
       deprecated: false

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 {
 	CreateAlertChannelAlerts,
 	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/api/generated/services/sigNoz.schemas.ts

@@ -8135,44 +8135,6 @@ export interface SpantypesGettableSpanMapperGroupsDTO {
 	items: SpantypesSpanMapperGroupDTO[];
 }
 
-export type SpantypesSpanMapperTestSpanDTOAttributesAnyOf = {
-	[key: string]: unknown;
-};
-
-/**
- * @nullable
- */
-export type SpantypesSpanMapperTestSpanDTOAttributes =
-	SpantypesSpanMapperTestSpanDTOAttributesAnyOf | null;
-
-export type SpantypesSpanMapperTestSpanDTOResourceAnyOf = {
-	[key: string]: unknown;
-};
-
-/**
- * @nullable
- */
-export type SpantypesSpanMapperTestSpanDTOResource =
-	SpantypesSpanMapperTestSpanDTOResourceAnyOf | null;
-
-export interface SpantypesSpanMapperTestSpanDTO {
-	/**
-	 * @type object,null
-	 */
-	attributes?: SpantypesSpanMapperTestSpanDTOAttributes;
-	/**
-	 * @type object,null
-	 */
-	resource?: SpantypesSpanMapperTestSpanDTOResource;
-}
-
-export interface SpantypesGettableSpanMapperTestDTO {
-	/**
-	 * @type array,null
-	 */
-	spans: SpantypesSpanMapperTestSpanDTO[] | null;
-}
-
 export enum SpantypesSpanAggregationTypeDTO {
 	span_count = 'span_count',
 	execution_time_percentage = 'execution_time_percentage',
@@ -8468,33 +8430,6 @@ export interface SpantypesPostableSpanMapperGroupDTO {
 	name: string;
 }
 
-export interface SpantypesPostableSpanMapperTestGroupDTO {
-	condition: SpantypesSpanMapperGroupConditionDTO | null;
-	/**
-	 * @type boolean
-	 */
-	enabled?: boolean;
-	/**
-	 * @type array,null
-	 */
-	mappers?: SpantypesPostableSpanMapperDTO[] | null;
-	/**
-	 * @type string
-	 */
-	name: string;
-}
-
-export interface SpantypesPostableSpanMapperTestDTO {
-	/**
-	 * @type array,null
-	 */
-	groups: SpantypesPostableSpanMapperTestGroupDTO[] | null;
-	/**
-	 * @type array,null
-	 */
-	spans: SpantypesSpanMapperTestSpanDTO[] | null;
-}
-
 export interface SpantypesSpanAggregationDTO {
 	aggregation: SpantypesSpanAggregationTypeDTO;
 	field: TelemetrytypesTelemetryFieldKeyDTO;
@@ -9863,14 +9798,6 @@ export type UpdateSpanMapperPathParameters = {
 	groupId: string;
 	mapperId: string;
 };
-export type TestSpanMappers200 = {
-	data: SpantypesGettableSpanMapperTestDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetStats200Data = { [key: string]: unknown };
 
 export type GetStats200 = {

frontend/src/api/generated/services/spanmapper/index.ts

@@ -30,10 +30,8 @@ import type {
 	RenderErrorResponseDTO,
 	SpantypesPostableSpanMapperDTO,
 	SpantypesPostableSpanMapperGroupDTO,
-	SpantypesPostableSpanMapperTestDTO,
 	SpantypesUpdatableSpanMapperDTO,
 	SpantypesUpdatableSpanMapperGroupDTO,
-	TestSpanMappers200,
 	UpdateSpanMapperGroupPathParameters,
 	UpdateSpanMapperPathParameters,
 } from '../sigNoz.schemas';
@@ -782,86 +780,3 @@ export const useUpdateSpanMapper = <
 > => {
 	return useMutation(getUpdateSpanMapperMutationOptions(options));
 };
-/**
- * Tests how span mappers would transform sample spans
- * @summary Test span mappers against sample spans
- */
-export const testSpanMappers = (
-	spantypesPostableSpanMapperTestDTO?: BodyType<SpantypesPostableSpanMapperTestDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<TestSpanMappers200>({
-		url: `/api/v1/span_mapper_groups/test`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableSpanMapperTestDTO,
-		signal,
-	});
-};
-
-export const getTestSpanMappersMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testSpanMappers>>,
-		TError,
-		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof testSpanMappers>>,
-	TError,
-	{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
-	TContext
-> => {
-	const mutationKey = ['testSpanMappers'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof testSpanMappers>>,
-		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> }
-	> = (props) => {
-		const { data } = props ?? {};
-
-		return testSpanMappers(data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type TestSpanMappersMutationResult = NonNullable<
-	Awaited<ReturnType<typeof testSpanMappers>>
->;
-export type TestSpanMappersMutationBody =
-	| BodyType<SpantypesPostableSpanMapperTestDTO>
-	| undefined;
-export type TestSpanMappersMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Test span mappers against sample spans
- */
-export const useTestSpanMappers = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof testSpanMappers>>,
-		TError,
-		{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof testSpanMappers>>,
-	TError,
-	{ data?: BodyType<SpantypesPostableSpanMapperTestDTO> },
-	TContext
-> => {
-	return useMutation(getTestSpanMappersMutationOptions(options));
-};

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/Checkbox.tsx

@@ -1,29 +1,67 @@
 /* eslint-disable sonarjs/no-identical-functions */
 import { Fragment, useMemo, useState } from 'react';
 import { Input } from '@signozhq/ui/input';
-import { Skeleton } from 'antd';
+import { Button, Skeleton } from 'antd';
+import { Checkbox } from '@signozhq/ui/checkbox';
 import { Typography } from '@signozhq/ui/typography';
+import cx from 'classnames';
+import { removeKeysFromExpression } from 'components/QueryBuilderV2/utils';
 import {
 	IQuickFiltersConfig,
 	QuickFiltersSource,
 } from 'components/QuickFilters/types';
+import { OPERATORS } from 'constants/antlrQueryConstants';
+import {
+	DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY,
+	PANEL_TYPES,
+} from 'constants/queryBuilder';
 import { DEBOUNCE_DELAY } from 'constants/queryBuilderFilterConfig';
+import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
+import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
+import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
+import { useGetQueryKeyValueSuggestions } from 'hooks/querySuggestions/useGetQueryKeyValueSuggestions';
 import useDebouncedFn from 'hooks/useDebouncedFunction';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { cloneDeep, isArray, isFunction } from 'lodash-es';
+import { ChevronDown, ChevronRight } from '@signozhq/icons';
+import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
+import { DataSource } from 'types/common/queryBuilder';
+import { v4 as uuid } from 'uuid';
 
-import CheckboxFilterHeader from './CheckboxFilterHeader';
-import CheckboxValueRow from './CheckboxValueRow';
 import LogsQuickFilterEmptyState from './LogsQuickFilterEmptyState';
-import useActiveQueryIndex from './useActiveQueryIndex';
-import useCheckboxDisclosure from './useCheckboxDisclosure';
-import useCheckboxFilterActions from './useCheckboxFilterActions';
-import useCheckboxFilterState from './useCheckboxFilterState';
-import useCheckboxFilterValues from './useCheckboxFilterValues';
+import { isKeyMatch } from './utils';
 
 import './Checkbox.styles.scss';
 
+const SELECTED_OPERATORS = [OPERATORS['='], 'in'];
+const NON_SELECTED_OPERATORS = [OPERATORS['!='], 'not in', 'nin'];
+
 const SOURCES_WITH_EMPTY_STATE_ENABLED = [QuickFiltersSource.LOGS_EXPLORER];
 
+// Sources that use backend APIs expecting short operator format (e.g., 'nin' instead of 'not in')
+const SOURCES_WITH_SHORT_OPERATORS = [QuickFiltersSource.INFRA_MONITORING];
+
+/**
+ * Returns the correct NOT_IN operator value based on source.
+ * InfraMonitoring backend expects 'nin', others expect 'not in'.
+ */
+function getNotInOperator(source: QuickFiltersSource): string {
+	if (SOURCES_WITH_SHORT_OPERATORS.includes(source)) {
+		return 'nin';
+	}
+	return getOperatorValue('NOT_IN');
+}
+
+function setDefaultValues(
+	values: string[],
+	trueOrFalse: boolean,
+): Record<string, boolean> {
+	const defaultState: Record<string, boolean> = {};
+	values.forEach((val) => {
+		defaultState[val] = trueOrFalse;
+	});
+	return defaultState;
+}
 interface ICheckboxProps {
 	filter: IQuickFiltersConfig;
 	source: QuickFiltersSource;
@@ -34,39 +72,194 @@ interface ICheckboxProps {
 export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 	const { source, filter, onFilterChange } = props;
 	const [searchText, setSearchText] = useState<string>('');
-
-	const activeQueryIndex = useActiveQueryIndex(source);
+	// null = no user action, true = user opened, false = user closed
+	const [userToggleState, setUserToggleState] = useState<boolean | null>(null);
+	const [visibleItemsCount, setVisibleItemsCount] = useState<number>(10);
 
 	const {
-		isOpen,
+		lastUsedQuery,
+		currentQuery,
+		redirectWithQueryBuilderData,
+		panelType,
+	} = useQueryBuilder();
+
+	// Determine if we're in ListView mode
+	const isListView = panelType === PANEL_TYPES.LIST;
+	// In ListView mode, use index 0 for most sources; for TRACES_EXPLORER, use lastUsedQuery
+	// Otherwise use lastUsedQuery for non-ListView modes
+	const activeQueryIndex = useMemo(() => {
+		if (isListView) {
+			return source === QuickFiltersSource.TRACES_EXPLORER
+				? lastUsedQuery || 0
+				: 0;
+		}
+		return lastUsedQuery || 0;
+	}, [isListView, source, lastUsedQuery]);
+
+	// Check if this filter has active filters in the query
+	const isSomeFilterPresentForCurrentAttribute = useMemo(
+		() =>
+			currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items?.some(
+				(item) => isKeyMatch(item.key?.key, filter.attributeKey.key),
+			),
+		[currentQuery.builder.queryData, activeQueryIndex, filter.attributeKey.key],
+	);
+
+	// Derive isOpen from filter state + user action
+	const isOpen = useMemo(() => {
+		// If user explicitly toggled, respect that
+		if (userToggleState !== null) {
+			return userToggleState;
+		}
+
+		// Auto-open if this filter has active filters in the query
+		if (isSomeFilterPresentForCurrentAttribute) {
+			return true;
+		}
+
+		// Otherwise use default behavior (first 2 filters open)
+		return filter.defaultOpen;
+	}, [
+		userToggleState,
 		isSomeFilterPresentForCurrentAttribute,
-		visibleItemsCount,
-		onToggleOpen,
-		onShowMore,
-	} = useCheckboxDisclosure({ filter, activeQueryIndex });
+		filter.defaultOpen,
+	]);
 
-	const { attributeValues, isLoading } = useCheckboxFilterValues({
-		filter,
-		source,
-		searchText,
-		isOpen,
-	});
+	const { data, isLoading } = useGetAggregateValues(
+		{
+			aggregateOperator: filter.aggregateOperator || 'noop',
+			dataSource: filter.dataSource || DataSource.LOGS,
+			aggregateAttribute: filter.aggregateAttribute || '',
+			attributeKey: filter.attributeKey.key,
+			filterAttributeKeyDataType: filter.attributeKey.dataType || DataTypes.EMPTY,
+			tagType: filter.attributeKey.type || '',
+			searchText: searchText ?? '',
+		},
+		{
+			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
+			keepPreviousData: true,
+		},
+	);
 
-	const { currentFilterState, isFilterDisabled, isMultipleValuesTrueForTheKey } =
-		useCheckboxFilterState({ filter, attributeValues, activeQueryIndex });
+	const { data: keyValueSuggestions, isLoading: isLoadingKeyValueSuggestions } =
+		useGetQueryKeyValueSuggestions({
+			key: filter.attributeKey.key,
+			signal: filter.dataSource || DataSource.LOGS,
+			signalSource: 'meter',
+			options: {
+				enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
+				keepPreviousData: true,
+			},
+		});
 
-	const { onChange, onClear } = useCheckboxFilterActions({
-		filter,
-		source,
-		attributeValues,
-		activeQueryIndex,
-		onFilterChange,
-	});
+	const attributeValues: string[] = useMemo(() => {
+		const dataType = filter.attributeKey.dataType || DataTypes.String;
+
+		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
+			// Process the response data
+			const responseData = keyValueSuggestions?.data as any;
+			const values = responseData.data?.values || {};
+			const stringValues = values.stringValues || [];
+			const numberValues = values.numberValues || [];
+
+			// Generate options from string values - explicitly handle empty strings
+			const stringOptions = stringValues
+				// Strict filtering for empty string - we'll handle it as a special case if needed
+				.filter(
+					(value: string | null | undefined): value is string =>
+						value !== null && value !== undefined && value !== '',
+				);
+
+			// Generate options from number values
+			const numberOptions = numberValues
+				.filter(
+					(value: number | null | undefined): value is number =>
+						value !== null && value !== undefined,
+				)
+				.map((value: number) => value.toString());
+
+			// Combine all options and make sure we don't have duplicate labels
+			return [...stringOptions, ...numberOptions];
+		}
+
+		const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
+		return (data?.payload?.[key] || []).filter(
+			(val) => val !== undefined && val !== null,
+		);
+	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
 
 	const setSearchTextDebounced = useDebouncedFn((...args) => {
 		setSearchText(args[0] as string);
 	}, DEBOUNCE_DELAY);
 
+	// derive the state of each filter key here in the renderer itself and keep it in sync with current query
+	// also we need to keep a note of last focussed query.
+	// eslint-disable-next-line sonarjs/cognitive-complexity
+	const currentFilterState = useMemo(() => {
+		let filterState: Record<string, boolean> = setDefaultValues(
+			attributeValues,
+			false,
+		);
+		const filterSync = currentQuery?.builder.queryData?.[
+			activeQueryIndex
+		]?.filters?.items.find((item) =>
+			isKeyMatch(item.key?.key, filter.attributeKey.key),
+		);
+
+		if (filterSync) {
+			if (SELECTED_OPERATORS.includes(filterSync.op)) {
+				if (isArray(filterSync.value)) {
+					filterSync.value.forEach((val) => {
+						filterState[String(val)] = true;
+					});
+				} else if (typeof filterSync.value === 'string') {
+					filterState[filterSync.value] = true;
+				} else if (typeof filterSync.value === 'boolean') {
+					filterState[String(filterSync.value)] = true;
+				} else if (typeof filterSync.value === 'number') {
+					filterState[String(filterSync.value)] = true;
+				}
+			} else if (NON_SELECTED_OPERATORS.includes(filterSync.op)) {
+				filterState = setDefaultValues(attributeValues, true);
+				if (isArray(filterSync.value)) {
+					filterSync.value.forEach((val) => {
+						filterState[String(val)] = false;
+					});
+				} else if (typeof filterSync.value === 'string') {
+					filterState[filterSync.value] = false;
+				} else if (typeof filterSync.value === 'boolean') {
+					filterState[String(filterSync.value)] = false;
+				} else if (typeof filterSync.value === 'number') {
+					filterState[String(filterSync.value)] = false;
+				}
+			}
+		} else {
+			filterState = setDefaultValues(attributeValues, true);
+		}
+		return filterState;
+	}, [
+		attributeValues,
+		currentQuery?.builder.queryData,
+		filter.attributeKey,
+		activeQueryIndex,
+	]);
+
+	// disable the filter when there are multiple entries of the same attribute key present in the filter bar
+	const isFilterDisabled = useMemo(
+		() =>
+			(currentQuery?.builder?.queryData?.[
+				activeQueryIndex
+			]?.filters?.items?.filter((item) =>
+				isKeyMatch(item.key?.key, filter.attributeKey.key),
+			)?.length || 0) > 1,
+
+		[currentQuery?.builder?.queryData, activeQueryIndex, filter.attributeKey],
+	);
+
+	// variable to check if the current filter has multiple values to its name in the key op value section
+	const isMultipleValuesTrueForTheKey =
+		Object.values(currentFilterState).filter((val) => val).length > 1;
+
 	// Sort checked items to the top, then unchecked items
 	const currentAttributeKeys = useMemo(() => {
 		const checkedValues = attributeValues.filter(
@@ -84,6 +277,293 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 		[currentAttributeKeys, currentFilterState],
 	);
 
+	const handleClearFilterAttribute = (): void => {
+		const preparedQuery: Query = {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: currentQuery.builder.queryData.map((item, idx) => ({
+					...item,
+					filter: {
+						expression: removeKeysFromExpression(item.filter?.expression ?? '', [
+							filter.attributeKey.key,
+						]),
+					},
+					filters: {
+						...item.filters,
+						items:
+							idx === activeQueryIndex
+								? item.filters?.items?.filter(
+										(fil) => !isKeyMatch(fil.key?.key, filter.attributeKey.key),
+									) || []
+								: [...(item.filters?.items || [])],
+						op: item.filters?.op || 'AND',
+					},
+				})),
+			},
+		};
+
+		if (onFilterChange && isFunction(onFilterChange)) {
+			onFilterChange(preparedQuery);
+		} else {
+			redirectWithQueryBuilderData(preparedQuery);
+		}
+	};
+
+	const onChange = (
+		value: string,
+		checked: boolean,
+		isOnlyOrAllClicked: boolean,
+		// eslint-disable-next-line sonarjs/cognitive-complexity
+	): void => {
+		const query = cloneDeep(currentQuery.builder.queryData?.[activeQueryIndex]);
+
+		// if only or all are clicked we do not need to worry about anything just override whatever we have
+		// by either adding a new IN operator value clause in case of ONLY or remove everything we have for ALL.
+		if (isOnlyOrAllClicked && query?.filters?.items) {
+			const isOnlyOrAll = isSomeFilterPresentForCurrentAttribute
+				? currentFilterState[value] && !isMultipleValuesTrueForTheKey
+					? 'All'
+					: 'Only'
+				: 'Only';
+			query.filters.items = query.filters.items.filter(
+				(q) => !isKeyMatch(q.key?.key, filter.attributeKey.key),
+			);
+
+			if (query.filter?.expression) {
+				query.filter.expression = removeKeysFromExpression(
+					query.filter.expression,
+					[filter.attributeKey.key],
+				);
+			}
+
+			if (isOnlyOrAll === 'Only') {
+				const newFilterItem: TagFilterItem = {
+					id: uuid(),
+					op: getOperatorValue(OPERATORS.IN),
+					key: filter.attributeKey,
+					value,
+				};
+				query.filters.items = [...query.filters.items, newFilterItem];
+			}
+		} else if (query?.filters?.items) {
+			if (
+				query.filters?.items?.some((item) =>
+					isKeyMatch(item.key?.key, filter.attributeKey.key),
+				)
+			) {
+				// if there is already a running filter for the current attribute key then
+				// we split the cases by which particular operator is present right now!
+				const currentFilter = query.filters?.items?.find((q) =>
+					isKeyMatch(q.key?.key, filter.attributeKey.key),
+				);
+				if (currentFilter) {
+					const runningOperator = currentFilter?.op;
+					switch (runningOperator) {
+						case 'in':
+							if (checked) {
+								// if it's an IN operator then if we are checking another value it get's added to the
+								// filter clause. example -  key IN [value1, currentSelectedValue]
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: [...currentFilter.value, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								} else {
+									// if the current state wasn't an array we make it one and add our value
+									const newFilter = {
+										...currentFilter,
+										value: [currentFilter.value as string, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								}
+							} else if (!checked) {
+								// if we are removing some value when the running operator is IN we filter.
+								// example - key IN [value1,currentSelectedValue] becomes key IN [value1] in case of array
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value.filter((val) => val !== value),
+									};
+
+									if (newFilter.value.length === 0) {
+										query.filters.items = query.filters.items.filter(
+											(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+										);
+									} else {
+										query.filters.items = query.filters.items.map((item) => {
+											if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+												return newFilter;
+											}
+											return item;
+										});
+									}
+								} else {
+									// if not an array remove the whole thing altogether!
+									query.filters.items = query.filters.items.filter(
+										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+									);
+								}
+							}
+							break;
+						case 'nin':
+						case 'not in':
+							// if the current running operator is NIN then when unchecking the value it gets
+							// added to the clause like key NIN [value1 , currentUnselectedValue]
+							if (!checked) {
+								// in case of array add the currentUnselectedValue to the list.
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: [...currentFilter.value, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								} else {
+									// in case of not an array make it one!
+									const newFilter = {
+										...currentFilter,
+										value: [currentFilter.value as string, value],
+									};
+									query.filters.items = query.filters.items.map((item) => {
+										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+											return newFilter;
+										}
+										return item;
+									});
+								}
+							} else if (checked) {
+								// opposite of above!
+								if (isArray(currentFilter.value)) {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value.filter((val) => val !== value),
+									};
+									if (newFilter.value.length === 0) {
+										query.filters.items = query.filters.items.filter(
+											(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+										);
+										if (query.filter?.expression) {
+											query.filter.expression = removeKeysFromExpression(
+												query.filter.expression,
+												[filter.attributeKey.key],
+											);
+										}
+									} else {
+										query.filters.items = query.filters.items.map((item) => {
+											if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+												return newFilter;
+											}
+											return item;
+										});
+									}
+								} else {
+									const newFilter = {
+										...currentFilter,
+										value: currentFilter.value === value ? null : currentFilter.value,
+									};
+									if (newFilter.value === null && query.filter?.expression) {
+										query.filter.expression = removeKeysFromExpression(
+											query.filter.expression,
+											[filter.attributeKey.key],
+										);
+									}
+									query.filters.items = query.filters.items.filter(
+										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+									);
+								}
+							}
+							break;
+						case '=':
+							if (checked) {
+								const newFilter = {
+									...currentFilter,
+									op: getOperatorValue(OPERATORS.IN),
+									value: [currentFilter.value as string, value],
+								};
+								query.filters.items = query.filters.items.map((item) => {
+									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+										return newFilter;
+									}
+									return item;
+								});
+							} else if (!checked) {
+								query.filters.items = query.filters.items.filter(
+									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+								);
+							}
+							break;
+						case '!=':
+							if (!checked) {
+								const newFilter = {
+									...currentFilter,
+									op: getNotInOperator(source),
+									value: [currentFilter.value as string, value],
+								};
+								query.filters.items = query.filters.items.map((item) => {
+									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
+										return newFilter;
+									}
+									return item;
+								});
+							} else if (checked) {
+								query.filters.items = query.filters.items.filter(
+									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
+								);
+							}
+							break;
+						default:
+							break;
+					}
+				}
+			} else {
+				// case  - when there is no filter for the current key that means all are selected right now.
+				const newFilterItem: TagFilterItem = {
+					id: uuid(),
+					op: getNotInOperator(source),
+					key: filter.attributeKey,
+					value,
+				};
+				query.filters.items = [...query.filters.items, newFilterItem];
+			}
+		}
+		const finalQuery = {
+			...currentQuery,
+			builder: {
+				...currentQuery.builder,
+				queryData: [
+					...currentQuery.builder.queryData.map((q, idx) => {
+						if (idx === activeQueryIndex) {
+							return query;
+						}
+						return q;
+					}),
+				],
+			},
+		};
+
+		if (onFilterChange && isFunction(onFilterChange)) {
+			onFilterChange(finalQuery);
+		} else {
+			redirectWithQueryBuilderData(finalQuery);
+		}
+	};
+
 	const isEmptyStateWithDocsEnabled =
 		SOURCES_WITH_EMPTY_STATE_ENABLED.includes(source) &&
 		!searchText &&
@@ -91,19 +571,48 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 
 	return (
 		<div className="checkbox-filter">
-			<CheckboxFilterHeader
-				title={filter.title}
-				isOpen={isOpen}
-				showClearAll={!!attributeValues.length}
-				onToggleOpen={onToggleOpen}
-				onClear={onClear}
-			/>
-			{isOpen && isLoading && !attributeValues.length && (
-				<section className="loading">
-					<Skeleton paragraph={{ rows: 4 }} />
+			<section
+				className="filter-header-checkbox"
+				onClick={(): void => {
+					if (isOpen) {
+						setUserToggleState(false);
+						setVisibleItemsCount(10);
+					} else {
+						setUserToggleState(true);
+					}
+				}}
+			>
+				<section className="left-action">
+					{isOpen ? (
+						<ChevronDown size={13} cursor="pointer" />
+					) : (
+						<ChevronRight size={13} cursor="pointer" />
+					)}
+					<Typography.Text className="title">{filter.title}</Typography.Text>
 				</section>
-			)}
-			{isOpen && !isLoading && (
+				<section className="right-action">
+					{isOpen && !!attributeValues.length && (
+						<Typography.Text
+							className="clear-all"
+							onClick={(e): void => {
+								e.stopPropagation();
+								e.preventDefault();
+								handleClearFilterAttribute();
+							}}
+						>
+							Clear All
+						</Typography.Text>
+					)}
+				</section>
+			</section>
+			{isOpen &&
+				(isLoading || isLoadingKeyValueSuggestions) &&
+				!attributeValues.length && (
+					<section className="loading">
+						<Skeleton paragraph={{ rows: 4 }} />
+					</section>
+				)}
+			{isOpen && !isLoading && !isLoadingKeyValueSuggestions && (
 				<>
 					{!isEmptyStateWithDocsEnabled && (
 						<section className="search">
@@ -125,24 +634,48 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 											data-testid="filter-separator"
 										/>
 									)}
-									<CheckboxValueRow
-										value={value}
-										checked={currentFilterState[value]}
-										disabled={isFilterDisabled}
-										title={filter.title}
-										onlyButtonLabel={
-											isSomeFilterPresentForCurrentAttribute
-												? currentFilterState[value] && !isMultipleValuesTrueForTheKey
-													? 'All'
-													: 'Only'
-												: 'Only'
-										}
-										customRendererForValue={filter.customRendererForValue}
-										onCheckboxChange={(checked): void => onChange(value, checked, false)}
-										onOnlyOrAllClick={(): void =>
-											onChange(value, currentFilterState[value], true)
-										}
-									/>
+									<div className="value">
+										<Checkbox
+											onChange={(checked): void =>
+												onChange(value, checked === true, false)
+											}
+											value={currentFilterState[value]}
+											disabled={isFilterDisabled}
+											className="check-box"
+										/>
+
+										<div
+											className={cx(
+												'checkbox-value-section',
+												isFilterDisabled ? 'filter-disabled' : '',
+											)}
+											onClick={(): void => {
+												if (isFilterDisabled) {
+													return;
+												}
+												onChange(value, currentFilterState[value], true);
+											}}
+										>
+											<div className={`${filter.title} label-${value}`} />
+											{filter.customRendererForValue ? (
+												filter.customRendererForValue(value)
+											) : (
+												<Typography.Text className="value-string" truncate={1}>
+													{String(value)}
+												</Typography.Text>
+											)}
+											<Button type="text" className="only-btn">
+												{isSomeFilterPresentForCurrentAttribute
+													? currentFilterState[value] && !isMultipleValuesTrueForTheKey
+														? 'All'
+														: 'Only'
+													: 'Only'}
+											</Button>
+											<Button type="text" className="toggle-btn">
+												Toggle
+											</Button>
+										</div>
+									</div>
 								</Fragment>
 							))}
 						</section>
@@ -155,7 +688,10 @@ export default function CheckboxFilter(props: ICheckboxProps): JSX.Element {
 					)}
 					{visibleItemsCount < attributeValues?.length && (
 						<section className="show-more">
-							<Typography.Text className="show-more-text" onClick={onShowMore}>
+							<Typography.Text
+								className="show-more-text"
+								onClick={(): void => setVisibleItemsCount((prev) => prev + 10)}
+							>
 								Show More...
 							</Typography.Text>
 						</section>

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/CheckboxFilterHeader.tsx

@@ -1,47 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-import { ChevronDown, ChevronRight } from '@signozhq/icons';
-
-interface CheckboxFilterHeaderProps {
-	title: string;
-	isOpen: boolean;
-	showClearAll: boolean;
-	onToggleOpen: () => void;
-	onClear: () => void;
-}
-
-function CheckboxFilterHeader({
-	title,
-	isOpen,
-	showClearAll,
-	onToggleOpen,
-	onClear,
-}: CheckboxFilterHeaderProps): JSX.Element {
-	return (
-		<section className="filter-header-checkbox" onClick={onToggleOpen}>
-			<section className="left-action">
-				{isOpen ? (
-					<ChevronDown size={13} cursor="pointer" />
-				) : (
-					<ChevronRight size={13} cursor="pointer" />
-				)}
-				<Typography.Text className="title">{title}</Typography.Text>
-			</section>
-			<section className="right-action">
-				{isOpen && showClearAll && (
-					<Typography.Text
-						className="clear-all"
-						onClick={(e): void => {
-							e.stopPropagation();
-							e.preventDefault();
-							onClear();
-						}}
-					>
-						Clear All
-					</Typography.Text>
-				)}
-			</section>
-		</section>
-	);
-}
-
-export default CheckboxFilterHeader;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/CheckboxValueRow.tsx

@@ -1,68 +0,0 @@
-import { Button } from 'antd';
-import { Checkbox } from '@signozhq/ui/checkbox';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-
-interface CheckboxValueRowProps {
-	value: string;
-	checked: boolean;
-	disabled: boolean;
-	title: string;
-	onlyButtonLabel: string;
-	customRendererForValue?: (value: string) => JSX.Element;
-	onCheckboxChange: (checked: boolean) => void;
-	onOnlyOrAllClick: () => void;
-}
-
-function CheckboxValueRow({
-	value,
-	checked,
-	disabled,
-	title,
-	onlyButtonLabel,
-	customRendererForValue,
-	onCheckboxChange,
-	onOnlyOrAllClick,
-}: CheckboxValueRowProps): JSX.Element {
-	return (
-		<div className="value">
-			<Checkbox
-				onChange={(isChecked): void => onCheckboxChange(isChecked === true)}
-				value={checked}
-				disabled={disabled}
-				className="check-box"
-			/>
-
-			<div
-				className={cx('checkbox-value-section', disabled ? 'filter-disabled' : '')}
-				onClick={(): void => {
-					if (disabled) {
-						return;
-					}
-					onOnlyOrAllClick();
-				}}
-			>
-				<div className={`${title} label-${value}`} />
-				{customRendererForValue ? (
-					customRendererForValue(value)
-				) : (
-					<Typography.Text className="value-string" truncate={1}>
-						{String(value)}
-					</Typography.Text>
-				)}
-				<Button type="text" className="only-btn">
-					{onlyButtonLabel}
-				</Button>
-				<Button type="text" className="toggle-btn">
-					Toggle
-				</Button>
-			</div>
-		</div>
-	);
-}
-
-CheckboxValueRow.defaultProps = {
-	customRendererForValue: undefined,
-};
-
-export default CheckboxValueRow;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/checkboxFilterQuery.ts

@@ -1,417 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { removeKeysFromExpression } from 'components/QueryBuilderV2/utils';
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { OPERATORS } from 'constants/antlrQueryConstants';
-import { getOperatorValue } from 'container/QueryBuilder/filters/QueryBuilderSearch/utils';
-import { cloneDeep, isArray } from 'lodash-es';
-import { Query, TagFilterItem } from 'types/api/queryBuilder/queryBuilderData';
-import { v4 as uuid } from 'uuid';
-
-import { isKeyMatch } from './utils';
-
-export const SELECTED_OPERATORS = [OPERATORS['='], 'in'];
-export const NON_SELECTED_OPERATORS = [OPERATORS['!='], 'not in', 'nin'];
-
-// Sources that use backend APIs expecting short operator format (e.g., 'nin' instead of 'not in')
-const SOURCES_WITH_SHORT_OPERATORS = [QuickFiltersSource.INFRA_MONITORING];
-
-/**
- * Returns the correct NOT_IN operator value based on source.
- * InfraMonitoring backend expects 'nin', others expect 'not in'.
- */
-export function getNotInOperator(source: QuickFiltersSource): string {
-	if (SOURCES_WITH_SHORT_OPERATORS.includes(source)) {
-		return 'nin';
-	}
-	return getOperatorValue('NOT_IN');
-}
-
-function setDefaultValues(
-	values: string[],
-	trueOrFalse: boolean,
-): Record<string, boolean> {
-	const defaultState: Record<string, boolean> = {};
-	values.forEach((val) => {
-		defaultState[val] = trueOrFalse;
-	});
-	return defaultState;
-}
-
-/**
- * Derives the checked/unchecked state for each attribute value by reading the
- * active filter clause for this attribute key out of the query.
- *
- * - No matching clause -> every value is checked (all selected).
- * - IN / `=` clause     -> only the listed values are checked.
- * - NOT IN / `!=` clause -> every value is checked except the excluded ones.
- */
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function deriveCheckboxState({
-	attributeValues,
-	filterItems,
-	filterKey,
-}: {
-	attributeValues: string[];
-	filterItems: TagFilterItem[] | undefined;
-	filterKey: string;
-}): Record<string, boolean> {
-	let filterState: Record<string, boolean> = setDefaultValues(
-		attributeValues,
-		false,
-	);
-	const filterSync = filterItems?.find((item) =>
-		isKeyMatch(item.key?.key, filterKey),
-	);
-
-	if (filterSync) {
-		if (SELECTED_OPERATORS.includes(filterSync.op)) {
-			if (isArray(filterSync.value)) {
-				filterSync.value.forEach((val) => {
-					filterState[String(val)] = true;
-				});
-			} else if (typeof filterSync.value === 'string') {
-				filterState[filterSync.value] = true;
-			} else if (typeof filterSync.value === 'boolean') {
-				filterState[String(filterSync.value)] = true;
-			} else if (typeof filterSync.value === 'number') {
-				filterState[String(filterSync.value)] = true;
-			}
-		} else if (NON_SELECTED_OPERATORS.includes(filterSync.op)) {
-			filterState = setDefaultValues(attributeValues, true);
-			if (isArray(filterSync.value)) {
-				filterSync.value.forEach((val) => {
-					filterState[String(val)] = false;
-				});
-			} else if (typeof filterSync.value === 'string') {
-				filterState[filterSync.value] = false;
-			} else if (typeof filterSync.value === 'boolean') {
-				filterState[String(filterSync.value)] = false;
-			} else if (typeof filterSync.value === 'number') {
-				filterState[String(filterSync.value)] = false;
-			}
-		}
-	} else {
-		filterState = setDefaultValues(attributeValues, true);
-	}
-	return filterState;
-}
-
-/**
- * Returns a new query with every clause for this attribute key removed, both
- * from the structured filter items and the raw filter expression.
- */
-export function clearFilterFromQuery({
-	currentQuery,
-	filter,
-	activeQueryIndex,
-}: {
-	currentQuery: Query;
-	filter: IQuickFiltersConfig;
-	activeQueryIndex: number;
-}): Query {
-	return {
-		...currentQuery,
-		builder: {
-			...currentQuery.builder,
-			queryData: currentQuery.builder.queryData.map((item, idx) => ({
-				...item,
-				filter: {
-					expression: removeKeysFromExpression(item.filter?.expression ?? '', [
-						filter.attributeKey.key,
-					]),
-				},
-				filters: {
-					...item.filters,
-					items:
-						idx === activeQueryIndex
-							? item.filters?.items?.filter(
-									(fil) => !isKeyMatch(fil.key?.key, filter.attributeKey.key),
-								) || []
-							: [...(item.filters?.items || [])],
-					op: item.filters?.op || 'AND',
-				},
-			})),
-		},
-	};
-}
-
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function applyCheckboxToggle({
-	currentQuery,
-	activeQueryIndex,
-	filter,
-	source,
-	attributeValues,
-	value,
-	checked,
-	isOnlyOrAllClicked,
-}: {
-	currentQuery: Query;
-	activeQueryIndex: number;
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	attributeValues: string[];
-	value: string;
-	checked: boolean;
-	isOnlyOrAllClicked: boolean;
-}): Query {
-	const activeItems =
-		currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items;
-
-	const isSomeFilterPresentForCurrentAttribute = !!activeItems?.some((item) =>
-		isKeyMatch(item.key?.key, filter.attributeKey.key),
-	);
-
-	const currentFilterState = deriveCheckboxState({
-		attributeValues,
-		filterItems: activeItems,
-		filterKey: filter.attributeKey.key,
-	});
-
-	const isMultipleValuesTrueForTheKey =
-		Object.values(currentFilterState).filter((val) => val).length > 1;
-
-	const query = cloneDeep(currentQuery.builder.queryData?.[activeQueryIndex]);
-
-	// if only or all are clicked we do not need to worry about anything just override whatever we have
-	// by either adding a new IN operator value clause in case of ONLY or remove everything we have for ALL.
-	if (isOnlyOrAllClicked && query?.filters?.items) {
-		const isOnlyOrAll = isSomeFilterPresentForCurrentAttribute
-			? currentFilterState[value] && !isMultipleValuesTrueForTheKey
-				? 'All'
-				: 'Only'
-			: 'Only';
-		query.filters.items = query.filters.items.filter(
-			(q) => !isKeyMatch(q.key?.key, filter.attributeKey.key),
-		);
-
-		if (query.filter?.expression) {
-			query.filter.expression = removeKeysFromExpression(query.filter.expression, [
-				filter.attributeKey.key,
-			]);
-		}
-
-		if (isOnlyOrAll === 'Only') {
-			const newFilterItem: TagFilterItem = {
-				id: uuid(),
-				op: getOperatorValue(OPERATORS.IN),
-				key: filter.attributeKey,
-				value,
-			};
-			query.filters.items = [...query.filters.items, newFilterItem];
-		}
-	} else if (query?.filters?.items) {
-		if (
-			query.filters?.items?.some((item) =>
-				isKeyMatch(item.key?.key, filter.attributeKey.key),
-			)
-		) {
-			// if there is already a running filter for the current attribute key then
-			// we split the cases by which particular operator is present right now!
-			const currentFilter = query.filters?.items?.find((q) =>
-				isKeyMatch(q.key?.key, filter.attributeKey.key),
-			);
-			if (currentFilter) {
-				const runningOperator = currentFilter?.op;
-				switch (runningOperator) {
-					case 'in':
-						if (checked) {
-							// if it's an IN operator then if we are checking another value it get's added to the
-							// filter clause. example -  key IN [value1, currentSelectedValue]
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: [...currentFilter.value, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							} else {
-								// if the current state wasn't an array we make it one and add our value
-								const newFilter = {
-									...currentFilter,
-									value: [currentFilter.value as string, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							}
-						} else if (!checked) {
-							// if we are removing some value when the running operator is IN we filter.
-							// example - key IN [value1,currentSelectedValue] becomes key IN [value1] in case of array
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value.filter((val) => val !== value),
-								};
-
-								if (newFilter.value.length === 0) {
-									query.filters.items = query.filters.items.filter(
-										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-									);
-								} else {
-									query.filters.items = query.filters.items.map((item) => {
-										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-											return newFilter;
-										}
-										return item;
-									});
-								}
-							} else {
-								// if not an array remove the whole thing altogether!
-								query.filters.items = query.filters.items.filter(
-									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-								);
-							}
-						}
-						break;
-					case 'nin':
-					case 'not in':
-						// if the current running operator is NIN then when unchecking the value it gets
-						// added to the clause like key NIN [value1 , currentUnselectedValue]
-						if (!checked) {
-							// in case of array add the currentUnselectedValue to the list.
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: [...currentFilter.value, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							} else {
-								// in case of not an array make it one!
-								const newFilter = {
-									...currentFilter,
-									value: [currentFilter.value as string, value],
-								};
-								query.filters.items = query.filters.items.map((item) => {
-									if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-										return newFilter;
-									}
-									return item;
-								});
-							}
-						} else if (checked) {
-							// opposite of above!
-							if (isArray(currentFilter.value)) {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value.filter((val) => val !== value),
-								};
-								if (newFilter.value.length === 0) {
-									query.filters.items = query.filters.items.filter(
-										(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-									);
-									if (query.filter?.expression) {
-										query.filter.expression = removeKeysFromExpression(
-											query.filter.expression,
-											[filter.attributeKey.key],
-										);
-									}
-								} else {
-									query.filters.items = query.filters.items.map((item) => {
-										if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-											return newFilter;
-										}
-										return item;
-									});
-								}
-							} else {
-								const newFilter = {
-									...currentFilter,
-									value: currentFilter.value === value ? null : currentFilter.value,
-								};
-								if (newFilter.value === null && query.filter?.expression) {
-									query.filter.expression = removeKeysFromExpression(
-										query.filter.expression,
-										[filter.attributeKey.key],
-									);
-								}
-								query.filters.items = query.filters.items.filter(
-									(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-								);
-							}
-						}
-						break;
-					case '=':
-						if (checked) {
-							const newFilter = {
-								...currentFilter,
-								op: getOperatorValue(OPERATORS.IN),
-								value: [currentFilter.value as string, value],
-							};
-							query.filters.items = query.filters.items.map((item) => {
-								if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-									return newFilter;
-								}
-								return item;
-							});
-						} else if (!checked) {
-							query.filters.items = query.filters.items.filter(
-								(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-							);
-						}
-						break;
-					case '!=':
-						if (!checked) {
-							const newFilter = {
-								...currentFilter,
-								op: getNotInOperator(source),
-								value: [currentFilter.value as string, value],
-							};
-							query.filters.items = query.filters.items.map((item) => {
-								if (isKeyMatch(item.key?.key, filter.attributeKey.key)) {
-									return newFilter;
-								}
-								return item;
-							});
-						} else if (checked) {
-							query.filters.items = query.filters.items.filter(
-								(item) => !isKeyMatch(item.key?.key, filter.attributeKey.key),
-							);
-						}
-						break;
-					default:
-						break;
-				}
-			}
-		} else {
-			// case  - when there is no filter for the current key that means all are selected right now.
-			const newFilterItem: TagFilterItem = {
-				id: uuid(),
-				op: getNotInOperator(source),
-				key: filter.attributeKey,
-				value,
-			};
-			query.filters.items = [...query.filters.items, newFilterItem];
-		}
-	}
-
-	return {
-		...currentQuery,
-		builder: {
-			...currentQuery.builder,
-			queryData: [
-				...currentQuery.builder.queryData.map((q, idx) => {
-					if (idx === activeQueryIndex) {
-						return query;
-					}
-					return q;
-				}),
-			],
-		},
-	};
-}

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useActiveQueryIndex.ts

@@ -1,27 +0,0 @@
-import { useMemo } from 'react';
-import { QuickFiltersSource } from 'components/QuickFilters/types';
-import { PANEL_TYPES } from 'constants/queryBuilder';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-/**
- * Resolves which query-builder query index the checkbox filter reads from and
- * writes to.
- *
- * In ListView most sources use index 0; TRACES_EXPLORER and every non-ListView
- * mode track the last focused query.
- */
-function useActiveQueryIndex(source: QuickFiltersSource): number {
-	const { lastUsedQuery, panelType } = useQueryBuilder();
-	const isListView = panelType === PANEL_TYPES.LIST;
-
-	return useMemo(() => {
-		if (isListView) {
-			return source === QuickFiltersSource.TRACES_EXPLORER
-				? lastUsedQuery || 0
-				: 0;
-		}
-		return lastUsedQuery || 0;
-	}, [isListView, source, lastUsedQuery]);
-}
-
-export default useActiveQueryIndex;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxDisclosure.ts

@@ -1,90 +0,0 @@
-import { useMemo, useState } from 'react';
-import { IQuickFiltersConfig } from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-import { isKeyMatch } from './utils';
-
-const DEFAULT_VISIBLE_ITEMS_COUNT = 10;
-
-interface UseCheckboxDisclosureProps {
-	filter: IQuickFiltersConfig;
-	activeQueryIndex: number;
-}
-
-interface UseCheckboxDisclosureReturn {
-	isOpen: boolean;
-	isSomeFilterPresentForCurrentAttribute: boolean;
-	visibleItemsCount: number;
-	onToggleOpen: () => void;
-	onShowMore: () => void;
-}
-
-/**
- * Owns the open/collapsed state of a checkbox filter section and how many
- * values are visible.
- *
- * Auto-opens when the query already has a clause for this attribute, otherwise
- * falls back to `filter.defaultOpen`. An explicit user toggle always wins.
- * Collapsing resets the visible count.
- */
-function useCheckboxDisclosure({
-	filter,
-	activeQueryIndex,
-}: UseCheckboxDisclosureProps): UseCheckboxDisclosureReturn {
-	const { currentQuery } = useQueryBuilder();
-	// null = no user action, true = user opened, false = user closed
-	const [userToggleState, setUserToggleState] = useState<boolean | null>(null);
-	const [visibleItemsCount, setVisibleItemsCount] = useState<number>(
-		DEFAULT_VISIBLE_ITEMS_COUNT,
-	);
-
-	const isSomeFilterPresentForCurrentAttribute = useMemo(
-		() =>
-			!!currentQuery.builder.queryData?.[activeQueryIndex]?.filters?.items?.some(
-				(item) => isKeyMatch(item.key?.key, filter.attributeKey.key),
-			),
-		[currentQuery.builder.queryData, activeQueryIndex, filter.attributeKey.key],
-	);
-
-	const isOpen = useMemo(() => {
-		// If user explicitly toggled, respect that
-		if (userToggleState !== null) {
-			return userToggleState;
-		}
-
-		// Auto-open if this filter has active filters in the query
-		if (isSomeFilterPresentForCurrentAttribute) {
-			return true;
-		}
-
-		// Otherwise use default behavior (first 2 filters open)
-		return filter.defaultOpen;
-	}, [
-		userToggleState,
-		isSomeFilterPresentForCurrentAttribute,
-		filter.defaultOpen,
-	]);
-
-	const onToggleOpen = (): void => {
-		if (isOpen) {
-			setUserToggleState(false);
-			setVisibleItemsCount(DEFAULT_VISIBLE_ITEMS_COUNT);
-		} else {
-			setUserToggleState(true);
-		}
-	};
-
-	const onShowMore = (): void => {
-		setVisibleItemsCount((prev) => prev + DEFAULT_VISIBLE_ITEMS_COUNT);
-	};
-
-	return {
-		isOpen,
-		isSomeFilterPresentForCurrentAttribute,
-		visibleItemsCount,
-		onToggleOpen,
-		onShowMore,
-	};
-}
-
-export default useCheckboxDisclosure;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterActions.ts

@@ -1,78 +0,0 @@
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { isFunction } from 'lodash-es';
-import { Query } from 'types/api/queryBuilder/queryBuilderData';
-
-import {
-	applyCheckboxToggle,
-	clearFilterFromQuery,
-} from './checkboxFilterQuery';
-
-interface UseCheckboxFilterActionsProps {
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	attributeValues: string[];
-	activeQueryIndex: number;
-	onFilterChange?: ((query: Query) => void) | null;
-}
-
-interface UseCheckboxFilterActionsReturn {
-	onChange: (
-		value: string,
-		checked: boolean,
-		isOnlyOrAllClicked: boolean,
-	) => void;
-	onClear: () => void;
-}
-
-/**
- * Wires the pure checkbox query algebra to query-builder dispatch: the
- * caller-provided `onFilterChange` when present, otherwise a URL redirect.
- */
-function useCheckboxFilterActions({
-	filter,
-	source,
-	attributeValues,
-	activeQueryIndex,
-	onFilterChange,
-}: UseCheckboxFilterActionsProps): UseCheckboxFilterActionsReturn {
-	const { currentQuery, redirectWithQueryBuilderData } = useQueryBuilder();
-
-	const dispatch = (query: Query): void => {
-		if (onFilterChange && isFunction(onFilterChange)) {
-			onFilterChange(query);
-		} else {
-			redirectWithQueryBuilderData(query);
-		}
-	};
-
-	const onChange = (
-		value: string,
-		checked: boolean,
-		isOnlyOrAllClicked: boolean,
-	): void => {
-		dispatch(
-			applyCheckboxToggle({
-				currentQuery,
-				activeQueryIndex,
-				filter,
-				source,
-				attributeValues,
-				value,
-				checked,
-				isOnlyOrAllClicked,
-			}),
-		);
-	};
-
-	const onClear = (): void => {
-		dispatch(clearFilterFromQuery({ currentQuery, filter, activeQueryIndex }));
-	};
-
-	return { onChange, onClear };
-}
-
-export default useCheckboxFilterActions;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterState.ts

@@ -1,71 +0,0 @@
-import { useMemo } from 'react';
-import { IQuickFiltersConfig } from 'components/QuickFilters/types';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-
-import { deriveCheckboxState } from './checkboxFilterQuery';
-import { isKeyMatch } from './utils';
-
-interface UseCheckboxFilterStateProps {
-	filter: IQuickFiltersConfig;
-	attributeValues: string[];
-	activeQueryIndex: number;
-}
-
-interface UseCheckboxFilterStateReturn {
-	currentFilterState: Record<string, boolean>;
-	isFilterDisabled: boolean;
-	isMultipleValuesTrueForTheKey: boolean;
-}
-
-/**
- * Reads the active query and derives the per-value checked state for this
- * attribute, whether the filter is disabled (same key used more than once in
- * the filter bar), and whether more than one value is currently selected.
- */
-function useCheckboxFilterState({
-	filter,
-	attributeValues,
-	activeQueryIndex,
-}: UseCheckboxFilterStateProps): UseCheckboxFilterStateReturn {
-	const { currentQuery } = useQueryBuilder();
-
-	// derive the state of each filter key here and keep it in sync with current query
-	const currentFilterState = useMemo(
-		() =>
-			deriveCheckboxState({
-				attributeValues,
-				filterItems:
-					currentQuery?.builder.queryData?.[activeQueryIndex]?.filters?.items,
-				filterKey: filter.attributeKey.key,
-			}),
-		[
-			attributeValues,
-			currentQuery?.builder.queryData,
-			filter.attributeKey,
-			activeQueryIndex,
-		],
-	);
-
-	// disable the filter when there are multiple entries of the same attribute key present in the filter bar
-	const isFilterDisabled = useMemo(
-		() =>
-			(currentQuery?.builder?.queryData?.[
-				activeQueryIndex
-			]?.filters?.items?.filter((item) =>
-				isKeyMatch(item.key?.key, filter.attributeKey.key),
-			)?.length || 0) > 1,
-		[currentQuery?.builder?.queryData, activeQueryIndex, filter.attributeKey],
-	);
-
-	// whether the current filter has multiple values to its name in the key op value section
-	const isMultipleValuesTrueForTheKey =
-		Object.values(currentFilterState).filter((val) => val).length > 1;
-
-	return {
-		currentFilterState,
-		isFilterDisabled,
-		isMultipleValuesTrueForTheKey,
-	};
-}
-
-export default useCheckboxFilterState;

frontend/src/components/QuickFilters/FilterRenderers/Checkbox/useCheckboxFilterValues.tsx

@@ -1,99 +0,0 @@
-import { useMemo } from 'react';
-import {
-	IQuickFiltersConfig,
-	QuickFiltersSource,
-} from 'components/QuickFilters/types';
-import { DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY } from 'constants/queryBuilder';
-import { useGetAggregateValues } from 'hooks/queryBuilder/useGetAggregateValues';
-import { useGetQueryKeyValueSuggestions } from 'hooks/querySuggestions/useGetQueryKeyValueSuggestions';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { DataSource } from 'types/common/queryBuilder';
-
-interface UseCheckboxFilterValuesProps {
-	filter: IQuickFiltersConfig;
-	source: QuickFiltersSource;
-	searchText: string;
-	isOpen: boolean;
-}
-
-interface UseCheckboxFilterValuesReturn {
-	attributeValues: string[];
-	isLoading: boolean;
-}
-
-function useCheckboxFilterValues({
-	filter,
-	source,
-	searchText,
-	isOpen,
-}: UseCheckboxFilterValuesProps): UseCheckboxFilterValuesReturn {
-	const { data, isLoading } = useGetAggregateValues(
-		{
-			aggregateOperator: filter.aggregateOperator || 'noop',
-			dataSource: filter.dataSource || DataSource.LOGS,
-			aggregateAttribute: filter.aggregateAttribute || '',
-			attributeKey: filter.attributeKey.key,
-			filterAttributeKeyDataType: filter.attributeKey.dataType || DataTypes.EMPTY,
-			tagType: filter.attributeKey.type || '',
-			searchText: searchText ?? '',
-		},
-		{
-			enabled: isOpen && source !== QuickFiltersSource.METER_EXPLORER,
-			keepPreviousData: true,
-		},
-	);
-
-	const { data: keyValueSuggestions, isLoading: isLoadingKeyValueSuggestions } =
-		useGetQueryKeyValueSuggestions({
-			key: filter.attributeKey.key,
-			signal: filter.dataSource || DataSource.LOGS,
-			signalSource: 'meter',
-			options: {
-				enabled: isOpen && source === QuickFiltersSource.METER_EXPLORER,
-				keepPreviousData: true,
-			},
-		});
-
-	const attributeValues: string[] = useMemo(() => {
-		const dataType = filter.attributeKey.dataType || DataTypes.String;
-
-		if (source === QuickFiltersSource.METER_EXPLORER && keyValueSuggestions) {
-			// Process the response data
-			const responseData = keyValueSuggestions?.data as any;
-			const values = responseData.data?.values || {};
-			const stringValues = values.stringValues || [];
-			const numberValues = values.numberValues || [];
-
-			// Generate options from string values - explicitly handle empty strings
-			const stringOptions = stringValues
-				// Strict filtering for empty string - we'll handle it as a special case if needed
-				.filter(
-					(value: string | null | undefined): value is string =>
-						value !== null && value !== undefined && value !== '',
-				);
-
-			// Generate options from number values
-			const numberOptions = numberValues
-				.filter(
-					(value: number | null | undefined): value is number =>
-						value !== null && value !== undefined,
-				)
-				.map((value: number) => value.toString());
-
-			// Combine all options and make sure we don't have duplicate labels
-			return [...stringOptions, ...numberOptions];
-		}
-
-		const key = DATA_TYPE_VS_ATTRIBUTE_VALUES_KEY[dataType];
-		return (data?.payload?.[key] || []).filter(
-			(val) => val !== undefined && val !== null,
-		);
-	}, [data?.payload, filter.attributeKey.dataType, keyValueSuggestions, source]);
-
-	return {
-		attributeValues,
-		isLoading: isLoading || isLoadingKeyValueSuggestions,
-	};
-}
-
-export default useCheckboxFilterValues;

frontend/src/constants/localStorage.ts

@@ -43,4 +43,5 @@ export enum LOCALSTORAGE {
 	DASHBOARD_PREFERENCES = 'DASHBOARD_PREFERENCES',
 	ACTIVE_SIGNOZ_INSTANCE_URL = 'ACTIVE_SIGNOZ_INSTANCE_URL',
 	DASHBOARDS_LIST_VISIBLE_COLUMNS = 'DASHBOARDS_LIST_VISIBLE_COLUMNS',
+	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/container/MetricsApplication/Tabs/Overview/ServiceOverview.tsx

@@ -1,5 +1,6 @@
 import { useMemo } from 'react';
 import { useParams } from 'react-router-dom';
+import { Skeleton } from 'antd';
 import { ENTITY_VERSION_V4 } from 'constants/app';
 import { FeatureKeys } from 'constants/features';
 import { PANEL_TYPES } from 'constants/queryBuilder';
@@ -123,14 +124,24 @@ function ServiceOverview({
 			/>
 			<Card data-testid="service_latency">
 				<GraphContainer>
-					<Graph
-						onDragSelect={onDragSelect}
-						widget={latencyWidget}
-						onClickHandler={handleGraphClick('Service')}
-						isQueryEnabled={isQueryEnabled}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							onDragSelect={onDragSelect}
+							widget={latencyWidget}
+							onClickHandler={handleGraphClick('Service')}
+							isQueryEnabled={isQueryEnabled}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			</Card>
 		</>

frontend/src/container/MetricsApplication/Tabs/Overview/TopLevelOperations.tsx

@@ -1,3 +1,4 @@
+import { Skeleton } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import axios from 'axios';
 import { SOMETHING_WENT_WRONG } from 'constants/api';
@@ -28,14 +29,24 @@ function TopLevelOperation({
 				</Typography>
 			) : (
 				<GraphContainer>
-					<Graph
-						widget={widget}
-						onClickHandler={handleGraphClick(opName)}
-						onDragSelect={onDragSelect}
-						isQueryEnabled={!topLevelOperationsIsLoading}
-						version={ENTITY_VERSION_V4}
-						enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
-					/>
+					{topLevelOperationsIsLoading && (
+						<Skeleton
+							style={{
+								height: '100%',
+								padding: '16px',
+							}}
+						/>
+					)}
+					{!topLevelOperationsIsLoading && (
+						<Graph
+							widget={widget}
+							onClickHandler={handleGraphClick(opName)}
+							onDragSelect={onDragSelect}
+							isQueryEnabled={!topLevelOperationsIsLoading}
+							version={ENTITY_VERSION_V4}
+							enableDrillDown={SERVICE_DETAIL_DRILLDOWN_ENABLED}
+						/>
+					)}
 				</GraphContainer>
 			)}
 		</Card>

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/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

@@ -20,7 +20,6 @@ import APIError from 'types/api/error';
 import DashboardActions from './DashboardActions/DashboardActions';
 import DashboardInfo from './DashboardInfo/DashboardInfo';
 import { useEditableTitle } from './DashboardInfo/useEditableTitle';
-import { usePublicDashboardMeta } from '../DashboardSettings/PublicDashboard/usePublicDashboardMeta';
 
 import styles from './DashboardPageToolbar.module.scss';
 
@@ -53,10 +52,6 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 		(s) => s.setIsPanelTypeSelectionModalOpen,
 	);
 
-	// Single global fetch of the public-sharing meta (the drawer reuses this cache);
-	// drives the public-access badge.
-	const { isPublic: isPublicDashboard } = usePublicDashboardMeta(id);
-
 	const isAuthor =
 		!!user?.email && !!dashboard.createdBy && dashboard.createdBy === user.email;
 
@@ -122,7 +117,7 @@ function DashboardPageToolbar(props: DashboardPageToolbarProps): JSX.Element {
 					image={image}
 					tags={tags}
 					description={description}
-					isPublicDashboard={isPublicDashboard}
+					isPublicDashboard={false}
 					isDashboardLocked={isDashboardLocked}
 					isEditing={isEditing}
 					draft={draft}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboard.module.scss

@@ -1,15 +1,106 @@
-// Publish tab — "status strip" direction (Claude Design: Publish Drawer Final).
-// Fills the drawer height so the actions anchor a footer instead of floating.
-.publishTab {
+// settings card wrapper — mirrors the V1 public dashboard treatment
+.publicDashboardCard {
 	display: flex;
 	flex-direction: column;
-	height: 100%;
-	min-height: 100%;
+	gap: 8px;
+	padding: 16px;
+	border-radius: 3px;
+	border: 1px solid var(--l2-border);
 }
 
-.content {
-	flex: 1;
+.statusTitle {
+	margin-bottom: 16px;
+	color: var(--l1-foreground);
+	font-family: Inter;
+	font-size: 14px;
+	font-weight: 500;
+	line-height: 20px;
+}
+
+.checkbox {
+	margin-bottom: 8px;
+}
+
+.timeRangeSelectGroup {
 	display: flex;
 	flex-direction: column;
-	gap: 20px;
+	gap: 4px;
+	margin-bottom: 8px;
+}
+
+.timeRangeSelectLabel {
+	color: var(--l2-foreground);
+	font-family: Inter;
+	font-size: 12px;
+	font-weight: 500;
+	line-height: 18px;
+}
+
+.timeRangeSelect {
+	width: 200px;
+}
+
+.urlGroup {
+	display: flex;
+	flex-direction: column;
+	gap: 4px;
+}
+
+.urlLabel {
+	color: var(--l2-foreground);
+	font-family: Inter;
+	font-size: 12px;
+	font-weight: 500;
+	line-height: 18px;
+}
+
+.urlContainer {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	padding: 0 4px;
+	border-radius: 4px;
+	border: 1px solid var(--l1-border);
+	background: var(--l3-background);
+}
+
+.urlText {
+	flex: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+	color: var(--l2-foreground);
+	font-family: Inter;
+	font-size: 13px;
+	line-height: 32px;
+}
+
+.callout {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	margin-top: 12px;
+	padding: 12px 8px;
+	border-radius: 3px;
+	background: color-mix(in srgb, var(--primary-background) 10%, transparent);
+}
+
+.calloutIcon {
+	flex-shrink: 0;
+	color: var(--text-robin-300);
+}
+
+.calloutText {
+	color: var(--text-robin-300);
+	font-family: Inter;
+	font-size: 11px;
+	font-weight: 400;
+	line-height: 16px;
+}
+
+.actions {
+	display: flex;
+	justify-content: flex-end;
+	gap: 8px;
+	margin-top: 32px;
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardActions.tsx

@@ -1,7 +1,7 @@
-import { Globe, RefreshCw, Trash } from '@signozhq/icons';
+import { Globe, Trash } from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 
-import styles from './PublicDashboardActions.module.scss';
+import styles from './PublicDashboard.module.scss';
 
 interface PublicDashboardActionsProps {
 	isPublic: boolean;
@@ -25,7 +25,7 @@ function PublicDashboardActions({
 	onUnpublish,
 }: PublicDashboardActionsProps): JSX.Element {
 	return (
-		<div className={styles.footer}>
+		<div className={styles.actions}>
 			{isPublic ? (
 				<>
 					<Button
@@ -33,22 +33,22 @@ function PublicDashboardActions({
 						color="destructive"
 						disabled={disabled}
 						loading={isUnpublishing}
-						prefix={<Trash size={15} />}
+						prefix={<Trash size={14} />}
 						testId="public-dashboard-unpublish"
 						onClick={onUnpublish}
 					>
-						Unpublish Dashboard
+						Unpublish dashboard
 					</Button>
 					<Button
 						variant="solid"
 						color="primary"
 						disabled={disabled}
 						loading={isUpdating}
-						prefix={<RefreshCw size={15} />}
+						prefix={<Globe size={14} />}
 						testId="public-dashboard-update"
 						onClick={onUpdate}
 					>
-						Update Dashboard
+						Update published dashboard
 					</Button>
 				</>
 			) : (
@@ -57,11 +57,11 @@ function PublicDashboardActions({
 					color="primary"
 					disabled={disabled}
 					loading={isPublishing}
-					prefix={<Globe size={15} />}
+					prefix={<Globe size={14} />}
 					testId="public-dashboard-publish"
 					onClick={onPublish}
 				>
-					Publish Dashboard
+					Publish dashboard
 				</Button>
 			)}
 		</div>

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardActions/PublicDashboardActions.module.scss

@@ -1,12 +0,0 @@
-.footer {
-	position: sticky;
-	z-index: 1;
-	flex: none;
-	display: flex;
-	align-items: center;
-	justify-content: flex-end;
-	gap: 12px;
-	margin-top: 10px;
-	padding-top: 14px;
-	border-top: 1px solid var(--l2-border);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardCallout.tsx

@@ -0,0 +1,17 @@
+import { Info } from '@signozhq/icons';
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './PublicDashboard.module.scss';
+
+function PublicDashboardCallout(): JSX.Element {
+	return (
+		<div className={styles.callout}>
+			<Info size={12} className={styles.calloutIcon} />
+			<Typography.Text className={styles.calloutText}>
+				Dashboard variables won&apos;t work in public dashboards
+			</Typography.Text>
+		</div>
+	);
+}
+
+export default PublicDashboardCallout;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardHint/PublicDashboardHint.module.scss

@@ -1,19 +0,0 @@
-.hint {
-	display: flex;
-	align-items: flex-start;
-	gap: 8px;
-	padding-top: 2px;
-	color: var(--l3-foreground);
-}
-
-.hintIcon {
-	flex: none;
-	margin-top: 1px;
-	color: var(--l3-foreground);
-}
-
-.hintText {
-	color: var(--l3-foreground);
-	font-size: 12px;
-	line-height: 1.5;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardHint/PublicDashboardHint.tsx

@@ -1,17 +0,0 @@
-import { Info } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboardHint.module.scss';
-
-function PublicDashboardHint(): JSX.Element {
-	return (
-		<div className={styles.hint}>
-			<Info size={14} className={styles.hintIcon} />
-			<Typography.Text className={styles.hintText}>
-				Dashboard variables aren&apos;t supported on public links.
-			</Typography.Text>
-		</div>
-	);
-}
-
-export default PublicDashboardHint;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardSettingsForm.tsx

@@ -1,9 +1,9 @@
+import { Checkbox } from '@signozhq/ui/checkbox';
 import { SelectSimple } from '@signozhq/ui/select';
-import { Switch } from '@signozhq/ui/switch';
 import { Typography } from '@signozhq/ui/typography';
-import { RelativeDurationOptions } from 'container/TopNav/DateTimeSelectionV2/constants';
 
-import styles from './PublicDashboardSettingsForm.module.scss';
+import { TIME_RANGE_PRESETS_OPTIONS } from './constants';
+import styles from './PublicDashboard.module.scss';
 
 interface PublicDashboardSettingsFormProps {
 	timeRangeEnabled: boolean;
@@ -22,29 +22,28 @@ function PublicDashboardSettingsForm({
 }: PublicDashboardSettingsFormProps): JSX.Element {
 	return (
 		<>
-			<div className={styles.switchRow}>
-				<Switch
-					testId="public-dashboard-time-range-toggle"
-					value={timeRangeEnabled}
-					disabled={disabled}
-					onChange={onTimeRangeEnabledChange}
-				>
-					Enable time range
-				</Switch>
-			</div>
+			<Checkbox
+				id="public-dashboard-enable-time-range"
+				className={styles.checkbox}
+				testId="public-dashboard-time-range-toggle"
+				value={timeRangeEnabled}
+				disabled={disabled}
+				onChange={(checked): void => onTimeRangeEnabledChange(checked === true)}
+			>
+				Enable time range
+			</Checkbox>
 
-			<div className={styles.fieldGroup}>
-				<Typography.Text className={styles.fieldLabel}>
+			<div className={styles.timeRangeSelectGroup}>
+				<Typography.Text className={styles.timeRangeSelectLabel}>
 					Default time range
 				</Typography.Text>
 				<SelectSimple
 					className={styles.timeRangeSelect}
 					testId="public-dashboard-default-time-range"
 					placeholder="Select default time range"
-					items={RelativeDurationOptions}
+					items={TIME_RANGE_PRESETS_OPTIONS}
 					value={defaultTimeRange}
 					disabled={disabled}
-					withPortal={false}
 					onChange={(value): void => onDefaultTimeRangeChange(value as string)}
 				/>
 			</div>

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardSettingsForm/PublicDashboardSettingsForm.module.scss

@@ -1,34 +0,0 @@
-.switchRow {
-	display: flex;
-	align-items: center;
-}
-
-.fieldGroup {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-
-	// Render the (non-portaled) dropdown above the drawer.
-	[data-radix-popper-content-wrapper] {
-		z-index: 1100 !important;
-	}
-
-	// Radix sets --radix-select-trigger-width on the content element (the wrapper's
-	// child), so match it there to make the dropdown take the input's width.
-	// SelectSimple exposes no content className, hence the descendant selector.
-	[data-radix-popper-content-wrapper] > * {
-		width: var(--radix-select-trigger-width);
-		min-width: var(--radix-select-trigger-width);
-	}
-}
-
-.fieldLabel {
-	color: var(--l2-foreground);
-	font-size: 12px;
-	font-weight: 500;
-	line-height: 1;
-}
-
-.timeRangeSelect {
-	width: 100%;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardStatus.tsx

@@ -0,0 +1,21 @@
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './PublicDashboard.module.scss';
+
+interface PublicDashboardStatusProps {
+	isPublic: boolean;
+}
+
+function PublicDashboardStatus({
+	isPublic,
+}: PublicDashboardStatusProps): JSX.Element {
+	return (
+		<Typography.Text className={styles.statusTitle}>
+			{isPublic
+				? 'This dashboard is publicly accessible. Anyone with the link can view it.'
+				: 'This dashboard is private. Publish it to make it accessible to anyone with the link.'}
+		</Typography.Text>
+	);
+}
+
+export default PublicDashboardStatus;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardStatus/PublicDashboardStatus.module.scss

@@ -1,67 +0,0 @@
-.statusStrip {
-	display: flex;
-	align-items: center;
-	gap: 13px;
-	padding: 14px 16px;
-	border-radius: 8px;
-	border: 1px solid var(--l2-border);
-	background: var(--l1-background);
-}
-
-.statusStripLive {
-	border-color: var(--callout-primary-border);
-	background: var(--callout-primary-background);
-}
-
-.statusMedallion {
-	display: flex;
-	align-items: center;
-	justify-content: center;
-	flex: none;
-	width: 38px;
-	height: 38px;
-	border-radius: 6px;
-	border: 1px solid var(--l2-border);
-	background: var(--l3-background);
-	color: var(--l2-foreground);
-}
-
-.statusMedallionLive {
-	border-color: var(--callout-primary-border);
-	background: var(--callout-primary-background);
-	color: var(--callout-primary-icon);
-}
-
-.statusBody {
-	flex: 1;
-	min-width: 0;
-	display: flex;
-	flex-direction: column;
-}
-
-.statusTitle {
-	color: var(--l1-foreground);
-	font-size: 14px;
-	font-weight: 600;
-	line-height: 1.2;
-}
-
-.statusSubtitle {
-	margin-top: 2px;
-	color: var(--l3-foreground);
-	font-size: 13px;
-	line-height: 1.35;
-}
-
-.statusSubtitleLive {
-	color: var(--l2-foreground);
-}
-
-.statusBadgeDot {
-	display: inline-block;
-	width: 6px;
-	height: 6px;
-	border-radius: 50%;
-	margin-right: 6px;
-	background: currentColor;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardStatus/PublicDashboardStatus.tsx

@@ -1,50 +0,0 @@
-import { Globe, LockKeyhole } from '@signozhq/icons';
-import { Badge } from '@signozhq/ui/badge';
-import { Typography } from '@signozhq/ui/typography';
-import cx from 'classnames';
-
-import styles from './PublicDashboardStatus.module.scss';
-
-interface PublicDashboardStatusProps {
-	isPublic: boolean;
-}
-
-function PublicDashboardStatus({
-	isPublic,
-}: PublicDashboardStatusProps): JSX.Element {
-	return (
-		<div
-			className={cx(styles.statusStrip, { [styles.statusStripLive]: isPublic })}
-		>
-			<span
-				className={cx(styles.statusMedallion, {
-					[styles.statusMedallionLive]: isPublic,
-				})}
-			>
-				{isPublic ? <Globe size={18} /> : <LockKeyhole size={18} />}
-			</span>
-
-			<div className={styles.statusBody}>
-				<Typography.Text className={styles.statusTitle}>
-					{isPublic ? 'This dashboard is live' : 'This dashboard is private'}
-				</Typography.Text>
-				<Typography.Text
-					className={cx(styles.statusSubtitle, {
-						[styles.statusSubtitleLive]: isPublic,
-					})}
-				>
-					{isPublic
-						? 'Anyone with the link can view it — no account needed.'
-						: 'Publish it to share a read-only view with anyone who has the link.'}
-				</Typography.Text>
-			</div>
-
-			<Badge variant="outline" color={isPublic ? 'robin' : 'secondary'}>
-				<span className={styles.statusBadgeDot} />
-				{isPublic ? 'Public' : 'Private'}
-			</Badge>
-		</div>
-	);
-}
-
-export default PublicDashboardStatus;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardUrl.tsx

@@ -0,0 +1,49 @@
+import { Copy, ExternalLink } from '@signozhq/icons';
+import { Button } from '@signozhq/ui/button';
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './PublicDashboard.module.scss';
+
+interface PublicDashboardUrlProps {
+	url: string;
+	onCopy: () => void;
+	onOpen: () => void;
+}
+
+function PublicDashboardUrl({
+	url,
+	onCopy,
+	onOpen,
+}: PublicDashboardUrlProps): JSX.Element {
+	return (
+		<div className={styles.urlGroup}>
+			<Typography.Text className={styles.urlLabel}>
+				Public dashboard URL
+			</Typography.Text>
+
+			<div className={styles.urlContainer}>
+				<Typography.Text className={styles.urlText}>{url}</Typography.Text>
+				<Button
+					variant="ghost"
+					size="icon"
+					aria-label="Copy public dashboard URL"
+					testId="public-dashboard-copy-url"
+					onClick={onCopy}
+				>
+					<Copy size={14} />
+				</Button>
+				<Button
+					variant="ghost"
+					size="icon"
+					aria-label="Open public dashboard in new tab"
+					testId="public-dashboard-open-url"
+					onClick={onOpen}
+				>
+					<ExternalLink size={14} />
+				</Button>
+			</div>
+		</div>
+	);
+}
+
+export default PublicDashboardUrl;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardUrl/PublicDashboardUrl.module.scss

@@ -1,69 +0,0 @@
-.fieldGroup {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-}
-
-.fieldLabel {
-	color: var(--l2-foreground);
-	font-size: 12px;
-	font-weight: 500;
-	line-height: 1;
-}
-
-.linkPlaceholder {
-	display: flex;
-	align-items: center;
-	gap: 9px;
-	height: 40px;
-	padding: 0 12px;
-	border-radius: 6px;
-	border: 1px dashed var(--l2-border);
-	background: var(--l1-background);
-	color: var(--l3-foreground);
-}
-
-.linkPlaceholderIcon {
-	flex: none;
-	color: var(--l3-foreground);
-}
-
-.linkPlaceholderText {
-	color: var(--l3-foreground);
-	font-size: 13px;
-	line-height: 1;
-}
-
-.linkField {
-	display: flex;
-	align-items: center;
-	gap: 2px;
-	height: 40px;
-	padding: 0 5px 0 12px;
-	border-radius: 6px;
-	border: 1px solid var(--l2-border);
-	background: var(--l1-background);
-
-	&:hover {
-		border-color: var(--l3-border);
-	}
-}
-
-.linkUrl {
-	flex: 1;
-	min-width: 0;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-	color: var(--l2-foreground);
-	font-family: var(--font-mono, 'Geist Mono'), monospace;
-	font-size: 13px;
-	line-height: 1;
-}
-
-.linkDivider {
-	width: 1px;
-	height: 20px;
-	margin: 0 4px;
-	background: var(--l2-border);
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardUrl/PublicDashboardUrl.tsx

@@ -1,59 +0,0 @@
-import { Copy, ExternalLink, Link2 } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboardUrl.module.scss';
-
-interface PublicDashboardUrlProps {
-	isPublic: boolean;
-	url: string;
-	onCopy: () => void;
-	onOpen: () => void;
-}
-
-function PublicDashboardUrl({
-	isPublic,
-	url,
-	onCopy,
-	onOpen,
-}: PublicDashboardUrlProps): JSX.Element {
-	return (
-		<div className={styles.fieldGroup}>
-			<Typography.Text className={styles.fieldLabel}>Public link</Typography.Text>
-
-			{isPublic ? (
-				<div className={styles.linkField}>
-					<Typography.Text className={styles.linkUrl}>{url}</Typography.Text>
-					<span className={styles.linkDivider} />
-					<Button
-						variant="ghost"
-						size="icon"
-						aria-label="Copy link"
-						testId="public-dashboard-copy-url"
-						onClick={onCopy}
-					>
-						<Copy size={15} />
-					</Button>
-					<Button
-						variant="ghost"
-						size="icon"
-						aria-label="Open link"
-						testId="public-dashboard-open-url"
-						onClick={onOpen}
-					>
-						<ExternalLink size={15} />
-					</Button>
-				</div>
-			) : (
-				<div className={styles.linkPlaceholder}>
-					<Link2 size={15} className={styles.linkPlaceholderIcon} />
-					<Typography.Text className={styles.linkPlaceholderText}>
-						Your shareable link will appear here once published
-					</Typography.Text>
-				</div>
-			)}
-		</div>
-	);
-}
-
-export default PublicDashboardUrl;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/constants.ts

@@ -0,0 +1,14 @@
+export interface TimeRangePresetOption {
+	label: string;
+	value: string;
+}
+
+// Default time-range presets offered for the public dashboard viewer.
+export const TIME_RANGE_PRESETS_OPTIONS: TimeRangePresetOption[] = [
+	{ label: 'Last 5 minutes', value: '5m' },
+	{ label: 'Last 15 minutes', value: '15m' },
+	{ label: 'Last 30 minutes', value: '30m' },
+	{ label: 'Last 1 hour', value: '1h' },
+	{ label: 'Last 6 hours', value: '6h' },
+	{ label: 'Last 1 day', value: '24h' },
+];

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx

@@ -1,10 +1,10 @@
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 
-import PublicDashboardActions from './PublicDashboardActions/PublicDashboardActions';
-import PublicDashboardHint from './PublicDashboardHint/PublicDashboardHint';
-import PublicDashboardSettingsForm from './PublicDashboardSettingsForm/PublicDashboardSettingsForm';
-import PublicDashboardStatus from './PublicDashboardStatus/PublicDashboardStatus';
-import PublicDashboardUrl from './PublicDashboardUrl/PublicDashboardUrl';
+import PublicDashboardActions from './PublicDashboardActions';
+import PublicDashboardCallout from './PublicDashboardCallout';
+import PublicDashboardSettingsForm from './PublicDashboardSettingsForm';
+import PublicDashboardStatus from './PublicDashboardStatus';
+import PublicDashboardUrl from './PublicDashboardUrl';
 import { usePublicDashboard } from './usePublicDashboard';
 import styles from './PublicDashboard.module.scss';
 
@@ -37,27 +37,22 @@ function PublicDashboardSettings({
 	const controlsDisabled = isLoading || !isAdmin;
 
 	return (
-		<div className={styles.publishTab}>
-			<div className={styles.content}>
-				<PublicDashboardStatus isPublic={isPublic} />
+		<div className={styles.publicDashboardCard}>
+			<PublicDashboardStatus isPublic={isPublic} />
 
-				<PublicDashboardUrl
-					isPublic={isPublic}
-					url={publicUrl}
-					onCopy={onCopyUrl}
-					onOpen={onOpenUrl}
-				/>
+			<PublicDashboardSettingsForm
+				timeRangeEnabled={timeRangeEnabled}
+				defaultTimeRange={defaultTimeRange}
+				disabled={controlsDisabled}
+				onTimeRangeEnabledChange={setTimeRangeEnabled}
+				onDefaultTimeRangeChange={setDefaultTimeRange}
+			/>
 
-				<PublicDashboardSettingsForm
-					timeRangeEnabled={timeRangeEnabled}
-					defaultTimeRange={defaultTimeRange}
-					disabled={controlsDisabled}
-					onTimeRangeEnabledChange={setTimeRangeEnabled}
-					onDefaultTimeRangeChange={setDefaultTimeRange}
-				/>
-			</div>
+			{isPublic && (
+				<PublicDashboardUrl url={publicUrl} onCopy={onCopyUrl} onOpen={onOpenUrl} />
+			)}
 
-			<PublicDashboardHint />
+			<PublicDashboardCallout />
 
 			<PublicDashboardActions
 				isPublic={isPublic}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/usePublicDashboard.ts

@@ -6,6 +6,7 @@ import {
 	invalidateGetPublicDashboard,
 	useCreatePublicDashboard,
 	useDeletePublicDashboard,
+	useGetPublicDashboard,
 	useUpdatePublicDashboard,
 } from 'api/generated/services/dashboard';
 import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
@@ -16,8 +17,6 @@ import { USER_ROLES } from 'types/roles';
 import { getAbsoluteUrl } from 'utils/basePath';
 import { openInNewTab } from 'utils/navigation';
 
-import { usePublicDashboardMeta } from './usePublicDashboardMeta';
-
 export interface UsePublicDashboardReturn {
 	isPublic: boolean;
 	isAdmin: boolean;
@@ -55,16 +54,22 @@ export function usePublicDashboard(
 	const [defaultTimeRange, setDefaultTimeRange] =
 		useState<string>(DEFAULT_TIME_RANGE);
 
-	// Read the shared public-meta cache — the GET is owned globally (toolbar), so the
-	// drawer reuses it rather than issuing its own request.
 	const {
-		publicMeta,
-		isPublic,
+		data,
 		isLoading: isLoadingMeta,
 		isFetching,
 		error,
 		refetch,
-	} = usePublicDashboardMeta(dashboardId);
+	} = useGetPublicDashboard(
+		{ id: dashboardId },
+		{ query: { enabled: !!dashboardId, retry: false } },
+	);
+
+	// react-query retains the last successful `data` even after a refetch errors, so
+	// after unpublishing (the refetch 404s) `data` still holds the old publicPath.
+	// Gate on `!error` so the UI flips back to the private state.
+	const publicMeta = error ? undefined : data?.data;
+	const isPublic = !!publicMeta?.publicPath;
 
 	// Seed form state from the server config when published.
 	useEffect(() => {
@@ -98,7 +103,7 @@ export function usePublicDashboard(
 		(message: string): void => {
 			toast.success(message);
 			void invalidateGetPublicDashboard(queryClient, { id: dashboardId });
-			refetch();
+			void refetch();
 		},
 		[queryClient, dashboardId, refetch],
 	);

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/usePublicDashboardMeta.ts

@@ -1,65 +0,0 @@
-import { useMemo } from 'react';
-import { useGetPublicDashboard } from 'api/generated/services/dashboard';
-import type { DashboardtypesGettablePublicDasbhboardDTO } from 'api/generated/services/sigNoz.schemas';
-import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
-
-export interface UsePublicDashboardMetaReturn {
-	publicMeta: DashboardtypesGettablePublicDasbhboardDTO | undefined;
-	isPublic: boolean;
-	isLoading: boolean;
-	isFetching: boolean;
-	error: unknown;
-	refetch: () => void;
-}
-
-// How long a fetched result stays fresh before a natural trigger may refresh it.
-const PUBLIC_META_STALE_TIME = 5 * 60 * 1000;
-
-/**
- * Single source of truth for a dashboard's public-sharing meta. Keyed by dashboard
- * id via the generated query, so the GET happens once globally (the toolbar mounts it
- * with the dashboard) and every other caller — the publish settings drawer — reads the
- * same cache instead of issuing its own request. A mutation that invalidates
- * getGetPublicDashboardQueryKey refreshes all consumers at once.
- *
- * Only fetched on cloud / enterprise tenants, where public dashboards are available.
- */
-export function usePublicDashboardMeta(
-	dashboardId: string,
-): UsePublicDashboardMetaReturn {
-	const { isCloudUser, isEnterpriseSelfHostedUser } = useGetTenantLicense();
-	const enabled = !!dashboardId && (isCloudUser || isEnterpriseSelfHostedUser);
-
-	const { data, isLoading, isFetching, error, refetch } = useGetPublicDashboard(
-		{ id: dashboardId },
-		{
-			query: {
-				enabled,
-				retry: false,
-				// refetchOnMount: false stops opening the drawer / switching to the Publish
-				// tab from refiring the GET — it reuses the toolbar's cached result. A finite
-				// staleTime still lets it refresh naturally once the data ages, and mutations
-				// invalidate the key to refresh the published state immediately.
-				staleTime: PUBLIC_META_STALE_TIME,
-				refetchOnMount: false,
-			},
-		},
-	);
-
-	// react-query retains the last successful `data` after a refetch errors (e.g. the
-	// 404 once a dashboard is unpublished), so gate on the error to reflect the
-	// private state.
-	const publicMeta = error ? undefined : data?.data;
-
-	return useMemo(
-		() => ({
-			publicMeta,
-			isPublic: !!publicMeta?.publicPath,
-			isLoading,
-			isFetching,
-			error,
-			refetch,
-		}),
-		[publicMeta, isLoading, isFetching, error, refetch],
-	);
-}

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,111 @@
+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;
+	/** 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,
+	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}
+								/>
+							))}
+						</div>
+					</div>
+				</>
+			)}
+		</div>
+	);
+}
+
+export default ConfigPane;

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

@@ -0,0 +1,77 @@
+import type {
+	DashboardtypesPanelSpecDTO,
+	TelemetrytypesSignalDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import {
+	SECTION_METADATA,
+	type SectionConfig,
+} from 'pages/DashboardPageV2/DashboardContainer/Panels/types/sections';
+
+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;
+}
+
+/**
+ * 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,
+}: 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} />}>
+			<Component
+				value={read(spec)}
+				controls={controls}
+				onChange={(next): void => onChangeSpec(write(spec, next))}
+				legendSeries={legendSeries}
+				yAxisUnit={yAxisUnit}
+				tableColumns={tableColumns}
+				signal={signal}
+			/>
+		</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,69 @@
+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(),
+		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: min(350px, 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,56 @@
+import { Select } from 'antd';
+
+import { SegmentIcon, type SegmentIconName } from '../segmentIcons';
+
+import styles from './ConfigSelect.module.scss';
+
+export interface ConfigSelectItem {
+	value: string;
+	label: string;
+	icon?: SegmentIconName;
+}
+
+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,
+				label: item.icon ? (
+					<span className={styles.item}>
+						<SegmentIcon name={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,172 @@
+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;
+	}>;
+	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,122 @@
+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). No
+// `controls` is passed, exercising 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();
+		// The editable fields are hidden until the row is edited.
+		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('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();
+		// Back to view mode.
+		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'));
+		// New row opens in edit mode.
+		expect(screen.getByTestId('threshold-value-0')).toBeInTheDocument();
+
+		fireEvent.click(screen.getByTestId('threshold-discard-0'));
+		// Discarding a never-saved row removes it entirely.
+		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,96 @@
+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. Edit
+ * form is color, value, unit, label.
+ */
+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)}
+			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;