@grafana/scenes 6.35.0--canary.1240.17499066940.0 → 6.35.1--canary.1235.17607489973.0

package/dist/index.js

@@ -599,6 +599,15 @@ function writeSceneLog(logger, message, ...rest) {
     console.log(`${logger}: `, message, ...rest);
   }
 }
+function writeSceneLogStyled(logger, message, style, ...rest) {
+  let loggingEnabled = false;
+  if (typeof window !== "undefined") {
+    loggingEnabled = localStorage.getItem("grafana.debug.scenes") === "true";
+  }
+  if (loggingEnabled) {
+    console.log(`%c${logger}: ${message}`, style, ...rest);
+  }
+}
 
 var __typeError$4 = (msg) => {
   throw TypeError(msg);
@@ -607,352 +616,6 @@ var __accessCheck$4 = (obj, member, msg) => member.has(obj) || __typeError$4("Ca
 var __privateGet$4 = (obj, member, getter) => (__accessCheck$4(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd$4 = (obj, member, value) => member.has(obj) ? __typeError$4("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet$4 = (obj, member, value, setter) => (__accessCheck$4(obj, member, "write to private field"), member.set(obj, value), value);
-var _profileInProgress$1, _profileStartTs, _trailAnimationFrameId, _recordedTrailingSpans, _visibilityChangeHandler;
-const POST_STORM_WINDOW = 2e3;
-const SPAN_THRESHOLD = 30;
-const TAB_INACTIVE_THRESHOLD = 1e3;
-class SceneRenderProfiler {
-  constructor(queryController) {
-    this.queryController = queryController;
-    __privateAdd$4(this, _profileInProgress$1, null);
-    __privateAdd$4(this, _profileStartTs, null);
-    __privateAdd$4(this, _trailAnimationFrameId, null);
-    // Will keep measured lengths trailing frames
-    __privateAdd$4(this, _recordedTrailingSpans, []);
-    __privateAdd$4(this, _visibilityChangeHandler, null);
-    this.measureTrailingFrames = (measurementStartTs, lastFrameTime, profileStartTs) => {
-      var _a;
-      const currentFrameTime = performance.now();
-      const frameLength = currentFrameTime - lastFrameTime;
-      if (frameLength > TAB_INACTIVE_THRESHOLD) {
-        writeSceneLog("SceneRenderProfiler", "Tab was inactive, cancelling profile measurement");
-        this.cancelProfile();
-        return;
-      }
-      __privateGet$4(this, _recordedTrailingSpans).push(frameLength);
-      if (currentFrameTime - measurementStartTs < POST_STORM_WINDOW) {
-        if (__privateGet$4(this, _profileInProgress$1)) {
-          __privateSet$4(this, _trailAnimationFrameId, requestAnimationFrame(
-            () => this.measureTrailingFrames(measurementStartTs, currentFrameTime, profileStartTs)
-          ));
-        }
-      } else {
-        const slowFrames = processRecordedSpans(__privateGet$4(this, _recordedTrailingSpans));
-        const slowFramesTime = slowFrames.reduce((acc, val) => acc + val, 0);
-        writeSceneLog(
-          this.constructor.name,
-          "Profile tail recorded, slow frames duration:",
-          slowFramesTime,
-          slowFrames,
-          __privateGet$4(this, _profileInProgress$1)
-        );
-        __privateSet$4(this, _recordedTrailingSpans, []);
-        const profileDuration = measurementStartTs - profileStartTs;
-        writeSceneLog(
-          this.constructor.name,
-          "Stoped recording, total measured time (network included):",
-          profileDuration + slowFramesTime
-        );
-        __privateSet$4(this, _trailAnimationFrameId, null);
-        const profileEndTs = profileStartTs + profileDuration + slowFramesTime;
-        if (!__privateGet$4(this, _profileInProgress$1)) {
-          return;
-        }
-        performance.measure(`DashboardInteraction ${__privateGet$4(this, _profileInProgress$1).origin}`, {
-          start: profileStartTs,
-          end: profileEndTs
-        });
-        const networkDuration = captureNetwork(profileStartTs, profileEndTs);
-        if (((_a = this.queryController) == null ? void 0 : _a.state.onProfileComplete) && __privateGet$4(this, _profileInProgress$1)) {
-          this.queryController.state.onProfileComplete({
-            origin: __privateGet$4(this, _profileInProgress$1).origin,
-            crumbs: __privateGet$4(this, _profileInProgress$1).crumbs,
-            duration: profileDuration + slowFramesTime,
-            networkDuration,
-            startTs: profileStartTs,
-            endTs: profileEndTs,
-            // @ts-ignore
-            jsHeapSizeLimit: performance.memory ? performance.memory.jsHeapSizeLimit : 0,
-            // @ts-ignore
-            usedJSHeapSize: performance.memory ? performance.memory.usedJSHeapSize : 0,
-            // @ts-ignore
-            totalJSHeapSize: performance.memory ? performance.memory.totalJSHeapSize : 0
-          });
-          __privateSet$4(this, _profileInProgress$1, null);
-          __privateSet$4(this, _trailAnimationFrameId, null);
-        }
-        if (window.__runs) {
-          window.__runs += `${Date.now()}, ${profileDuration + slowFramesTime}
-`;
-        } else {
-          window.__runs = `${Date.now()}, ${profileDuration + slowFramesTime}
-`;
-        }
-      }
-    };
-    this.setupVisibilityChangeHandler();
-  }
-  setQueryController(queryController) {
-    this.queryController = queryController;
-  }
-  setupVisibilityChangeHandler() {
-    if (__privateGet$4(this, _visibilityChangeHandler)) {
-      return;
-    }
-    __privateSet$4(this, _visibilityChangeHandler, () => {
-      if (document.hidden && __privateGet$4(this, _profileInProgress$1)) {
-        writeSceneLog("SceneRenderProfiler", "Tab became inactive, cancelling profile");
-        this.cancelProfile();
-      }
-    });
-    if (typeof document !== "undefined") {
-      document.addEventListener("visibilitychange", __privateGet$4(this, _visibilityChangeHandler));
-    }
-  }
-  cleanup() {
-    if (__privateGet$4(this, _visibilityChangeHandler) && typeof document !== "undefined") {
-      document.removeEventListener("visibilitychange", __privateGet$4(this, _visibilityChangeHandler));
-      __privateSet$4(this, _visibilityChangeHandler, null);
-    }
-    this.cancelProfile();
-  }
-  startProfile(name) {
-    if (document.hidden) {
-      writeSceneLog("SceneRenderProfiler", "Tab is inactive, skipping profile", name);
-      return;
-    }
-    if (__privateGet$4(this, _profileInProgress$1)) {
-      if (__privateGet$4(this, _trailAnimationFrameId)) {
-        this.cancelProfile();
-        this._startNewProfile(name, true);
-      } else {
-        this.addCrumb(name);
-      }
-    } else {
-      this._startNewProfile(name);
-    }
-  }
-  /**
-   * 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
-   */
-  _startNewProfile(name, force = false) {
-    __privateSet$4(this, _profileInProgress$1, { origin: name, crumbs: [] });
-    __privateSet$4(this, _profileStartTs, performance.now());
-    writeSceneLog(
-      "SceneRenderProfiler",
-      `Profile started[${force ? "forced" : "clean"}]`,
-      __privateGet$4(this, _profileInProgress$1),
-      __privateGet$4(this, _profileStartTs)
-    );
-  }
-  recordProfileTail(measurementStartTime, profileStartTs) {
-    __privateSet$4(this, _trailAnimationFrameId, requestAnimationFrame(
-      () => this.measureTrailingFrames(measurementStartTime, measurementStartTime, profileStartTs)
-    ));
-  }
-  tryCompletingProfile() {
-    var _a;
-    writeSceneLog("SceneRenderProfiler", "Trying to complete profile", __privateGet$4(this, _profileInProgress$1));
-    if (((_a = this.queryController) == null ? void 0 : _a.runningQueriesCount()) === 0 && __privateGet$4(this, _profileInProgress$1)) {
-      writeSceneLog("SceneRenderProfiler", "All queries completed, stopping profile");
-      this.recordProfileTail(performance.now(), __privateGet$4(this, _profileStartTs));
-    }
-  }
-  isTailRecording() {
-    return Boolean(__privateGet$4(this, _trailAnimationFrameId));
-  }
-  cancelTailRecording() {
-    if (__privateGet$4(this, _trailAnimationFrameId)) {
-      cancelAnimationFrame(__privateGet$4(this, _trailAnimationFrameId));
-      __privateSet$4(this, _trailAnimationFrameId, null);
-      writeSceneLog("SceneRenderProfiler", "Cancelled recording frames, new profile started");
-    }
-  }
-  // cancel profile
-  cancelProfile() {
-    if (__privateGet$4(this, _profileInProgress$1)) {
-      writeSceneLog("SceneRenderProfiler", "Cancelling profile", __privateGet$4(this, _profileInProgress$1));
-      __privateSet$4(this, _profileInProgress$1, null);
-      if (__privateGet$4(this, _trailAnimationFrameId)) {
-        cancelAnimationFrame(__privateGet$4(this, _trailAnimationFrameId));
-        __privateSet$4(this, _trailAnimationFrameId, null);
-      }
-      __privateSet$4(this, _recordedTrailingSpans, []);
-    }
-  }
-  addCrumb(crumb) {
-    if (__privateGet$4(this, _profileInProgress$1)) {
-      writeSceneLog("SceneRenderProfiler", "Adding crumb:", crumb);
-      __privateGet$4(this, _profileInProgress$1).crumbs.push(crumb);
-    }
-  }
-}
-_profileInProgress$1 = new WeakMap();
-_profileStartTs = new WeakMap();
-_trailAnimationFrameId = new WeakMap();
-_recordedTrailingSpans = new WeakMap();
-_visibilityChangeHandler = new WeakMap();
-function processRecordedSpans(spans) {
-  for (let i = spans.length - 1; i >= 0; i--) {
-    if (spans[i] > SPAN_THRESHOLD) {
-      return spans.slice(0, i + 1);
-    }
-  }
-  return [spans[0]];
-}
-function captureNetwork(startTs, endTs) {
-  const entries = performance.getEntriesByType("resource");
-  performance.clearResourceTimings();
-  const networkEntries = entries.filter(
-    (entry) => entry.startTime >= startTs && entry.startTime <= endTs && entry.responseEnd >= startTs && entry.responseEnd <= endTs
-  );
-  for (const entry of networkEntries) {
-    performance.measure("Network entry " + entry.name, {
-      start: entry.startTime,
-      end: entry.responseEnd
-    });
-  }
-  return calculateNetworkTime(networkEntries);
-}
-function calculateNetworkTime(requests) {
-  if (requests.length === 0) {
-    return 0;
-  }
-  requests.sort((a, b) => a.startTime - b.startTime);
-  let totalNetworkTime = 0;
-  let currentStart = requests[0].startTime;
-  let currentEnd = requests[0].responseEnd;
-  for (let i = 1; i < requests.length; i++) {
-    if (requests[i].startTime <= currentEnd) {
-      currentEnd = Math.max(currentEnd, requests[i].responseEnd);
-    } else {
-      totalNetworkTime += currentEnd - currentStart;
-      currentStart = requests[i].startTime;
-      currentEnd = requests[i].responseEnd;
-    }
-  }
-  totalNetworkTime += currentEnd - currentStart;
-  return totalNetworkTime;
-}
-const REFRESH_INTERACTION = "refresh";
-const TIME_RANGE_CHANGE_INTERACTION = "time_range_change";
-const FILTER_REMOVED_INTERACTION = "filter_removed";
-const FILTER_CHANGED_INTERACTION = "filter_changed";
-const FILTER_RESTORED_INTERACTION = "filter_restored";
-const VARIABLE_VALUE_CHANGED_INTERACTION = "variable_value_changed";
-const SCOPES_CHANGED_INTERACTION = "scopes_changed";
-
-var __typeError$3 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
-var __privateGet$3 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), member.get(obj));
-var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$3 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
-var _profileInProgress;
-function isInteractionProfiler(obj) {
-  return obj && typeof obj === "object" && "isInteractionProfiler" in obj;
-}
-class SceneInteractionProfiler extends SceneObjectBase {
-  constructor() {
-    super(...arguments);
-    this.isInteractionProfiler = true;
-    __privateAdd$3(this, _profileInProgress, null);
-  }
-  startProfile(interaction) {
-    if (!this.state.enableProfiling) {
-      return;
-    }
-    if (__privateGet$3(this, _profileInProgress)) {
-      this.cancelProfile();
-    }
-    __privateSet$3(this, _profileInProgress, {
-      interaction,
-      startTs: performance.now()
-    });
-    writeSceneLog("SceneInteractionProfiler", "Started profiling interaction:", interaction);
-  }
-  stopProfile() {
-    if (!__privateGet$3(this, _profileInProgress)) {
-      return;
-    }
-    const endTs = performance.now();
-    const interactionDuration = endTs - __privateGet$3(this, _profileInProgress).startTs;
-    const networkDuration = captureNetwork(__privateGet$3(this, _profileInProgress).startTs, endTs);
-    const result = {
-      interaction: __privateGet$3(this, _profileInProgress).interaction,
-      interactionDuration,
-      networkDuration,
-      startTs: __privateGet$3(this, _profileInProgress).startTs,
-      endTs
-    };
-    writeSceneLog("SceneInteractionProfiler", "Completed profile:", result);
-    if (this.state.onProfileComplete) {
-      this.state.onProfileComplete(result);
-    }
-    performance.mark(`${__privateGet$3(this, _profileInProgress).interaction}_start`, {
-      startTime: __privateGet$3(this, _profileInProgress).startTs
-    });
-    performance.mark(`${__privateGet$3(this, _profileInProgress).interaction}_end`, {
-      startTime: endTs
-    });
-    performance.measure(
-      `Interaction_${__privateGet$3(this, _profileInProgress).interaction}`,
-      `${__privateGet$3(this, _profileInProgress).interaction}_start`,
-      `${__privateGet$3(this, _profileInProgress).interaction}_end`
-    );
-    __privateSet$3(this, _profileInProgress, null);
-  }
-  cancelProfile() {
-    if (__privateGet$3(this, _profileInProgress)) {
-      writeSceneLog("SceneInteractionProfiler", "Cancelled profile:", __privateGet$3(this, _profileInProgress).interaction);
-      __privateSet$3(this, _profileInProgress, null);
-    }
-  }
-  isProfileActive() {
-    return __privateGet$3(this, _profileInProgress) !== null;
-  }
-  getCurrentInteraction() {
-    var _a, _b;
-    return (_b = (_a = __privateGet$3(this, _profileInProgress)) == null ? void 0 : _a.interaction) != null ? _b : null;
-  }
-}
-_profileInProgress = new WeakMap();
-const USER_INTERACTIONS = {
-  ADHOC_KEYS_DROPDOWN: "adhoc_keys_dropdown",
-  ADHOC_VALUES_DROPDOWN: "adhoc_values_dropdown",
-  GROUPBY_DROPDOWN: "groupby_dropdown"
-};
-
-function getInteractionProfiler(sceneObject) {
-  let parent = sceneObject;
-  while (parent) {
-    if (parent.state.$behaviors) {
-      for (const behavior of parent.state.$behaviors) {
-        if (isInteractionProfiler(behavior)) {
-          return behavior;
-        }
-      }
-    }
-    parent = parent.parent;
-  }
-  return void 0;
-}
-
-var __typeError$2 = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
-var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
 var _running, _tryCompleteProfileFrameId;
 function isQueryController(s) {
   return "isQueryController" in s;
@@ -962,10 +625,10 @@ class SceneQueryController extends SceneObjectBase {
     super({ ...state, isRunning: false });
     this.profiler = profiler;
     this.isQueryController = true;
-    __privateAdd$2(this, _running, /* @__PURE__ */ new Set());
-    __privateAdd$2(this, _tryCompleteProfileFrameId, null);
+    __privateAdd$4(this, _running, /* @__PURE__ */ new Set());
+    __privateAdd$4(this, _tryCompleteProfileFrameId, null);
     this.runningQueriesCount = () => {
-      return __privateGet$2(this, _running).size;
+      return __privateGet$4(this, _running).size;
     };
     if (profiler) {
       this.profiler = profiler;
@@ -974,7 +637,7 @@ class SceneQueryController extends SceneObjectBase {
     this.addActivationHandler(() => {
       var _a;
       (_a = this.profiler) == null ? void 0 : _a.setQueryController(this);
-      return () => __privateGet$2(this, _running).clear();
+      return () => __privateGet$4(this, _running).clear();
     });
   }
   startProfile(name) {
@@ -989,19 +652,19 @@ class SceneQueryController extends SceneObjectBase {
     (_a = this.profiler) == null ? void 0 : _a.cancelProfile();
   }
   queryStarted(entry) {
-    __privateGet$2(this, _running).add(entry);
+    __privateGet$4(this, _running).add(entry);
     this.changeRunningQueryCount(1, entry);
     if (!this.state.isRunning) {
       this.setState({ isRunning: true });
     }
   }
   queryCompleted(entry) {
-    if (!__privateGet$2(this, _running).has(entry)) {
+    if (!__privateGet$4(this, _running).has(entry)) {
       return;
     }
-    __privateGet$2(this, _running).delete(entry);
+    __privateGet$4(this, _running).delete(entry);
     this.changeRunningQueryCount(-1);
-    if (__privateGet$2(this, _running).size === 0) {
+    if (__privateGet$4(this, _running).size === 0) {
       this.setState({ isRunning: false });
     }
   }
@@ -1018,186 +681,699 @@ class SceneQueryController extends SceneObjectBase {
       }
     }
     if (this.state.enableProfiling) {
-      if (__privateGet$2(this, _tryCompleteProfileFrameId)) {
-        cancelAnimationFrame(__privateGet$2(this, _tryCompleteProfileFrameId));
+      if (__privateGet$4(this, _tryCompleteProfileFrameId)) {
+        cancelAnimationFrame(__privateGet$4(this, _tryCompleteProfileFrameId));
       }
-      __privateSet$2(this, _tryCompleteProfileFrameId, requestAnimationFrame(() => {
+      __privateSet$4(this, _tryCompleteProfileFrameId, requestAnimationFrame(() => {
         var _a2;
         (_a2 = this.profiler) == null ? void 0 : _a2.tryCompletingProfile();
       }));
     }
   }
-  cancelAll() {
-    var _a;
-    for (const entry of __privateGet$2(this, _running).values()) {
-      (_a = entry.cancel) == null ? void 0 : _a.call(entry);
+  cancelAll() {
+    var _a;
+    for (const entry of __privateGet$4(this, _running).values()) {
+      (_a = entry.cancel) == null ? void 0 : _a.call(entry);
+    }
+  }
+}
+_running = new WeakMap();
+_tryCompleteProfileFrameId = new WeakMap();
+
+function getQueryController(sceneObject) {
+  let parent = sceneObject;
+  while (parent) {
+    if (parent.state.$behaviors) {
+      for (const behavior of parent.state.$behaviors) {
+        if (isQueryController(behavior)) {
+          return behavior;
+        }
+      }
+    }
+    parent = parent.parent;
+  }
+  return void 0;
+}
+
+class SceneDataNode extends SceneObjectBase {
+  constructor(state) {
+    super({
+      data: emptyPanelData,
+      ...state
+    });
+  }
+  getResultsStream() {
+    const result = {
+      origin: this,
+      data: this.state.data
+    };
+    return rxjs.of(result);
+  }
+}
+const emptyPanelData = {
+  state: schema.LoadingState.Done,
+  series: [],
+  timeRange: data.getDefaultTimeRange()
+};
+
+class SceneObjectUrlSyncConfig {
+  constructor(_sceneObject, _options) {
+    this._sceneObject = _sceneObject;
+    this._nextChangeShouldAddHistoryStep = false;
+    this._keys = _options.keys;
+  }
+  getKeys() {
+    if (typeof this._keys === "function") {
+      return this._keys();
+    }
+    return this._keys;
+  }
+  getUrlState() {
+    return this._sceneObject.getUrlState();
+  }
+  updateFromUrl(values) {
+    this._sceneObject.updateFromUrl(values);
+  }
+  shouldCreateHistoryStep(values) {
+    return this._nextChangeShouldAddHistoryStep;
+  }
+  performBrowserHistoryAction(callback) {
+    this._nextChangeShouldAddHistoryStep = true;
+    callback();
+    this._nextChangeShouldAddHistoryStep = false;
+  }
+}
+
+function getClosest(sceneObject, extract) {
+  let curSceneObject = sceneObject;
+  let extracted = void 0;
+  while (curSceneObject && !extracted) {
+    extracted = extract(curSceneObject);
+    curSceneObject = curSceneObject.parent;
+  }
+  return extracted;
+}
+
+const INTERVAL_STRING_REGEX = /^\d+[yYmMsSwWhHdD]$/;
+function parseUrlParam(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  if (value.indexOf("now") !== -1) {
+    return value;
+  }
+  if (INTERVAL_STRING_REGEX.test(value)) {
+    return value;
+  }
+  if (value.length === 8) {
+    const utcValue = data.toUtc(value, "YYYYMMDD");
+    if (utcValue.isValid()) {
+      return utcValue.toISOString();
+    }
+  } else if (value.length === 15) {
+    const utcValue = data.toUtc(value, "YYYYMMDDTHHmmss");
+    if (utcValue.isValid()) {
+      return utcValue.toISOString();
+    }
+  } else if (value.length === 19) {
+    const utcValue = data.toUtc(value, "YYYY-MM-DD HH:mm:ss");
+    if (utcValue.isValid()) {
+      return utcValue.toISOString();
+    }
+  } else if (value.length === 24) {
+    const utcValue = data.toUtc(value);
+    return utcValue.toISOString();
+  }
+  const epoch = parseInt(value, 10);
+  if (!isNaN(epoch)) {
+    return data.toUtc(epoch).toISOString();
+  }
+  return null;
+}
+
+function evaluateTimeRange(from, to, timeZone, fiscalYearStartMonth, delay, weekStart) {
+  const hasDelay = delay && to === "now";
+  const now = Date.now();
+  if (weekStart) {
+    setWeekStartIfDifferent(weekStart);
+  }
+  const parseOrToDateTime = (val, options) => {
+    if (data.dateMath.toDateTime) {
+      return data.dateMath.toDateTime(val, options);
+    } else {
+      return data.dateMath.parse(val, options.roundUp, options.timezone, options.fiscalYearStartMonth);
+    }
+  };
+  return {
+    to: parseOrToDateTime(hasDelay ? "now-" + delay : to, {
+      roundUp: true,
+      timezone: timeZone,
+      fiscalYearStartMonth,
+      now
+    }),
+    from: parseOrToDateTime(from, {
+      roundUp: false,
+      timezone: timeZone,
+      fiscalYearStartMonth,
+      now
+    }),
+    raw: {
+      from,
+      to
+    }
+  };
+}
+let prevWeekStart;
+function setWeekStartIfDifferent(weekStart) {
+  if (weekStart !== prevWeekStart) {
+    prevWeekStart = weekStart;
+    data.setWeekStart(weekStart);
+  }
+}
+
+function isValid$1(value, roundUp, timeZone) {
+  if (data.isDateTime(value)) {
+    return value.isValid();
+  }
+  if (data.dateMath.isMathString(value)) {
+    return data.dateMath.isValid(value);
+  }
+  const parsed = data.dateTimeParse(value, { roundUp, timeZone });
+  return parsed.isValid();
+}
+
+var __typeError$3 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
+var __privateGet$3 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$3 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
+var _isTracking, _callback, _frameTrackingId, _lastFrameTime, _loafObserver;
+const LONG_FRAME_THRESHOLD = 50;
+class LongFrameDetector {
+  constructor() {
+    __privateAdd$3(this, _isTracking, false);
+    __privateAdd$3(this, _callback, null);
+    // Manual tracking state
+    __privateAdd$3(this, _frameTrackingId, null);
+    __privateAdd$3(this, _lastFrameTime, 0);
+    // LoAF tracking state
+    __privateAdd$3(this, _loafObserver, null);
+    /**
+     * Measure frame durations using requestAnimationFrame
+     */
+    this.measureFrames = () => {
+      if (!__privateGet$3(this, _isTracking)) {
+        return;
+      }
+      const currentFrameTime = performance.now();
+      const frameLength = currentFrameTime - __privateGet$3(this, _lastFrameTime);
+      if (frameLength > LONG_FRAME_THRESHOLD) {
+        const event = {
+          duration: frameLength,
+          timestamp: currentFrameTime,
+          method: "manual"
+        };
+        if (__privateGet$3(this, _callback)) {
+          __privateGet$3(this, _callback).call(this, event);
+        }
+        if (typeof performance !== "undefined" && performance.mark && performance.measure) {
+          const frameId = `long-frame-manual-${currentFrameTime.toFixed(0)}`;
+          const startMarkName = `${frameId}-start`;
+          const endMarkName = `${frameId}-end`;
+          const measureName = `Long Frame (Manual): ${frameLength.toFixed(1)}ms`;
+          try {
+            performance.mark(startMarkName, { startTime: currentFrameTime - frameLength });
+            performance.mark(endMarkName, { startTime: currentFrameTime });
+            performance.measure(measureName, startMarkName, endMarkName);
+          } catch (e) {
+            performance.mark(measureName);
+          }
+        }
+        writeSceneLog(
+          "LongFrameDetector",
+          `Long frame detected (manual): ${frameLength}ms (threshold: ${LONG_FRAME_THRESHOLD}ms)`
+        );
+      }
+      __privateSet$3(this, _lastFrameTime, currentFrameTime);
+      if (__privateGet$3(this, _isTracking)) {
+        __privateSet$3(this, _frameTrackingId, requestAnimationFrame(this.measureFrames));
+      }
+    };
+  }
+  /**
+   * Check if LoAF API is available in the browser
+   */
+  isLoAFAvailable() {
+    return typeof PerformanceObserver !== "undefined" && PerformanceObserver.supportedEntryTypes && PerformanceObserver.supportedEntryTypes.includes("long-animation-frame");
+  }
+  /**
+   * Start detecting long frames and call the provided callback when they occur
+   */
+  start(callback) {
+    if (__privateGet$3(this, _isTracking)) {
+      writeSceneLog("LongFrameDetector", "Already tracking frames, stopping previous session");
+      this.stop();
+    }
+    __privateSet$3(this, _callback, callback);
+    __privateSet$3(this, _isTracking, true);
+    if (this.isLoAFAvailable()) {
+      this.startLoAFTracking();
+    } else {
+      this.startManualFrameTracking();
+    }
+    writeSceneLog(
+      "LongFrameDetector",
+      `Started tracking with ${this.isLoAFAvailable() ? "LoAF API" : "manual"} method, threshold: ${LONG_FRAME_THRESHOLD}ms`
+    );
+  }
+  /**
+   * Stop detecting long frames
+   */
+  stop() {
+    if (!__privateGet$3(this, _isTracking)) {
+      return;
+    }
+    __privateSet$3(this, _isTracking, false);
+    __privateSet$3(this, _callback, null);
+    this.stopLoAFTracking();
+    this.stopManualFrameTracking();
+  }
+  /**
+   * Check if currently tracking frames
+   */
+  isTracking() {
+    return __privateGet$3(this, _isTracking);
+  }
+  /**
+   * Start tracking using the Long Animation Frame API
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongAnimationFrameTiming
+   */
+  startLoAFTracking() {
+    if (!this.isLoAFAvailable()) {
+      writeSceneLog("LongFrameDetector", "LoAF API not available, falling back to manual tracking");
+      this.startManualFrameTracking();
+      return;
+    }
+    try {
+      __privateSet$3(this, _loafObserver, new PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+          const event = {
+            duration: entry.duration,
+            timestamp: entry.startTime,
+            method: "loaf"
+          };
+          if (__privateGet$3(this, _callback)) {
+            __privateGet$3(this, _callback).call(this, event);
+          }
+          if (typeof performance !== "undefined" && performance.mark && performance.measure) {
+            const frameId = `long-frame-${entry.startTime.toFixed(0)}`;
+            const startMarkName = `${frameId}-start`;
+            const endMarkName = `${frameId}-end`;
+            const measureName = `Long Frame (LoAF): ${entry.duration.toFixed(1)}ms`;
+            try {
+              performance.mark(startMarkName, { startTime: entry.startTime });
+              performance.mark(endMarkName, { startTime: entry.startTime + entry.duration });
+              performance.measure(measureName, startMarkName, endMarkName);
+            } catch (e) {
+              performance.mark(measureName);
+            }
+          }
+          writeSceneLog("LongFrameDetector", `Long frame detected (LoAF): ${entry.duration}ms at ${entry.startTime}ms`);
+        }
+      }));
+      __privateGet$3(this, _loafObserver).observe({ type: "long-animation-frame", buffered: false });
+    } catch (error) {
+      writeSceneLog("LongFrameDetector", "Failed to start LoAF tracking, falling back to manual:", error);
+      this.startManualFrameTracking();
+    }
+  }
+  /**
+   * Stop LoAF tracking
+   */
+  stopLoAFTracking() {
+    if (__privateGet$3(this, _loafObserver)) {
+      __privateGet$3(this, _loafObserver).disconnect();
+      __privateSet$3(this, _loafObserver, null);
+      writeSceneLog("LongFrameDetector", "Stopped LoAF tracking");
+    }
+  }
+  /**
+   * Start manual frame tracking using requestAnimationFrame
+   */
+  startManualFrameTracking() {
+    __privateSet$3(this, _lastFrameTime, performance.now());
+    __privateSet$3(this, _frameTrackingId, requestAnimationFrame(() => this.measureFrames()));
+  }
+  /**
+   * Stop manual frame tracking
+   */
+  stopManualFrameTracking() {
+    if (__privateGet$3(this, _frameTrackingId)) {
+      cancelAnimationFrame(__privateGet$3(this, _frameTrackingId));
+      __privateSet$3(this, _frameTrackingId, null);
+      writeSceneLog("LongFrameDetector", "Stopped manual frame tracking");
+    }
+  }
+}
+_isTracking = new WeakMap();
+_callback = new WeakMap();
+_frameTrackingId = new WeakMap();
+_lastFrameTime = new WeakMap();
+_loafObserver = new WeakMap();
+
+var __typeError$2 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
+var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet$2(obj, member, value);
+  },
+  get _() {
+    return __privateGet$2(obj, member, getter);
+  }
+});
+var _profileInProgress, _profileStartTs, _trailAnimationFrameId, _recordedTrailingSpans, _longFrameDetector, _longFramesCount, _longFramesTotalTime, _visibilityChangeHandler;
+const POST_STORM_WINDOW = 2e3;
+const DEFAULT_LONG_FRAME_THRESHOLD = 30;
+const TAB_INACTIVE_THRESHOLD = 1e3;
+class SceneRenderProfiler {
+  constructor(queryController) {
+    this.queryController = queryController;
+    __privateAdd$2(this, _profileInProgress, null);
+    __privateAdd$2(this, _profileStartTs, null);
+    __privateAdd$2(this, _trailAnimationFrameId, null);
+    // Will keep measured lengths trailing frames
+    __privateAdd$2(this, _recordedTrailingSpans, []);
+    // Long frame tracking
+    __privateAdd$2(this, _longFrameDetector);
+    __privateAdd$2(this, _longFramesCount, 0);
+    __privateAdd$2(this, _longFramesTotalTime, 0);
+    __privateAdd$2(this, _visibilityChangeHandler, null);
+    this.measureTrailingFrames = (measurementStartTs, lastFrameTime, profileStartTs) => {
+      var _a, _b, _c, _d;
+      const currentFrameTime = performance.now();
+      const frameLength = currentFrameTime - lastFrameTime;
+      if (frameLength > TAB_INACTIVE_THRESHOLD) {
+        writeSceneLog("SceneRenderProfiler", "Tab was inactive, cancelling profile measurement");
+        this.cancelProfile();
+        return;
+      }
+      __privateGet$2(this, _recordedTrailingSpans).push(frameLength);
+      if (currentFrameTime - measurementStartTs < POST_STORM_WINDOW) {
+        if (__privateGet$2(this, _profileInProgress)) {
+          __privateSet$2(this, _trailAnimationFrameId, requestAnimationFrame(
+            () => this.measureTrailingFrames(measurementStartTs, currentFrameTime, profileStartTs)
+          ));
+        }
+      } else {
+        const slowFrames = processRecordedSpans(__privateGet$2(this, _recordedTrailingSpans));
+        const slowFramesTime = slowFrames.reduce((acc, val) => acc + val, 0);
+        writeSceneLog(
+          "SceneRenderProfiler",
+          `Profile tail recorded - Slow frames: ${slowFramesTime.toFixed(1)}ms (${slowFrames.length} frames)`
+        );
+        writeSceneLog("", `  \u251C\u2500 Origin: ${((_a = __privateGet$2(this, _profileInProgress)) == null ? void 0 : _a.origin) || "unknown"}`);
+        writeSceneLog("", `  \u2514\u2500 Crumbs:`, ((_b = __privateGet$2(this, _profileInProgress)) == null ? void 0 : _b.crumbs) || []);
+        __privateSet$2(this, _recordedTrailingSpans, []);
+        const profileDuration = measurementStartTs - profileStartTs;
+        if (typeof performance !== "undefined" && performance.mark) {
+          const profileName = ((_c = __privateGet$2(this, _profileInProgress)) == null ? void 0 : _c.origin) || "unknown";
+          const totalTime = profileDuration + slowFramesTime;
+          performance.mark(`Dashboard Profile End: ${profileName}`);
+          const startMarkName = `Dashboard Profile Start: ${profileName}`;
+          try {
+            performance.measure(
+              `Dashboard Profile: ${profileName} (${totalTime.toFixed(1)}ms)`,
+              startMarkName,
+              `Dashboard Profile End: ${profileName}`
+            );
+          } catch (e) {
+            performance.mark(`Dashboard Profile Complete: ${profileName} (${totalTime.toFixed(1)}ms)`);
+          }
+          if (slowFrames.length > 0) {
+            const slowFramesMarkName = `Slow Frames Summary: ${slowFrames.length} frames (${slowFramesTime.toFixed(
+              1
+            )}ms)`;
+            performance.mark(slowFramesMarkName);
+            slowFrames.forEach((frameTime, index) => {
+              if (frameTime > 16) {
+                try {
+                  const frameStartTime = __privateGet$2(this, _profileStartTs) + profileDuration + (index > 0 ? slowFrames.slice(0, index).reduce((sum, t) => sum + t, 0) : 0);
+                  const frameId = `slow-frame-${index}`;
+                  const frameStartMark = `${frameId}-start`;
+                  const frameEndMark = `${frameId}-end`;
+                  performance.mark(frameStartMark, { startTime: frameStartTime });
+                  performance.mark(frameEndMark, { startTime: frameStartTime + frameTime });
+                  performance.measure(`Slow Frame ${index + 1}: ${frameTime.toFixed(1)}ms`, frameStartMark, frameEndMark);
+                } catch (e) {
+                  performance.mark(`Slow Frame ${index + 1}: ${frameTime.toFixed(1)}ms`);
+                }
+              }
+            });
+          }
+        }
+        const completionTimestamp = performance.now();
+        writeSceneLog("SceneRenderProfiler", "Profile completed");
+        writeSceneLog("", `  \u251C\u2500 Timestamp: ${completionTimestamp.toFixed(1)}ms`);
+        writeSceneLog("", `  \u251C\u2500 Total time: ${(profileDuration + slowFramesTime).toFixed(1)}ms`);
+        writeSceneLog("", `  \u251C\u2500 Slow frames: ${slowFramesTime}ms (${slowFrames.length} frames)`);
+        writeSceneLog("", `  \u2514\u2500 Long frames: ${__privateGet$2(this, _longFramesTotalTime)}ms (${__privateGet$2(this, _longFramesCount)} frames)`);
+        __privateGet$2(this, _longFrameDetector).stop();
+        writeSceneLogStyled(
+          "SceneRenderProfiler",
+          `Stopped long frame detection - profile complete at ${completionTimestamp.toFixed(1)}ms`,
+          "color: #00CC00; font-weight: bold;"
+        );
+        __privateSet$2(this, _trailAnimationFrameId, null);
+        const profileEndTs = profileStartTs + profileDuration + slowFramesTime;
+        if (!__privateGet$2(this, _profileInProgress)) {
+          return;
+        }
+        performance.measure(`DashboardInteraction ${__privateGet$2(this, _profileInProgress).origin}`, {
+          start: profileStartTs,
+          end: profileEndTs
+        });
+        const networkDuration = captureNetwork(profileStartTs, profileEndTs);
+        if (((_d = this.queryController) == null ? void 0 : _d.state.onProfileComplete) && __privateGet$2(this, _profileInProgress)) {
+          this.queryController.state.onProfileComplete({
+            origin: __privateGet$2(this, _profileInProgress).origin,
+            crumbs: __privateGet$2(this, _profileInProgress).crumbs,
+            duration: profileDuration + slowFramesTime,
+            networkDuration,
+            startTs: profileStartTs,
+            endTs: profileEndTs,
+            longFramesCount: __privateGet$2(this, _longFramesCount),
+            longFramesTotalTime: __privateGet$2(this, _longFramesTotalTime),
+            // @ts-ignore
+            jsHeapSizeLimit: performance.memory ? performance.memory.jsHeapSizeLimit : 0,
+            // @ts-ignore
+            usedJSHeapSize: performance.memory ? performance.memory.usedJSHeapSize : 0,
+            // @ts-ignore
+            totalJSHeapSize: performance.memory ? performance.memory.totalJSHeapSize : 0
+          });
+          __privateSet$2(this, _profileInProgress, null);
+          __privateSet$2(this, _trailAnimationFrameId, null);
+        }
+        if (window.__runs) {
+          window.__runs += `${Date.now()}, ${profileDuration + slowFramesTime}
+`;
+        } else {
+          window.__runs = `${Date.now()}, ${profileDuration + slowFramesTime}
+`;
+        }
+      }
+    };
+    __privateSet$2(this, _longFrameDetector, new LongFrameDetector());
+    this.setupVisibilityChangeHandler();
+  }
+  setQueryController(queryController) {
+    this.queryController = queryController;
+  }
+  setupVisibilityChangeHandler() {
+    if (__privateGet$2(this, _visibilityChangeHandler)) {
+      return;
+    }
+    __privateSet$2(this, _visibilityChangeHandler, () => {
+      if (document.hidden && __privateGet$2(this, _profileInProgress)) {
+        writeSceneLog("SceneRenderProfiler", "Tab became inactive, cancelling profile");
+        this.cancelProfile();
+      }
+    });
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", __privateGet$2(this, _visibilityChangeHandler));
+    }
+  }
+  cleanup() {
+    if (__privateGet$2(this, _visibilityChangeHandler) && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", __privateGet$2(this, _visibilityChangeHandler));
+      __privateSet$2(this, _visibilityChangeHandler, null);
     }
+    __privateGet$2(this, _longFrameDetector).stop();
+    this.cancelProfile();
   }
-}
-_running = new WeakMap();
-_tryCompleteProfileFrameId = new WeakMap();
-
-function getQueryController(sceneObject) {
-  let parent = sceneObject;
-  while (parent) {
-    if (parent.state.$behaviors) {
-      for (const behavior of parent.state.$behaviors) {
-        if (isQueryController(behavior)) {
-          return behavior;
-        }
+  startProfile(name) {
+    if (document.hidden) {
+      writeSceneLog("SceneRenderProfiler", "Tab is inactive, skipping profile", name);
+      return;
+    }
+    if (__privateGet$2(this, _profileInProgress)) {
+      if (__privateGet$2(this, _trailAnimationFrameId)) {
+        this.cancelProfile();
+        this._startNewProfile(name, true);
+      } else {
+        this.addCrumb(name);
       }
+    } else {
+      this._startNewProfile(name);
     }
-    parent = parent.parent;
   }
-  return void 0;
-}
-
-class SceneDataNode extends SceneObjectBase {
-  constructor(state) {
-    super({
-      data: emptyPanelData,
-      ...state
+  /**
+   * 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
+   */
+  _startNewProfile(name, force = false) {
+    var _a;
+    __privateSet$2(this, _profileInProgress, { origin: name, crumbs: [] });
+    __privateSet$2(this, _profileStartTs, performance.now());
+    __privateSet$2(this, _longFramesCount, 0);
+    __privateSet$2(this, _longFramesTotalTime, 0);
+    if (typeof performance !== "undefined" && performance.mark) {
+      const markName = `Dashboard Profile Start: ${name}`;
+      performance.mark(markName);
+    }
+    writeSceneLogStyled(
+      "SceneRenderProfiler",
+      `Profile started[${force ? "forced" : "clean"}]`,
+      "color: #FFCC00; font-weight: bold;"
+    );
+    writeSceneLog("", `  \u251C\u2500 Origin: ${((_a = __privateGet$2(this, _profileInProgress)) == null ? void 0 : _a.origin) || "unknown"}`);
+    writeSceneLog("", `  \u2514\u2500 Timestamp: ${__privateGet$2(this, _profileStartTs).toFixed(1)}ms`);
+    __privateGet$2(this, _longFrameDetector).start((event) => {
+      if (!__privateGet$2(this, _profileInProgress) || !__privateGet$2(this, _profileStartTs)) {
+        return;
+      }
+      if (event.timestamp < __privateGet$2(this, _profileStartTs)) {
+        return;
+      }
+      __privateWrapper(this, _longFramesCount)._++;
+      __privateSet$2(this, _longFramesTotalTime, __privateGet$2(this, _longFramesTotalTime) + event.duration);
     });
   }
-  getResultsStream() {
-    const result = {
-      origin: this,
-      data: this.state.data
-    };
-    return rxjs.of(result);
-  }
-}
-const emptyPanelData = {
-  state: schema.LoadingState.Done,
-  series: [],
-  timeRange: data.getDefaultTimeRange()
-};
-
-class SceneObjectUrlSyncConfig {
-  constructor(_sceneObject, _options) {
-    this._sceneObject = _sceneObject;
-    this._nextChangeShouldAddHistoryStep = false;
-    this._keys = _options.keys;
+  recordProfileTail(measurementStartTime, profileStartTs) {
+    __privateSet$2(this, _trailAnimationFrameId, requestAnimationFrame(
+      () => this.measureTrailingFrames(measurementStartTime, measurementStartTime, profileStartTs)
+    ));
   }
-  getKeys() {
-    if (typeof this._keys === "function") {
-      return this._keys();
+  tryCompletingProfile() {
+    var _a;
+    writeSceneLog("SceneRenderProfiler", "Trying to complete profile", __privateGet$2(this, _profileInProgress));
+    if (((_a = this.queryController) == null ? void 0 : _a.runningQueriesCount()) === 0 && __privateGet$2(this, _profileInProgress)) {
+      writeSceneLog("SceneRenderProfiler", "All queries completed, starting tail measurement");
+      this.recordProfileTail(performance.now(), __privateGet$2(this, _profileStartTs));
     }
-    return this._keys;
-  }
-  getUrlState() {
-    return this._sceneObject.getUrlState();
   }
-  updateFromUrl(values) {
-    this._sceneObject.updateFromUrl(values);
+  isTailRecording() {
+    return Boolean(__privateGet$2(this, _trailAnimationFrameId));
   }
-  shouldCreateHistoryStep(values) {
-    return this._nextChangeShouldAddHistoryStep;
+  cancelTailRecording() {
+    if (__privateGet$2(this, _trailAnimationFrameId)) {
+      cancelAnimationFrame(__privateGet$2(this, _trailAnimationFrameId));
+      __privateSet$2(this, _trailAnimationFrameId, null);
+      writeSceneLog("SceneRenderProfiler", "Cancelled recording frames, new profile started");
+    }
   }
-  performBrowserHistoryAction(callback) {
-    this._nextChangeShouldAddHistoryStep = true;
-    callback();
-    this._nextChangeShouldAddHistoryStep = false;
+  // cancel profile
+  cancelProfile() {
+    if (__privateGet$2(this, _profileInProgress)) {
+      writeSceneLog("SceneRenderProfiler", "Cancelling profile", __privateGet$2(this, _profileInProgress));
+      __privateSet$2(this, _profileInProgress, null);
+      if (__privateGet$2(this, _trailAnimationFrameId)) {
+        cancelAnimationFrame(__privateGet$2(this, _trailAnimationFrameId));
+        __privateSet$2(this, _trailAnimationFrameId, null);
+      }
+      __privateGet$2(this, _longFrameDetector).stop();
+      writeSceneLog("SceneRenderProfiler", "Stopped long frame detection - profile cancelled");
+      __privateSet$2(this, _recordedTrailingSpans, []);
+      __privateSet$2(this, _longFramesCount, 0);
+      __privateSet$2(this, _longFramesTotalTime, 0);
+    }
   }
-}
-
-function getClosest(sceneObject, extract) {
-  let curSceneObject = sceneObject;
-  let extracted = void 0;
-  while (curSceneObject && !extracted) {
-    extracted = extract(curSceneObject);
-    curSceneObject = curSceneObject.parent;
+  addCrumb(crumb) {
+    if (__privateGet$2(this, _profileInProgress)) {
+      writeSceneLog("SceneRenderProfiler", "Adding crumb:", crumb);
+      __privateGet$2(this, _profileInProgress).crumbs.push(crumb);
+    }
   }
-  return extracted;
 }
-
-const INTERVAL_STRING_REGEX = /^\d+[yYmMsSwWhHdD]$/;
-function parseUrlParam(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  if (value.indexOf("now") !== -1) {
-    return value;
-  }
-  if (INTERVAL_STRING_REGEX.test(value)) {
-    return value;
-  }
-  if (value.length === 8) {
-    const utcValue = data.toUtc(value, "YYYYMMDD");
-    if (utcValue.isValid()) {
-      return utcValue.toISOString();
-    }
-  } else if (value.length === 15) {
-    const utcValue = data.toUtc(value, "YYYYMMDDTHHmmss");
-    if (utcValue.isValid()) {
-      return utcValue.toISOString();
-    }
-  } else if (value.length === 19) {
-    const utcValue = data.toUtc(value, "YYYY-MM-DD HH:mm:ss");
-    if (utcValue.isValid()) {
-      return utcValue.toISOString();
+_profileInProgress = new WeakMap();
+_profileStartTs = new WeakMap();
+_trailAnimationFrameId = new WeakMap();
+_recordedTrailingSpans = new WeakMap();
+_longFrameDetector = new WeakMap();
+_longFramesCount = new WeakMap();
+_longFramesTotalTime = new WeakMap();
+_visibilityChangeHandler = new WeakMap();
+function processRecordedSpans(spans) {
+  for (let i = spans.length - 1; i >= 0; i--) {
+    if (spans[i] > DEFAULT_LONG_FRAME_THRESHOLD) {
+      return spans.slice(0, i + 1);
     }
-  } else if (value.length === 24) {
-    const utcValue = data.toUtc(value);
-    return utcValue.toISOString();
   }
-  const epoch = parseInt(value, 10);
-  if (!isNaN(epoch)) {
-    return data.toUtc(epoch).toISOString();
+  return [spans[0]];
+}
+function captureNetwork(startTs, endTs) {
+  const entries = performance.getEntriesByType("resource");
+  performance.clearResourceTimings();
+  const networkEntries = entries.filter(
+    (entry) => entry.startTime >= startTs && entry.startTime <= endTs && entry.responseEnd >= startTs && entry.responseEnd <= endTs
+  );
+  for (const entry of networkEntries) {
+    performance.measure("Network entry " + entry.name, {
+      start: entry.startTime,
+      end: entry.responseEnd
+    });
   }
-  return null;
+  return calculateNetworkTime(networkEntries);
 }
-
-function evaluateTimeRange(from, to, timeZone, fiscalYearStartMonth, delay, weekStart) {
-  const hasDelay = delay && to === "now";
-  const now = Date.now();
-  if (weekStart) {
-    setWeekStartIfDifferent(weekStart);
+function calculateNetworkTime(requests) {
+  if (requests.length === 0) {
+    return 0;
   }
-  const parseOrToDateTime = (val, options) => {
-    if (data.dateMath.toDateTime) {
-      return data.dateMath.toDateTime(val, options);
+  requests.sort((a, b) => a.startTime - b.startTime);
+  let totalNetworkTime = 0;
+  let currentStart = requests[0].startTime;
+  let currentEnd = requests[0].responseEnd;
+  for (let i = 1; i < requests.length; i++) {
+    if (requests[i].startTime <= currentEnd) {
+      currentEnd = Math.max(currentEnd, requests[i].responseEnd);
     } else {
-      return data.dateMath.parse(val, options.roundUp, options.timezone, options.fiscalYearStartMonth);
-    }
-  };
-  return {
-    to: parseOrToDateTime(hasDelay ? "now-" + delay : to, {
-      roundUp: true,
-      timezone: timeZone,
-      fiscalYearStartMonth,
-      now
-    }),
-    from: parseOrToDateTime(from, {
-      roundUp: false,
-      timezone: timeZone,
-      fiscalYearStartMonth,
-      now
-    }),
-    raw: {
-      from,
-      to
+      totalNetworkTime += currentEnd - currentStart;
+      currentStart = requests[i].startTime;
+      currentEnd = requests[i].responseEnd;
     }
-  };
-}
-let prevWeekStart;
-function setWeekStartIfDifferent(weekStart) {
-  if (weekStart !== prevWeekStart) {
-    prevWeekStart = weekStart;
-    data.setWeekStart(weekStart);
-  }
-}
-
-function isValid$1(value, roundUp, timeZone) {
-  if (data.isDateTime(value)) {
-    return value.isValid();
-  }
-  if (data.dateMath.isMathString(value)) {
-    return data.dateMath.isValid(value);
   }
-  const parsed = data.dateTimeParse(value, { roundUp, timeZone });
-  return parsed.isValid();
+  totalNetworkTime += currentEnd - currentStart;
+  return totalNetworkTime;
 }
+const REFRESH_INTERACTION = "refresh";
+const TIME_RANGE_CHANGE_INTERACTION = "time_range_change";
+const FILTER_REMOVED_INTERACTION = "filter_removed";
+const FILTER_CHANGED_INTERACTION = "filter_changed";
+const FILTER_RESTORED_INTERACTION = "filter_restored";
+const VARIABLE_VALUE_CHANGED_INTERACTION = "variable_value_changed";
+const SCOPES_CHANGED_INTERACTION = "scopes_changed";
 
 class SceneTimeRange extends SceneObjectBase {
   constructor(state = {}) {
@@ -3784,13 +3960,10 @@ function GroupByVariableRenderer({ model }) {
         setUncommittedValue(newValue);
       },
       onOpenMenu: async () => {
-        const profiler = getInteractionProfiler(model);
-        profiler == null ? void 0 : profiler.startProfile(USER_INTERACTIONS.GROUPBY_DROPDOWN);
         setIsFetchingOptions(true);
         await rxjs.lastValueFrom(model.validateAndUpdate());
         setIsFetchingOptions(false);
         setIsOptionsOpen(true);
-        profiler == null ? void 0 : profiler.stopProfile();
       },
       onCloseMenu: () => {
         setIsOptionsOpen(false);
@@ -3840,13 +4013,10 @@ function GroupByVariableRenderer({ model }) {
         }
       },
       onOpenMenu: async () => {
-        const profiler = getInteractionProfiler(model);
-        profiler == null ? void 0 : profiler.startProfile(USER_INTERACTIONS.GROUPBY_DROPDOWN);
         setIsFetchingOptions(true);
         await rxjs.lastValueFrom(model.validateAndUpdate());
         setIsFetchingOptions(false);
         setIsOptionsOpen(true);
-        profiler == null ? void 0 : profiler.stopProfile();
       },
       onCloseMenu: () => {
         setIsOptionsOpen(false);
@@ -5011,11 +5181,6 @@ const AdHocCombobox = React.forwardRef(function AdHocCombobox2({ filter, model,
   const handleFetchOptions = React.useCallback(
     async (inputType) => {
       var _a2;
-      const profiler = getInteractionProfiler(model);
-      const interactionName = inputType === "key" ? USER_INTERACTIONS.ADHOC_KEYS_DROPDOWN : USER_INTERACTIONS.ADHOC_VALUES_DROPDOWN;
-      if (inputType !== "operator") {
-        profiler == null ? void 0 : profiler.startProfile(interactionName);
-      }
       setOptionsError(false);
       setOptionsLoading(true);
       setOptions([]);
@@ -5029,7 +5194,6 @@ const AdHocCombobox = React.forwardRef(function AdHocCombobox2({ filter, model,
           options2 = await model._getValuesFor(filter);
         }
         if (filterInputTypeRef.current !== inputType) {
-          profiler == null ? void 0 : profiler.stopProfile();
           return;
         }
         setOptions(options2);
@@ -5042,7 +5206,6 @@ const AdHocCombobox = React.forwardRef(function AdHocCombobox2({ filter, model,
         setOptionsError(true);
       }
       setOptionsLoading(false);
-      profiler == null ? void 0 : profiler.stopProfile();
     },
     [filter, model]
   );
@@ -8090,7 +8253,6 @@ const sceneGraph = {
   findAllObjects,
   getAncestor,
   getQueryController,
-  getInteractionProfiler,
   findDescendents,
   getScopes
 };
@@ -9590,7 +9752,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
   ActWhenVariableChanged: ActWhenVariableChanged,
   CursorSync: CursorSync,
   LiveNowTimer: LiveNowTimer,
-  SceneInteractionProfiler: SceneInteractionProfiler,
   SceneQueryController: SceneQueryController
 });
 
@@ -11634,15 +11795,14 @@ function SceneGridLayoutRenderer({ model }) {
       ))
     );
   };
-  return /* @__PURE__ */ React__default.default.createElement(
-    "div",
-    {
-      ref: outerDivRef,
-      style: { flex: "1 1 auto", position: "relative", zIndex: 1, width: "100%" }
-    },
-    renderGrid(width, height)
-  );
+  return /* @__PURE__ */ React__default.default.createElement("div", { ref: outerDivRef, className: gridWrapperClass }, renderGrid(width, height));
 }
+const gridWrapperClass = css.css({
+  flex: "1 1 auto",
+  position: "relative",
+  zIndex: 1,
+  width: "100%"
+});
 const GridItemWrapper = React__default.default.forwardRef((props, ref) => {
   var _a;
   const { grid, layoutItem, index, totalCount, isLazy, style, onLoad, onChange, children, ...divProps } = props;
@@ -11847,6 +12007,20 @@ const _SceneGridLayout = class _SceneGridLayout extends SceneObjectBase {
       }
     };
   }
+  adjustYPositions(after, amount) {
+    for (const child of this.state.children) {
+      if (child.state.y > after) {
+        child.setState({ y: child.state.y + amount });
+      }
+      if (child instanceof SceneGridRow) {
+        for (const rowChild of child.state.children) {
+          if (rowChild.state.y > after) {
+            rowChild.setState({ y: rowChild.state.y + amount });
+          }
+        }
+      }
+    }
+  }
   toggleRow(row) {
     var _a, _b;
     const isCollapsed = row.state.isCollapsed;
@@ -14887,25 +15061,25 @@ const VizConfigBuilders = {
 
 function __variableDynamicImportRuntime0__(path) {
   switch (path) {
-    case '../locales/cs-CZ/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CY85TD5F.js'); });
-    case '../locales/de-DE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-n10eQkNF.js'); });
+    case '../locales/cs-CZ/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BcDO8gk4.js'); });
+    case '../locales/de-DE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CzZTvOrf.js'); });
     case '../locales/en-US/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-C_CT7peT.js'); });
-    case '../locales/es-ES/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-YMli37Xh.js'); });
-    case '../locales/fr-FR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DXM1LI4B.js'); });
-    case '../locales/hu-HU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DlUSL8jI.js'); });
-    case '../locales/id-ID/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-D5qs_fc9.js'); });
-    case '../locales/it-IT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Dy2CLUY9.js'); });
-    case '../locales/ja-JP/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CBRfJ-2H.js'); });
-    case '../locales/ko-KR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CgIzGE5F.js'); });
-    case '../locales/nl-NL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Br6NPcwR.js'); });
-    case '../locales/pl-PL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-B3ypGD5T.js'); });
-    case '../locales/pt-BR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-COr0P0oM.js'); });
-    case '../locales/pt-PT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-Cub9Gl0n.js'); });
-    case '../locales/ru-RU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BGCbMCFm.js'); });
-    case '../locales/sv-SE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CqRf9pRc.js'); });
-    case '../locales/tr-TR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CeVkPanY.js'); });
-    case '../locales/zh-Hans/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-DObtL2WT.js'); });
-    case '../locales/zh-Hant/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-B0JDDOYY.js'); });
+    case '../locales/es-ES/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-zGpJY4O3.js'); });
+    case '../locales/fr-FR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CfoPR_PZ.js'); });
+    case '../locales/hu-HU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CoXR5Z7T.js'); });
+    case '../locales/id-ID/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-kfW02M-K.js'); });
+    case '../locales/it-IT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CMtHJ23j.js'); });
+    case '../locales/ja-JP/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-cTJt4LR7.js'); });
+    case '../locales/ko-KR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BbJq3cEa.js'); });
+    case '../locales/nl-NL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BwQ_A3lk.js'); });
+    case '../locales/pl-PL/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BbRDYrqK.js'); });
+    case '../locales/pt-BR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-naZktXG6.js'); });
+    case '../locales/pt-PT/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CixWq8rH.js'); });
+    case '../locales/ru-RU/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-VOzZRdKp.js'); });
+    case '../locales/sv-SE/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-BtGEpoZT.js'); });
+    case '../locales/tr-TR/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CqMfWT-f.js'); });
+    case '../locales/zh-Hans/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-CS09sc_L.js'); });
+    case '../locales/zh-Hant/grafana-scenes.json': return Promise.resolve().then(function () { return require('./grafana-scenes-C-CibbsO.js'); });
     default: return new Promise(function(resolve, reject) {
       (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
         reject.bind(null, new Error("Unknown variable dynamic import: " + path))
@@ -15028,6 +15202,7 @@ exports.VizPanelExploreButton = VizPanelExploreButton;
 exports.VizPanelMenu = VizPanelMenu;
 exports.behaviors = index$1;
 exports.dataLayers = index;
+exports.escapeUrlPipeDelimiters = escapeUrlPipeDelimiters;
 exports.formatRegistry = formatRegistry;
 exports.getExploreURL = getExploreURL;
 exports.isCustomVariableValue = isCustomVariableValue;