@grafana/scenes 6.40.0--canary.1278.18560955561.0 → 6.40.0--canary.1265.18596374903.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import * as _grafana_data from '@grafana/data';
-import { BusEventWithPayload, EventBus, BusEvent, BusEventType, BusEventHandler, PanelMenuItem, FieldConfigSource, PanelPlugin, AbsoluteTimeRange, PanelData, InterpolateFunction, PanelModel, TimeRange, DataTransformContext, DataFrame, DataQueryRequest, DataSourceGetTagKeysOptions, DataSourceGetTagValuesOptions, IconName, PageLayoutType, UrlQueryMap, DataQuery as DataQuery$1, DataSourceApi, Registry, RegistryItem, ScopedVars, AdHocVariableFilter, GrafanaTheme2, GetTagResponse, MetricFindValue, SelectableValue, DrilldownsApplicability, VariableRefresh as VariableRefresh$1, VariableSort, Scope, EventFilterOptions, AnnotationEvent, AnnotationQuery, DataTransformerConfig, TimeOption, FieldConfig, FieldType, FieldValueMatcherConfig, ScopedVar, RawTimeRange } from '@grafana/data';
+import { BusEventWithPayload, EventBus, BusEvent, BusEventType, BusEventHandler, PanelMenuItem, DataQueryRequest, FieldConfigSource, PanelPlugin, AbsoluteTimeRange, PanelData, InterpolateFunction, PanelModel, TimeRange, DataTransformContext, DataFrame, DataSourceGetTagKeysOptions, DataSourceGetTagValuesOptions, IconName, PageLayoutType, UrlQueryMap, DataQuery as DataQuery$1, DataSourceApi, Registry, RegistryItem, ScopedVars, AdHocVariableFilter, GetTagResponse, MetricFindValue, SelectableValue, VariableRefresh as VariableRefresh$1, VariableSort, DrilldownsApplicability, Scope, EventFilterOptions, AnnotationEvent, AnnotationQuery, DataTransformerConfig, TimeOption, FieldConfig, FieldType, FieldValueMatcherConfig, ScopedVar, RawTimeRange } from '@grafana/data';
+import * as _grafana_schema from '@grafana/schema';
+import { VariableType, VariableHide, LoadingState, TimeZone, DataQuery, DataTopic, DataSourceRef, VariableRefresh, DashboardCursorSync, MatcherConfig, TableFieldOptions } from '@grafana/schema';
 import * as React$1 from 'react';
 import React__default, { ComponentType, CSSProperties, PointerEvent, ForwardRefExoticComponent } from 'react';
 import * as rxjs from 'rxjs';
 import { Observable, Subscription, Unsubscribable, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
-import * as _grafana_schema from '@grafana/schema';
-import { VariableType, VariableHide, TimeZone, DataQuery, DataTopic, DataSourceRef, VariableRefresh, LoadingState, DashboardCursorSync, MatcherConfig, TableFieldOptions } from '@grafana/schema';
 import { PanelContext, WeekStart, IconName as IconName$1 } from '@grafana/ui';
 import { LocationService, VariableInterpolation, ScopesContextValue } from '@grafana/runtime';
 import { Location } from 'history';
@@ -315,6 +315,170 @@ declare class VariableDependencyConfig<TState extends SceneObjectState> implemen
     private handleTimeMacros;
 }
 
+interface LongFrameEvent {
+    duration: number;
+    timestamp: number;
+    method: 'manual' | 'loaf';
+}
+type LongFrameCallback = (event: LongFrameEvent) => void;
+/**
+ * LongFrameDetector is a module for detecting long animation frames.
+ *
+ * It supports two detection methods with automatic fallback:
+ * 1. LoAF API (default when available): Uses Long Animation Frame API with 50ms threshold
+ * 2. Manual tracking (fallback): Uses requestAnimationFrame with configurable threshold (default: 50ms)
+ *
+ * The detector automatically uses LoAF when available for better attribution and performance,
+ * falling back to manual tracking for broader browser support.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Performance_API/Long_animation_frame_timing
+ */
+declare class LongFrameDetector {
+    #private;
+    /**
+     * Check if LoAF API is available in the browser
+     */
+    private isLoAFAvailable;
+    /**
+     * Start detecting long frames and call the provided callback when they occur
+     */
+    start(callback: LongFrameCallback): void;
+    /**
+     * Stop detecting long frames
+     */
+    stop(): void;
+    /**
+     * Check if currently tracking frames
+     */
+    isTracking(): boolean;
+    /**
+     * Start tracking using the Long Animation Frame API
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongAnimationFrameTiming
+     */
+    private startLoAFTracking;
+    /**
+     * Stop LoAF tracking
+     */
+    private stopLoAFTracking;
+    /**
+     * Start manual frame tracking using requestAnimationFrame
+     */
+    private startManualFrameTracking;
+    /**
+     * Stop manual frame tracking
+     */
+    private stopManualFrameTracking;
+    /**
+     * Measure frame durations using requestAnimationFrame
+     */
+    private measureFrames;
+}
+
+interface QueryResultWithState {
+    state: LoadingState;
+}
+interface SceneQueryControllerEntry {
+    request?: DataQueryRequest;
+    type: SceneQueryControllerEntryType;
+    origin: SceneObject;
+    cancel?: () => void;
+}
+type SceneQueryControllerEntryType = 'data' | 'annotations' | 'variable' | 'alerts' | 'plugin' | string;
+
+
+
+interface SceneComponentInteractionEvent {
+    origin: string;
+    duration: number;
+    networkDuration: number;
+    startTs: number;
+    endTs: number;
+}
+interface SceneInteractionTrackerState extends SceneObjectState {
+    enableInteractionTracking?: boolean;
+    onInteractionComplete?(event: SceneComponentInteractionEvent): void;
+}
+interface SceneQueryStateControllerState extends SceneObjectState {
+    isRunning: boolean;
+    enableProfiling?: boolean;
+}
+interface SceneQueryControllerLike extends SceneObject<SceneQueryStateControllerState> {
+    isQueryController: true;
+    cancelAll(): void;
+    queryStarted(entry: SceneQueryControllerEntry): void;
+    queryCompleted(entry: SceneQueryControllerEntry): void;
+    startProfile(name: string): void;
+    cancelProfile(): void;
+    runningQueriesCount(): number;
+}
+
+interface QueryProfilerLike {
+    onQueryStarted(timestamp: number, entry: SceneQueryControllerEntry, queryId: string): ((endTimestamp: number, error?: any) => void) | null;
+}
+/**
+ * Will look for a scene object with a behavior that is a SceneQueryController and register the query with it.
+ * Optionally accepts a panel profiler for direct query tracking callbacks.
+ */
+declare function registerQueryWithController<T extends QueryResultWithState>(entry: SceneQueryControllerEntry, profiler?: QueryProfilerLike): (queryStream: Observable<T>) => Observable<T>;
+
+interface VizPanelRenderProfilerState extends SceneObjectState {
+}
+/**
+ * Tracks performance metrics for individual VizPanel instances using observer pattern.
+ *
+ * Performance events are sent to ScenePerformanceTracker observers, which are consumed
+ * by Grafana's ScenePerformanceLogger and DashboardAnalyticsAggregator.
+ */
+declare class VizPanelRenderProfiler extends SceneObjectBase<VizPanelRenderProfilerState> implements QueryProfilerLike {
+    private _panelKey?;
+    private _panelId?;
+    private _pluginId?;
+    private _pluginVersion?;
+    private _isTracking;
+    private _loadPluginStartTime?;
+    private _applyFieldConfigStartTime?;
+    private _activeQueries;
+    constructor(state?: Partial<VizPanelRenderProfilerState>);
+    private _onActivate;
+    private _handlePanelStateChange;
+    /**
+     * Track query execution with operation ID correlation
+     */
+    onQueryStarted(timestamp: number, entry: SceneQueryControllerEntry, queryId: string): ((endTimestamp: number, error?: any) => void) | null;
+    /**
+     * Track plugin loading with operation ID correlation
+     */
+    onPluginLoadStart(pluginId: string): ((plugin: any, fromCache?: boolean) => void) | null;
+    /**
+     * Track field config processing with operation ID correlation
+     */
+    onFieldConfigStart(timestamp: number): ((endTimestamp: number, dataPointsCount?: number, seriesCount?: number) => void) | null;
+    /**
+     * Get panel info for logging - truncates long titles for readability
+     */
+    private _getPanelInfo;
+    /**
+     * Track simple render timing with operation ID correlation
+     */
+    onSimpleRenderStart(timestamp: number): ((endTimestamp: number, duration: number) => void) | undefined;
+    /** Handle plugin changes */
+    private _onPluginChange;
+    /** Start tracking this panel */
+    private _startTracking;
+    /** Cleanup when behavior is deactivated */
+    private _cleanup;
+    /**
+     * Track data transformation with operation ID correlation
+     */
+    onDataTransformStart(timestamp: number, transformationId: string, metrics: {
+        transformationCount: number;
+        seriesTransformationCount: number;
+        annotationTransformationCount: number;
+    }): ((endTimestamp: number, duration: number, success: boolean, result?: {
+        error?: string;
+    }) => void) | null;
+}
+
 interface VizPanelState<TOptions = {}, TFieldConfig = {}> extends SceneObjectState {
     /**
      * This is usually a plugin id that references a core plugin or an external plugin. But this can also reference a
@@ -335,10 +499,6 @@ interface VizPanelState<TOptions = {}, TFieldConfig = {}> extends SceneObjectSta
      * Offset hoverHeader position on the y axis
      */
     hoverHeaderOffset?: number;
-    /**
-     * Allows adding elements to the subheader of the panel.
-     */
-    subHeaderContent?: React.ReactNode | SceneObject | SceneObject[];
     /**
      * Only shows vizPanelMenu on hover if false, otherwise the menu is always visible in the header
      */
@@ -389,6 +549,10 @@ declare class VizPanel<TOptions = {}, TFieldConfig extends {} = {}> extends Scen
     private _dataWithFieldConfig?;
     private _structureRev;
     constructor(state: Partial<VizPanelState<TOptions, TFieldConfig>>);
+    /**
+     * Get the VizPanelRenderProfiler behavior if attached
+     */
+    getProfiler(): VizPanelRenderProfiler | undefined;
     private _onActivate;
     forceRender(): void;
     private _loadPlugin;
@@ -867,10 +1031,6 @@ declare function escapeLabelValueInExactSelector(labelValue: string): string;
 declare function escapeLabelValueInRegexSelector(labelValue: string): string;
 declare function escapeUrlPipeDelimiters(value: string | undefined): string;
 declare function escapeURLDelimiters(value: string | undefined): string;
-declare function getNonApplicablePillStyles(theme: GrafanaTheme2): {
-    disabledPill: string;
-    strikethrough: string;
-};
 
 declare class AdHocFiltersVariableUrlSyncHandler implements SceneObjectUrlSyncHandler {
     private _variable;
@@ -1024,7 +1184,6 @@ declare class AdHocFiltersVariable extends SceneObjectBase<AdHocFiltersVariableS
     _removeFilter(filter: AdHocFilterWithLabels): void;
     _removeLastFilter(): void;
     _handleComboboxBackspace(filter: AdHocFilterWithLabels): void;
-    getFiltersApplicabilityForQueries(filters: AdHocFilterWithLabels[], queries: SceneDataQuery[]): Promise<DrilldownsApplicability[] | undefined>;
     _verifyApplicability(): Promise<void>;
     /**
      * Get possible keys given current filters. Do not call from plugins directly
@@ -1278,7 +1437,6 @@ declare class GroupByVariable extends MultiValueVariable<GroupByVariableState> {
     constructor(initialState: Partial<GroupByVariableState>);
     private _activationHandler;
     getApplicableKeys(): VariableValue;
-    getGroupByApplicabilityForQueries(value: VariableValue, queries: SceneDataQuery[]): Promise<DrilldownsApplicability[] | undefined>;
     _verifyApplicability(): Promise<void>;
     checkIfRestorable(values: VariableValue): boolean;
     restoreDefaultValues(): void;
@@ -1353,65 +1511,6 @@ declare class UserActionEvent extends BusEventWithPayload<UserActionEventPayload
  */
 declare function lookupVariable(name: string, sceneObject: SceneObject): SceneVariable | null;
 
-interface LongFrameEvent {
-    duration: number;
-    timestamp: number;
-    method: 'manual' | 'loaf';
-}
-type LongFrameCallback = (event: LongFrameEvent) => void;
-
-interface QueryResultWithState {
-    state: LoadingState;
-}
-interface SceneQueryControllerEntry {
-    request?: DataQueryRequest;
-    type: SceneQueryControllerEntryType;
-    origin: SceneObject;
-    cancel?: () => void;
-}
-type SceneQueryControllerEntryType = 'data' | 'annotations' | 'variable' | 'alerts' | 'plugin' | string;
-
-
-
-interface SceneInteractionProfileEvent {
-    origin: string;
-    duration: number;
-    networkDuration: number;
-    jsHeapSizeLimit: number;
-    usedJSHeapSize: number;
-    totalJSHeapSize: number;
-    crumbs: string[];
-    startTs: number;
-    endTs: number;
-    longFramesCount: number;
-    longFramesTotalTime: number;
-}
-interface SceneComponentInteractionEvent {
-    origin: string;
-    duration: number;
-    networkDuration: number;
-    startTs: number;
-    endTs: number;
-}
-interface SceneInteractionTrackerState extends SceneObjectState {
-    enableInteractionTracking?: boolean;
-    onInteractionComplete?(event: SceneComponentInteractionEvent): void;
-}
-interface SceneQueryStateControllerState extends SceneObjectState {
-    isRunning: boolean;
-    enableProfiling?: boolean;
-    onProfileComplete?(event: SceneInteractionProfileEvent): void;
-}
-interface SceneQueryControllerLike extends SceneObject<SceneQueryStateControllerState> {
-    isQueryController: true;
-    cancelAll(): void;
-    queryStarted(entry: SceneQueryControllerEntry): void;
-    queryCompleted(entry: SceneQueryControllerEntry): void;
-    startProfile(name: string): void;
-    cancelProfile(): void;
-    runningQueriesCount(): number;
-}
-
 /**
  * Returns the closest query controller undefined if none found
  */
@@ -1591,6 +1690,37 @@ declare class PanelContextEventBus implements EventBus {
     newScopedBus(key: string, filter: EventFilterOptions): EventBus;
 }
 
+interface PanelProfilingConfig {
+    watchStateKey?: string;
+}
+/**
+ * Manages VizPanelRenderProfiler instances for all panels in a scene object.
+ * Extracted from DashboardPanelProfilingBehavior to allow composition with SceneRenderProfiler.
+ */
+declare class PanelProfilingManager {
+    private _config;
+    private _sceneObject?;
+    private _subscriptions;
+    constructor(_config: PanelProfilingConfig);
+    /**
+     * Attach panel profiling to a scene object
+     */
+    attachToScene(sceneObject: SceneObject): void;
+    /**
+     * Attach VizPanelRenderProfiler to a specific panel if it doesn't already have one
+     * @param panel - The VizPanel to attach profiling to
+     */
+    attachProfilerToPanel(panel: VizPanel): void;
+    /**
+     * Attach VizPanelRenderProfiler to all VizPanels that don't already have one
+     */
+    private _attachProfilersToPanels;
+    /**
+     * Clean up subscriptions and references
+     */
+    cleanup(): void;
+}
+
 /**
  * SceneRenderProfiler tracks dashboard interaction performance including:
  * - Total interaction duration
@@ -1610,9 +1740,17 @@ declare class PanelContextEventBus implements EventBus {
  */
 declare class SceneRenderProfiler {
     #private;
+    private metadata;
+    private _panelProfilingManager?;
     private queryController?;
-    constructor(queryController?: SceneQueryControllerLike | undefined);
+    constructor(panelProfilingConfig?: PanelProfilingConfig);
+    /** Set generic metadata for observer notifications */
+    setMetadata(metadata: Record<string, unknown>): void;
     setQueryController(queryController: SceneQueryControllerLike): void;
+    /** Attach panel profiling to a scene object */
+    attachPanelProfiling(sceneObject: SceneObject): void;
+    /** Attach profiler to a specific panel */
+    attachProfilerToPanel(panel: VizPanel): void;
     setInteractionCompleteHandler(handler?: (event: SceneComponentInteractionEvent) => void): void;
     private setupVisibilityChangeHandler;
     cleanup(): void;
@@ -1621,14 +1759,9 @@ declare class SceneRenderProfiler {
     stopInteraction(): void;
     getCurrentInteraction(): string | null;
     /**
-     * Starts a new profile for performance measurement.
-     *
-     * @param name - The origin/trigger of the profile (e.g., 'time_range_change', 'variable_value_changed')
-     * @param force - Whether this is a "forced" profile (true) or "clean" profile (false)
-     *               - "forced": Started by canceling an existing profile that was recording trailing frames
-     *                           This happens when a new user interaction occurs before the previous one
-     *                           finished measuring its performance impact
-     *               - "clean": Started when no profile is currently active
+     * Start new performance profile
+     * @param name - Profile trigger (e.g., 'time_range_change')
+     * @param force - True if canceling existing profile, false if starting clean
      */
     private _startNewProfile;
     private recordProfileTail;
@@ -1677,26 +1810,250 @@ declare class LiveNowTimer extends SceneObjectBase<LiveNowTimerState> {
     get isEnabled(): boolean;
 }
 
-type index$1_ActWhenVariableChanged = ActWhenVariableChanged;
-declare const index$1_ActWhenVariableChanged: typeof ActWhenVariableChanged;
-type index$1_CursorSync = CursorSync;
-declare const index$1_CursorSync: typeof CursorSync;
-type index$1_LiveNowTimer = LiveNowTimer;
-declare const index$1_LiveNowTimer: typeof LiveNowTimer;
-type index$1_SceneInteractionTracker = SceneInteractionTracker;
-declare const index$1_SceneInteractionTracker: typeof SceneInteractionTracker;
-type index$1_SceneQueryController = SceneQueryController;
-declare const index$1_SceneQueryController: typeof SceneQueryController;
-declare namespace index$1 {
+type index$2_ActWhenVariableChanged = ActWhenVariableChanged;
+declare const index$2_ActWhenVariableChanged: typeof ActWhenVariableChanged;
+type index$2_CursorSync = CursorSync;
+declare const index$2_CursorSync: typeof CursorSync;
+type index$2_LiveNowTimer = LiveNowTimer;
+declare const index$2_LiveNowTimer: typeof LiveNowTimer;
+type index$2_SceneInteractionTracker = SceneInteractionTracker;
+declare const index$2_SceneInteractionTracker: typeof SceneInteractionTracker;
+type index$2_SceneQueryController = SceneQueryController;
+declare const index$2_SceneQueryController: typeof SceneQueryController;
+declare namespace index$2 {
   export {
-    index$1_ActWhenVariableChanged as ActWhenVariableChanged,
-    index$1_CursorSync as CursorSync,
-    index$1_LiveNowTimer as LiveNowTimer,
-    index$1_SceneInteractionTracker as SceneInteractionTracker,
-    index$1_SceneQueryController as SceneQueryController,
+    index$2_ActWhenVariableChanged as ActWhenVariableChanged,
+    index$2_CursorSync as CursorSync,
+    index$2_LiveNowTimer as LiveNowTimer,
+    index$2_SceneInteractionTracker as SceneInteractionTracker,
+    index$2_SceneQueryController as SceneQueryController,
   };
 }
 
+/**
+ * Centralized performance tracking system using observer pattern.
+ * External systems (like Grafana) implement ScenePerformanceObserver to receive performance events.
+ */
+declare function generateOperationId(prefix?: string): string;
+/** Base interface for all performance events */
+interface BasePerformanceEvent {
+    operationId: string;
+    timestamp: number;
+    duration?: number;
+    error?: string;
+}
+interface DashboardInteractionStartData extends BasePerformanceEvent {
+    interactionType: string;
+    metadata?: Record<string, unknown>;
+}
+interface DashboardInteractionMilestoneData extends BasePerformanceEvent {
+    interactionType: string;
+    milestone: string;
+    metadata?: Record<string, unknown>;
+}
+interface DashboardInteractionCompleteData extends BasePerformanceEvent {
+    interactionType: string;
+    networkDuration?: number;
+    longFramesCount: number;
+    longFramesTotalTime: number;
+    metadata?: Record<string, unknown>;
+}
+/** Metadata interface for transform operations */
+interface TransformMetadata {
+    transformationId: string;
+    transformationCount: number;
+    seriesTransformationCount: number;
+    annotationTransformationCount: number;
+    success?: boolean;
+    error?: string;
+}
+/** Metadata interface for query operations */
+interface QueryMetadata {
+    queryId: string;
+    queryType: string;
+}
+/** Metadata interface for render operations */
+interface RenderMetadata {
+}
+/** Metadata interface for plugin load operations */
+interface PluginLoadMetadata {
+    pluginId: string;
+    fromCache?: boolean;
+    pluginLoadTime?: number;
+}
+/** Metadata interface for field config operations */
+interface FieldConfigMetadata {
+}
+/** Base interface for panel performance events */
+interface BasePanelPerformanceData extends BasePerformanceEvent {
+    panelId: string;
+    panelKey: string;
+    pluginId: string;
+    pluginVersion?: string;
+    panelTitle?: string;
+}
+/** Transform operation performance data */
+interface PanelTransformPerformanceData extends BasePanelPerformanceData {
+    operation: 'transform';
+    metadata: TransformMetadata;
+}
+/** Query operation performance data */
+interface PanelQueryPerformanceData extends BasePanelPerformanceData {
+    operation: 'query';
+    metadata: QueryMetadata;
+}
+/** Render operation performance data */
+interface PanelRenderPerformanceData extends BasePanelPerformanceData {
+    operation: 'render';
+    metadata: RenderMetadata;
+}
+/** Plugin load operation performance data */
+interface PanelPluginLoadPerformanceData extends BasePanelPerformanceData {
+    operation: 'plugin-load';
+    metadata: PluginLoadMetadata;
+}
+/** Field config operation performance data */
+interface PanelFieldConfigPerformanceData extends BasePanelPerformanceData {
+    operation: 'fieldConfig';
+    metadata: FieldConfigMetadata;
+}
+/** Discriminated union of all panel performance data types */
+type PanelPerformanceData = PanelTransformPerformanceData | PanelQueryPerformanceData | PanelRenderPerformanceData | PanelPluginLoadPerformanceData | PanelFieldConfigPerformanceData;
+/** Non-panel query performance data for dashboard queries (annotations, variables, etc.) */
+interface QueryPerformanceData extends BasePerformanceEvent {
+    queryId: string;
+    queryType: string;
+    origin: string;
+}
+/**
+ * Observer interface for performance monitoring
+ * External systems implement this to receive performance notifications
+ */
+interface ScenePerformanceObserver {
+    onDashboardInteractionStart?(data: DashboardInteractionStartData): void;
+    onDashboardInteractionMilestone?(data: DashboardInteractionMilestoneData): void;
+    onDashboardInteractionComplete?(data: DashboardInteractionCompleteData): void;
+    onPanelOperationStart?(data: PanelPerformanceData): void;
+    onPanelOperationComplete?(data: PanelPerformanceData): void;
+    onQueryStart?(data: QueryPerformanceData): void;
+    onQueryComplete?(data: QueryPerformanceData): void;
+}
+/**
+ * Centralized performance tracker
+ * Manages observers and provides methods for scene objects to report performance events
+ */
+declare class ScenePerformanceTracker {
+    private static instance;
+    private observers;
+    static getInstance(): ScenePerformanceTracker;
+    /**
+     * Register a performance observer
+     */
+    addObserver(observer: ScenePerformanceObserver): () => void;
+    /**
+     * Remove all observers (for testing)
+     */
+    clearObservers(): void;
+    /**
+     * Get current observer count (for debugging)
+     */
+    getObserverCount(): number;
+    private notifyObservers;
+    notifyDashboardInteractionStart(data: DashboardInteractionStartData): void;
+    notifyDashboardInteractionMilestone(data: DashboardInteractionMilestoneData): void;
+    notifyDashboardInteractionComplete(data: DashboardInteractionCompleteData): void;
+    notifyPanelOperationStart(data: PanelPerformanceData): void;
+    notifyPanelOperationComplete(data: PanelPerformanceData): void;
+    notifyQueryStart(data: QueryPerformanceData): void;
+    notifyQueryComplete(data: QueryPerformanceData): void;
+}
+/**
+ * Get the global performance tracker instance
+ */
+declare function getScenePerformanceTracker(): ScenePerformanceTracker;
+
+/**
+ * Constants for different types of dashboard interactions tracked by SceneRenderProfiler
+ */
+declare const REFRESH_INTERACTION = "refresh";
+declare const TIME_RANGE_CHANGE_INTERACTION = "time_range_change";
+declare const FILTER_ADDED_INTERACTION = "filter_added";
+declare const FILTER_REMOVED_INTERACTION = "filter_removed";
+declare const FILTER_CHANGED_INTERACTION = "filter_changed";
+declare const FILTER_RESTORED_INTERACTION = "filter_restored";
+declare const VARIABLE_VALUE_CHANGED_INTERACTION = "variable_value_changed";
+declare const SCOPES_CHANGED_INTERACTION = "scopes_changed";
+declare const ADHOC_KEYS_DROPDOWN_INTERACTION = "adhoc_keys_dropdown";
+declare const ADHOC_VALUES_DROPDOWN_INTERACTION = "adhoc_values_dropdown";
+declare const GROUPBY_DIMENSIONS_INTERACTION = "groupby_dimensions";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+declare const index$1_ADHOC_KEYS_DROPDOWN_INTERACTION: typeof ADHOC_KEYS_DROPDOWN_INTERACTION;
+declare const index$1_ADHOC_VALUES_DROPDOWN_INTERACTION: typeof ADHOC_VALUES_DROPDOWN_INTERACTION;
+type index$1_BasePerformanceEvent = BasePerformanceEvent;
+type index$1_DashboardInteractionCompleteData = DashboardInteractionCompleteData;
+type index$1_DashboardInteractionMilestoneData = DashboardInteractionMilestoneData;
+type index$1_DashboardInteractionStartData = DashboardInteractionStartData;
+declare const index$1_FILTER_ADDED_INTERACTION: typeof FILTER_ADDED_INTERACTION;
+declare const index$1_FILTER_CHANGED_INTERACTION: typeof FILTER_CHANGED_INTERACTION;
+declare const index$1_FILTER_REMOVED_INTERACTION: typeof FILTER_REMOVED_INTERACTION;
+declare const index$1_FILTER_RESTORED_INTERACTION: typeof FILTER_RESTORED_INTERACTION;
+type index$1_FieldConfigMetadata = FieldConfigMetadata;
+declare const index$1_GROUPBY_DIMENSIONS_INTERACTION: typeof GROUPBY_DIMENSIONS_INTERACTION;
+type index$1_LongFrameDetector = LongFrameDetector;
+declare const index$1_LongFrameDetector: typeof LongFrameDetector;
+type index$1_PanelFieldConfigPerformanceData = PanelFieldConfigPerformanceData;
+type index$1_PanelPerformanceData = PanelPerformanceData;
+type index$1_PanelPluginLoadPerformanceData = PanelPluginLoadPerformanceData;
+type index$1_PanelProfilingConfig = PanelProfilingConfig;
+type index$1_PanelProfilingManager = PanelProfilingManager;
+declare const index$1_PanelProfilingManager: typeof PanelProfilingManager;
+type index$1_PanelQueryPerformanceData = PanelQueryPerformanceData;
+type index$1_PanelRenderPerformanceData = PanelRenderPerformanceData;
+type index$1_PanelTransformPerformanceData = PanelTransformPerformanceData;
+type index$1_PluginLoadMetadata = PluginLoadMetadata;
+type index$1_QueryMetadata = QueryMetadata;
+type index$1_QueryPerformanceData = QueryPerformanceData;
+declare const index$1_REFRESH_INTERACTION: typeof REFRESH_INTERACTION;
+type index$1_RenderMetadata = RenderMetadata;
+declare const index$1_SCOPES_CHANGED_INTERACTION: typeof SCOPES_CHANGED_INTERACTION;
+type index$1_ScenePerformanceObserver = ScenePerformanceObserver;
+type index$1_ScenePerformanceTracker = ScenePerformanceTracker;
+declare const index$1_ScenePerformanceTracker: typeof ScenePerformanceTracker;
+type index$1_SceneRenderProfiler = SceneRenderProfiler;
+declare const index$1_SceneRenderProfiler: typeof SceneRenderProfiler;
+declare const index$1_TIME_RANGE_CHANGE_INTERACTION: typeof TIME_RANGE_CHANGE_INTERACTION;
+type index$1_TransformMetadata = TransformMetadata;
+declare const index$1_VARIABLE_VALUE_CHANGED_INTERACTION: typeof VARIABLE_VALUE_CHANGED_INTERACTION;
+type index$1_VizPanelRenderProfiler = VizPanelRenderProfiler;
+declare const index$1_VizPanelRenderProfiler: typeof VizPanelRenderProfiler;
+declare const index$1_generateOperationId: typeof generateOperationId;
+declare const index$1_getScenePerformanceTracker: typeof getScenePerformanceTracker;
+declare namespace index$1 {
+  export { index$1_ADHOC_KEYS_DROPDOWN_INTERACTION as ADHOC_KEYS_DROPDOWN_INTERACTION, index$1_ADHOC_VALUES_DROPDOWN_INTERACTION as ADHOC_VALUES_DROPDOWN_INTERACTION, index$1_FILTER_ADDED_INTERACTION as FILTER_ADDED_INTERACTION, index$1_FILTER_CHANGED_INTERACTION as FILTER_CHANGED_INTERACTION, index$1_FILTER_REMOVED_INTERACTION as FILTER_REMOVED_INTERACTION, index$1_FILTER_RESTORED_INTERACTION as FILTER_RESTORED_INTERACTION, index$1_GROUPBY_DIMENSIONS_INTERACTION as GROUPBY_DIMENSIONS_INTERACTION, index$1_LongFrameDetector as LongFrameDetector, index$1_PanelProfilingManager as PanelProfilingManager, index$1_REFRESH_INTERACTION as REFRESH_INTERACTION, index$1_SCOPES_CHANGED_INTERACTION as SCOPES_CHANGED_INTERACTION, index$1_ScenePerformanceTracker as ScenePerformanceTracker, index$1_SceneRenderProfiler as SceneRenderProfiler, index$1_TIME_RANGE_CHANGE_INTERACTION as TIME_RANGE_CHANGE_INTERACTION, index$1_VARIABLE_VALUE_CHANGED_INTERACTION as VARIABLE_VALUE_CHANGED_INTERACTION, index$1_VizPanelRenderProfiler as VizPanelRenderProfiler, index$1_generateOperationId as generateOperationId, index$1_getScenePerformanceTracker as getScenePerformanceTracker };
+  export type { index$1_BasePerformanceEvent as BasePerformanceEvent, index$1_DashboardInteractionCompleteData as DashboardInteractionCompleteData, index$1_DashboardInteractionMilestoneData as DashboardInteractionMilestoneData, index$1_DashboardInteractionStartData as DashboardInteractionStartData, index$1_FieldConfigMetadata as FieldConfigMetadata, index$1_PanelFieldConfigPerformanceData as PanelFieldConfigPerformanceData, index$1_PanelPerformanceData as PanelPerformanceData, index$1_PanelPluginLoadPerformanceData as PanelPluginLoadPerformanceData, index$1_PanelProfilingConfig as PanelProfilingConfig, index$1_PanelQueryPerformanceData as PanelQueryPerformanceData, index$1_PanelRenderPerformanceData as PanelRenderPerformanceData, index$1_PanelTransformPerformanceData as PanelTransformPerformanceData, index$1_PluginLoadMetadata as PluginLoadMetadata, index$1_QueryMetadata as QueryMetadata, index$1_QueryPerformanceData as QueryPerformanceData, index$1_RenderMetadata as RenderMetadata, index$1_ScenePerformanceObserver as ScenePerformanceObserver, index$1_TransformMetadata as TransformMetadata };
+}
+
+declare function writePerformanceLog(logger: string, message: string, ...rest: unknown[]): void;
+
 /**
  * Base class for data layer. Handles common implementation including enabling/disabling layer and publishing results.
  */
@@ -2022,6 +2379,10 @@ declare class SceneDataTransformer extends SceneObjectBase<SceneDataTransformerS
     setContainerWidth(width: number): void;
     isDataReadyToDisplay(): boolean;
     reprocessTransformations(): void;
+    /**
+     * S3.1: Calculate transformation complexity metrics
+     */
+    private _calculateTransformationMetrics;
     cancelQuery(): void;
     getResultsStream(): ReplaySubject<SceneDataProviderResult>;
     clone(withState?: Partial<SceneDataTransformerState>): this;
@@ -2033,11 +2394,6 @@ declare class SceneDataTransformer extends SceneObjectBase<SceneDataTransformerS
     private _filterAndPrepareTransformationsByTopic;
 }
 
-/**
- * Will look for a scene object with a behavior that is a SceneQueryController and register the query with it.
- */
-declare function registerQueryWithController<T extends QueryResultWithState>(entry: SceneQueryControllerEntry): (queryStream: Observable<T>) => Observable<T>;
-
 interface VariableValueSelectorsState extends SceneObjectState {
     layout?: ControlsLayout;
 }
@@ -3215,7 +3571,6 @@ declare const loadResources: ResourceLoader;
 
 
 
-
 
 
 declare const sceneUtils: {
@@ -3243,5 +3598,5 @@ declare const sceneUtils: {
     buildPathIdFor: typeof buildPathIdFor;
 };
 
-export { AdHocFiltersVariable, ConstantVariable, ControlsLabel, CustomVariable, DataProviderProxy, DataSourceVariable, EmbeddedScene, FieldConfigBuilder, FieldConfigBuilders, FieldConfigOverridesBuilder, GroupByVariable, IntervalVariable, LazyLoader, LocalValueVariable, MultiOrSingleValueSelect, MultiValueVariable, NestedScene, NewSceneObjectAddedEvent, PATH_ID_SEPARATOR, PanelBuilders, PanelOptionsBuilders, QueryVariable, RuntimeDataSource, SafeSerializableSceneObject, SceneApp, SceneAppPage, SceneByFrameRepeater, SceneByVariableRepeater, SceneCSSGridItem, SceneCSSGridLayout, SceneCanvasText, SceneControlsSpacer, SceneDataLayerBase, SceneDataLayerControls, SceneDataLayerSet, SceneDataLayerSetBase, SceneDataNode, SceneDataTransformer, SceneDebugger, SceneFlexItem, SceneFlexLayout, SceneGridItem, SceneGridLayout, SceneGridLayoutDragStartEvent, SceneGridRow, SceneObjectBase, SceneObjectRef, SceneObjectStateChangedEvent, SceneObjectUrlSyncConfig, SceneQueryRunner, SceneReactObject, SceneRefreshPicker, SceneRenderProfiler, SceneTimePicker, SceneTimeRange, SceneTimeRangeCompare, SceneTimeRangeTransformerBase, SceneTimeZoneOverride, SceneToolbarButton, SceneToolbarInput, SceneVariableSet, SceneVariableValueChangedEvent, ScopesVariable, SplitLayout, SwitchVariable, TestVariable, TextBoxVariable, UrlSyncContextProvider, UrlSyncManager, UserActionEvent, VariableDependencyConfig, VariableValueControl, VariableValueSelectWrapper, VariableValueSelectors, VizConfigBuilder, VizConfigBuilders, VizPanel, VizPanelBuilder, VizPanelExploreButton, VizPanelMenu, index$1 as behaviors, index as dataLayers, escapeUrlPipeDelimiters, formatRegistry, getExploreURL, getNonApplicablePillStyles, isCustomVariableValue, isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject, loadResources, registerQueryWithController, registerRuntimeDataSource, sceneGraph, sceneUtils, useSceneApp, useSceneObjectState, useUrlSync };
-export type { AdHocFilterWithLabels, CancelActivationHandler, ControlsLayout, CustomFormatterVariable, CustomTransformOperator, CustomTransformerDefinition, CustomVariableValue, DataLayerFilter, DataRequestEnricher, DeepPartial, EmbeddedSceneState, ExtraQueryDataProcessor, ExtraQueryDescriptor, ExtraQueryProvider, FiltersRequestEnricher, FormatVariable, InterpolationFormatParameter, MacroVariableConstructor, MultiValueVariableState, QueryRunnerState, SceneActivationHandler, SceneAppDrilldownView, SceneAppPageLike, SceneAppPageState, SceneAppRoute, SceneComponent, SceneComponentProps, SceneDataLayerProvider, SceneDataLayerProviderState, SceneDataProvider, SceneDataProviderResult, SceneDataQuery, SceneDataState, SceneDataTransformerState, SceneDeactivationHandler, SceneFlexItemLike, SceneFlexItemState, SceneGridItemLike, SceneGridItemStateLike, SceneInteractionProfileEvent, SceneLayout, SceneLayoutChildOptions, SceneLayoutState, SceneObject, SceneObjectState, SceneObjectStateChangedPayload, SceneObjectUrlSyncHandler, SceneObjectUrlValue, SceneObjectUrlValues, SceneObjectWithUrlSync, SceneQueryControllerEntry, SceneQueryControllerEntryType, SceneQueryControllerLike, SceneRefreshPickerState, SceneRouteMatch, SceneStateChangedHandler, SceneStatelessBehavior, SceneTimeRangeLike, SceneTimeRangeState, SceneUrlSyncOptions, SceneVariable, SceneVariableDependencyConfigLike, SceneVariableSetState, SceneVariableState, SceneVariables, UrlSyncManagerLike, UseStateHookOptions, ValidateAndUpdateResult, VariableCustomFormatterFn, VariableGetOptionsArgs, VariableValue, VariableValueOption, VariableValueSingle, VizConfig, VizPanelState };
+export { AdHocFiltersVariable, ConstantVariable, ControlsLabel, CustomVariable, DataProviderProxy, DataSourceVariable, EmbeddedScene, FieldConfigBuilder, FieldConfigBuilders, FieldConfigOverridesBuilder, GroupByVariable, IntervalVariable, LazyLoader, LocalValueVariable, MultiOrSingleValueSelect, MultiValueVariable, NestedScene, NewSceneObjectAddedEvent, PATH_ID_SEPARATOR, PanelBuilders, PanelOptionsBuilders, QueryVariable, RuntimeDataSource, SafeSerializableSceneObject, SceneApp, SceneAppPage, SceneByFrameRepeater, SceneByVariableRepeater, SceneCSSGridItem, SceneCSSGridLayout, SceneCanvasText, SceneControlsSpacer, SceneDataLayerBase, SceneDataLayerControls, SceneDataLayerSet, SceneDataLayerSetBase, SceneDataNode, SceneDataTransformer, SceneDebugger, SceneFlexItem, SceneFlexLayout, SceneGridItem, SceneGridLayout, SceneGridLayoutDragStartEvent, SceneGridRow, SceneObjectBase, SceneObjectRef, SceneObjectStateChangedEvent, SceneObjectUrlSyncConfig, SceneQueryRunner, SceneReactObject, SceneRefreshPicker, SceneTimePicker, SceneTimeRange, SceneTimeRangeCompare, SceneTimeRangeTransformerBase, SceneTimeZoneOverride, SceneToolbarButton, SceneToolbarInput, SceneVariableSet, SceneVariableValueChangedEvent, ScopesVariable, SplitLayout, SwitchVariable, TestVariable, TextBoxVariable, UrlSyncContextProvider, UrlSyncManager, UserActionEvent, VariableDependencyConfig, VariableValueControl, VariableValueSelectWrapper, VariableValueSelectors, VizConfigBuilder, VizConfigBuilders, VizPanel, VizPanelBuilder, VizPanelExploreButton, VizPanelMenu, index$2 as behaviors, index as dataLayers, escapeUrlPipeDelimiters, formatRegistry, getExploreURL, isCustomVariableValue, isDataLayer, isDataRequestEnricher, isFiltersRequestEnricher, isSceneObject, loadResources, index$1 as performanceUtils, registerQueryWithController, registerRuntimeDataSource, sceneGraph, sceneUtils, useSceneApp, useSceneObjectState, useUrlSync, writePerformanceLog };
+export type { AdHocFilterWithLabels, CancelActivationHandler, ControlsLayout, CustomFormatterVariable, CustomTransformOperator, CustomTransformerDefinition, CustomVariableValue, DataLayerFilter, DataRequestEnricher, DeepPartial, EmbeddedSceneState, ExtraQueryDataProcessor, ExtraQueryDescriptor, ExtraQueryProvider, FiltersRequestEnricher, FormatVariable, InterpolationFormatParameter, MacroVariableConstructor, MultiValueVariableState, QueryRunnerState, SceneActivationHandler, SceneAppDrilldownView, SceneAppPageLike, SceneAppPageState, SceneAppRoute, SceneComponent, SceneComponentProps, SceneDataLayerProvider, SceneDataLayerProviderState, SceneDataProvider, SceneDataProviderResult, SceneDataQuery, SceneDataState, SceneDataTransformerState, SceneDeactivationHandler, SceneFlexItemLike, SceneFlexItemState, SceneGridItemLike, SceneGridItemStateLike, SceneLayout, SceneLayoutChildOptions, SceneLayoutState, SceneObject, SceneObjectState, SceneObjectStateChangedPayload, SceneObjectUrlSyncHandler, SceneObjectUrlValue, SceneObjectUrlValues, SceneObjectWithUrlSync, SceneQueryControllerEntry, SceneQueryControllerEntryType, SceneQueryControllerLike, SceneRefreshPickerState, SceneRouteMatch, SceneStateChangedHandler, SceneStatelessBehavior, SceneTimeRangeLike, SceneTimeRangeState, SceneUrlSyncOptions, SceneVariable, SceneVariableDependencyConfigLike, SceneVariableSetState, SceneVariableState, SceneVariables, UrlSyncManagerLike, UseStateHookOptions, ValidateAndUpdateResult, VariableCustomFormatterFn, VariableGetOptionsArgs, VariableValue, VariableValueOption, VariableValueSingle, VizConfig, VizPanelState };