nuxt-devtools-observatory 0.1.31 → 0.1.32

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": "^3.0.0 || ^4.0.0"
   },
-  "version": "0.1.31",
+  "version": "0.1.32",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -612,7 +612,7 @@ const module$1 = defineNuxtModule({
     if (resolved.fetchDashboard || resolved.provideInjectGraph || resolved.composableTracker || resolved.renderHeatmap || resolved.transitionTracker) {
       addPlugin(resolver.resolve("./runtime/plugin"));
     }
-    if (resolved.fetchDashboard) {
+    if (resolved.fetchDashboard || resolved.traceViewer && resolved.instrumentServer) {
       addServerPlugin(resolver.resolve("./runtime/nitro/fetch-capture"));
     }
     const base = "/__observatory";

package/dist/runtime/composables/composable-registry.d.ts

@@ -22,6 +22,11 @@ export interface ComposableEntry {
      * instances of this composable — indicates module-level (global) state.
      */
     sharedKeys: string[];
+    /**
+     * Stable per-composable-name identity group id for each shared key.
+     * Keys are ref/reactive key names; values are group ids like `group-1`.
+     */
+    sharedKeyGroups?: Record<string, string>;
     watcherCount: number;
     intervalCount: number;
     lifecycle: {
@@ -39,6 +44,19 @@ export interface ComposableEntry {
     /** Whether this composable is called from a layout component (persists across pages). */
     isLayoutComposable?: boolean;
 }
+interface SsrObservatoryEvent {
+    context?: {
+        __observatoryRequestId?: string;
+        __ssrFetchStart?: number;
+    };
+}
+export declare function __recordSsrComposableSpan(name: string, meta: {
+    file: string;
+    line: number;
+}, startTime: number, endTime: number, opts?: {
+    error?: unknown;
+    event?: SsrObservatoryEvent;
+}): void;
 /**
  * Registers a new composable entry, updates an existing one, or retrieves all entries.
  * @remarks The returned object exposes the following methods:
@@ -78,3 +96,4 @@ export declare function __trackComposable<T>(name: string, callFn: () => T, meta
     file: string;
     line: number;
 }): T;
+export {};

package/dist/runtime/composables/composable-registry.js

@@ -1,4 +1,32 @@
 import { isRef, isReactive, isReadonly, unref, computed, watchEffect, getCurrentInstance, onUnmounted } from "vue";
+import { addSsrPhaseSpan } from "../nitro/ssr-trace-store.js";
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+export function __recordSsrComposableSpan(name, meta, startTime, endTime, opts = {}) {
+  const eventContext = opts.event?.context ?? globalThis.__observatorySsrContext__;
+  const requestId = eventContext?.__observatoryRequestId;
+  const requestStart = eventContext?.__ssrFetchStart;
+  if (!requestId || typeof requestStart !== "number") {
+    return;
+  }
+  const metadata = {
+    file: meta.file,
+    line: meta.line,
+    phase: "setup"
+  };
+  if (opts.error instanceof Error) {
+    metadata.errorMessage = opts.error.message;
+  }
+  addSsrPhaseSpan(requestId, {
+    name: `composable:${name}`,
+    type: "composable",
+    startMs: Math.max(startTime - requestStart, 0),
+    endMs: Math.max(endTime - requestStart, 0),
+    error: !!opts.error,
+    metadata
+  });
+}
 export function setupComposableRegistry() {
   const entries = /* @__PURE__ */ new Map();
   const liveRefs = /* @__PURE__ */ new Map();
@@ -38,14 +66,30 @@ export function setupComposableRegistry() {
     }
     nameCache = /* @__PURE__ */ new Map();
     sharedKeysCache.set(name, nameCache);
+    const identityIds = /* @__PURE__ */ new WeakMap();
+    let nextIdentity = 1;
+    const getIdentityGroup = (obj) => {
+      if (!obj || typeof obj !== "object") {
+        return void 0;
+      }
+      const target = obj;
+      const existing = identityIds.get(target);
+      if (existing) {
+        return existing;
+      }
+      const created = `group-${nextIdentity++}`;
+      identityIds.set(target, created);
+      return created;
+    };
     const peers = [...entries.entries()].filter(([, e]) => e.name === name);
     for (const [eid] of peers) {
       const ownRaw = rawRefs.get(eid);
       if (!ownRaw) {
-        nameCache.set(eid, []);
+        nameCache.set(eid, { keys: [], groups: {} });
         continue;
       }
       const shared = /* @__PURE__ */ new Set();
+      const groups = {};
       for (const [otherId] of peers) {
         if (otherId === eid) {
           continue;
@@ -57,12 +101,16 @@ export function setupComposableRegistry() {
         for (const [key, obj] of Object.entries(ownRaw)) {
           if (key in otherRaw && otherRaw[key] === obj) {
             shared.add(key);
+            const identity = getIdentityGroup(obj);
+            if (identity) {
+              groups[key] = identity;
+            }
           }
         }
       }
-      nameCache.set(eid, [...shared]);
+      nameCache.set(eid, { keys: [...shared], groups });
     }
-    return nameCache.get(id) ?? [];
+    return nameCache.get(id) ?? { keys: [], groups: {} };
   }
   let currentRoute = "/";
   function setRoute(path) {
@@ -197,6 +245,7 @@ export function setupComposableRegistry() {
         }
       ])
     );
+    const shared = getSharedKeys(entry.id, entry.name);
     return {
       id: entry.id,
       name: entry.name,
@@ -207,7 +256,8 @@ export function setupComposableRegistry() {
       leakReason: entry.leakReason,
       refs: freshRefs,
       history: entryHistory.get(entry.id) ?? [],
-      sharedKeys: getSharedKeys(entry.id, entry.name),
+      sharedKeys: shared.keys,
+      sharedKeyGroups: shared.groups,
       watcherCount: entry.watcherCount,
       intervalCount: entry.intervalCount,
       lifecycle: entry.lifecycle,
@@ -318,7 +368,15 @@ export function __trackComposable(name, callFn, meta) {
     return callFn();
   }
   if (!import.meta.client) {
-    return callFn();
+    const startTime = nowMs();
+    try {
+      const result2 = callFn();
+      __recordSsrComposableSpan(name, meta, startTime, nowMs());
+      return result2;
+    } catch (error) {
+      __recordSsrComposableSpan(name, meta, startTime, nowMs(), { error });
+      throw error;
+    }
   }
   const registry = window.__observatory__?.composable;
   if (!registry) {

package/dist/runtime/composables/render-registry.js

@@ -8,6 +8,7 @@ export function setupRenderRegistry(nuxtApp, options = {}) {
   const HIDE_INTERNALS = config.heatmapHideInternals ?? false;
   let dirty = true;
   let cachedSnapshot = "[]";
+  let resetTimestamp = 0;
   const liveElements = /* @__PURE__ */ new Map();
   function markDirty() {
     dirty = true;
@@ -61,6 +62,7 @@ export function setupRenderRegistry(nuxtApp, options = {}) {
     };
   }
   function reset() {
+    resetTimestamp = performance.now();
     for (const entry of entries.values()) {
       entry.isPersistent = true;
       entry.rerenders = 0;
@@ -73,21 +75,27 @@ export function setupRenderRegistry(nuxtApp, options = {}) {
   }
   function aggregateFromComponentSpans() {
     const componentSpans = traceStore.getAllTraces().flatMap((trace) => trace.spans).filter((span) => span.type === "component");
-    const spansByUid = /* @__PURE__ */ new Map();
+    const allSpansByUid = /* @__PURE__ */ new Map();
+    const postResetSpansByUid = /* @__PURE__ */ new Map();
     for (const span of componentSpans) {
       const uidValue = span.metadata?.uid;
       const uid = typeof uidValue === "number" ? uidValue : Number(uidValue);
       if (!Number.isFinite(uid)) {
         continue;
       }
-      const list = spansByUid.get(uid) ?? [];
-      list.push(span);
-      spansByUid.set(uid, list);
+      const allList = allSpansByUid.get(uid) ?? [];
+      allList.push(span);
+      allSpansByUid.set(uid, allList);
+      if (span.startTime >= resetTimestamp) {
+        const postList = postResetSpansByUid.get(uid) ?? [];
+        postList.push(span);
+        postResetSpansByUid.set(uid, postList);
+      }
     }
     for (const [uid, entry] of entries.entries()) {
-      const spans = spansByUid.get(uid) ?? [];
-      spans.sort((a, b) => a.startTime - b.startTime);
-      const timeline = spans.slice(-MAX_TIMELINE).map((span) => {
+      const allSpans = (allSpansByUid.get(uid) ?? []).sort((a, b) => a.startTime - b.startTime);
+      const postResetSpans = (postResetSpansByUid.get(uid) ?? []).sort((a, b) => a.startTime - b.startTime);
+      const timeline = postResetSpans.slice(-MAX_TIMELINE).map((span) => {
         const lifecycle = span.metadata?.lifecycle === "mounted" ? "mount" : "update";
         const routeValue = span.metadata?.route;
         const route = typeof routeValue === "string" && routeValue.length > 0 ? routeValue : entry.route;
@@ -98,10 +106,10 @@ export function setupRenderRegistry(nuxtApp, options = {}) {
           route
         };
       });
-      const mountCount = spans.filter((span) => span.metadata?.lifecycle === "mounted").length;
-      const rerenders = spans.filter((span) => span.metadata?.lifecycle !== "mounted").length;
-      const totalMs = spans.reduce((sum, span) => sum + (span.durationMs ?? 0), 0);
-      const eventsCount = Math.max(mountCount + rerenders, 1);
+      const mountCount = allSpans.filter((span) => span.metadata?.lifecycle === "mounted").length;
+      const rerenders = postResetSpans.filter((span) => span.metadata?.lifecycle !== "mounted").length;
+      const totalMs = postResetSpans.reduce((sum, span) => sum + (span.durationMs ?? 0), 0);
+      const eventsCount = Math.max(postResetSpans.length, 1);
       entry.mountCount = mountCount;
       entry.rerenders = rerenders;
       entry.totalMs = Math.round(totalMs * 10) / 10;

package/dist/runtime/nitro/fetch-capture.d.ts

@@ -1,7 +1,6 @@
-import type { H3Event } from 'h3';
 interface NitroAppLike {
     hooks: {
-        hook: (name: 'request' | 'afterResponse', handler: (event: H3Event) => void) => void;
+        hook: (name: string, handler: (...args: unknown[]) => void) => void;
     };
 }
 export default function fetchCapturePlugin(nitroApp: NitroAppLike): void;

package/dist/runtime/nitro/fetch-capture.js

@@ -1,14 +1,92 @@
-import { setResponseHeader } from "h3";
+import { getRequestURL, setResponseHeader } from "h3";
+import { addSsrPhaseSpan, createSsrRecord, drainSsrRecord } from "./ssr-trace-store.js";
+let _requestCounter = 0;
+function newRequestId() {
+  _requestCounter = (_requestCounter + 1) % 999999;
+  return `req_${Date.now()}_${_requestCounter}`;
+}
 export default function fetchCapturePlugin(nitroApp) {
-  nitroApp.hooks.hook("request", (event) => {
-    ;
-    event.__ssrFetchStart = performance.now();
+  nitroApp.hooks.hook("request", (...args) => {
+    const event = args[0];
+    const start = performance.now();
+    event.context.__ssrFetchStart = start;
+    let route = "/";
+    try {
+      route = getRequestURL(event).pathname;
+    } catch (error) {
+      console.error("Error getting request URL:", error);
+    }
+    const method = String(event.method ?? event.node?.req?.method ?? "GET").toUpperCase();
+    const requestId = newRequestId();
+    event.context.__observatoryRequestId = requestId;
+    createSsrRecord(requestId, route, method);
+    globalThis.__observatorySsrContext__ = {
+      __observatoryRequestId: requestId,
+      __ssrFetchStart: start
+    };
   });
-  nitroApp.hooks.hook("afterResponse", (event) => {
-    const start = event.__ssrFetchStart;
-    if (start) {
+  nitroApp.hooks.hook("afterResponse", (...args) => {
+    const hookStart = performance.now();
+    const event = args[0];
+    const start = event.context.__ssrFetchStart;
+    if (start !== void 0) {
       const ms = Math.round(performance.now() - start);
       setResponseHeader(event, "x-observatory-ssr-ms", String(ms));
     }
+    const requestId = event.context.__observatoryRequestId;
+    if (requestId) {
+      if (start !== void 0) {
+        const hookEnd = performance.now();
+        addSsrPhaseSpan(requestId, {
+          name: "ssr:afterResponse",
+          type: "server",
+          startMs: Math.max(hookStart - start, 0),
+          endMs: Math.max(hookEnd - start, 0),
+          metadata: {
+            hook: "afterResponse"
+          }
+        });
+      }
+      const durationMs = start !== void 0 ? Math.max(performance.now() - start, 0) : 0;
+      drainSsrRecord(requestId, durationMs);
+    }
+    const active = globalThis.__observatorySsrContext__;
+    if (active?.__observatoryRequestId === requestId) {
+      delete globalThis.__observatorySsrContext__;
+    }
+  });
+  nitroApp.hooks.hook("render:html", (...args) => {
+    const hookStart = performance.now();
+    const html = args[0];
+    const ctx = args[1];
+    const event = ctx?.event;
+    if (!event) {
+      return;
+    }
+    const requestId = event.context.__observatoryRequestId;
+    const start = event.context.__ssrFetchStart;
+    if (!requestId) {
+      return;
+    }
+    if (start !== void 0) {
+      const hookEnd = performance.now();
+      addSsrPhaseSpan(requestId, {
+        name: "ssr:render:html",
+        type: "server",
+        startMs: Math.max(hookStart - start, 0),
+        endMs: Math.max(hookEnd - start, 0),
+        metadata: {
+          hook: "render:html",
+          island: html.island === true
+        }
+      });
+    }
+    const durationMs = start !== void 0 ? Math.max(performance.now() - start, 0) : 0;
+    const record = drainSsrRecord(requestId, durationMs);
+    if (!record) {
+      return;
+    }
+    const json = JSON.stringify(record).replace(/<\/script>/gi, "<\\/script>");
+    html.bodyAppend.push(`<script id="__observatory_ssr_spans__" type="application/json">${json}<\/script>`);
   });
 }

package/dist/runtime/nitro/ssr-trace-store.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Per-request SSR trace collector.
+ *
+ * Each incoming SSR page request gets its own record keyed by a unique
+ * requestId (stored on H3 `event.context`). Spans are accumulated during the
+ * request lifecycle and drained once the HTML is rendered (via the
+ * `render:html` Nitro hook), so they can be injected into the page as inline
+ * JSON for the client plugin to pick up.
+ */
+export interface SsrSpan {
+    id: string;
+    name: string;
+    type: string;
+    /** Milliseconds relative to request start (0 = request began). */
+    startTime: number;
+    endTime?: number;
+    durationMs?: number;
+    status: 'ok' | 'error' | 'active';
+    metadata?: Record<string, unknown>;
+}
+export interface SsrTraceRecord {
+    traceId: string;
+    name: string;
+    spans: SsrSpan[];
+}
+/**
+ * Open a new per-request SSR record. A `navigation` span covering the full
+ * request is pre-populated; its end time is filled in when `drainSsrRecord`
+ * is called.
+ * @param {string} requestId - Unique identifier for the HTTP request, stored in `event.context`.
+ * @param {string} route - Request pathname (e.g. `/dashboard`).
+ * @param {string} method - HTTP method in upper-case (e.g. `GET`).
+ * @returns {SsrTraceRecord} The newly created `SsrTraceRecord` keyed by `requestId`.
+ */
+export declare function createSsrRecord(requestId: string, route: string, method: string): SsrTraceRecord;
+/**
+ * Append an SSR-side fetch span. `startMs` / `endMs` are milliseconds
+ * relative to request start (same origin as `createSsrRecord`).
+ * @param {string} requestId - The request identifier returned by `createSsrRecord`.
+ * @param {object} opts - Span options.
+ * @param {string} opts.url - The request URL or path that was fetched.
+ * @param {string} opts.method - HTTP method in upper-case (e.g. `GET`).
+ * @param {number} opts.startMs - Span start, in ms relative to the request start time.
+ * @param {number} opts.endMs - Span end, in ms relative to the request start time.
+ * @param {number} [opts.statusCode] - Optional HTTP response status code.
+ * @param {boolean} [opts.error] - Set to `true` to mark the span status as `error`.
+ */
+export declare function addSsrFetchSpan(requestId: string, opts: {
+    url: string;
+    method: string;
+    startMs: number;
+    endMs: number;
+    statusCode?: number;
+    error?: boolean;
+}): void;
+/**
+ * Append a generic SSR phase span (e.g. `render:html`, `afterResponse`) to
+ * an existing request record.
+ * @param {string} requestId - The request identifier returned by `createSsrRecord`.
+ * @param {object} opts - Span options.
+ * @param {string} opts.name - Human-readable span name.
+ * @param {string} [opts.type] - Span type. Defaults to `server`.
+ * @param {number} opts.startMs - Span start, in ms relative to request start.
+ * @param {number} opts.endMs - Span end, in ms relative to request start.
+ * @param {boolean} [opts.error] - Set to `true` to mark the span status as `error`.
+ * @param {Record<string, unknown>} [opts.metadata] - Additional metadata fields.
+ */
+export declare function addSsrPhaseSpan(requestId: string, opts: {
+    name: string;
+    type?: string;
+    startMs: number;
+    endMs: number;
+    error?: boolean;
+    metadata?: Record<string, unknown>;
+}): void;
+/**
+ * Finalize and remove the record for `requestId`. The pre-populated
+ * navigation span is closed with `durationMs`. Returns `undefined` if the
+ * requestId is unknown (e.g. non-page requests that never called
+ * `createSsrRecord`).
+ * @param {string} requestId - The request identifier returned by `createSsrRecord`.
+ * @param {number} durationMs - Total SSR request duration in milliseconds, used to close the navigation span.
+ * @returns {SsrTraceRecord | undefined} The completed `SsrTraceRecord`, or `undefined` if no record exists for `requestId`.
+ */
+export declare function drainSsrRecord(requestId: string, durationMs: number): SsrTraceRecord | undefined;

package/dist/runtime/nitro/ssr-trace-store.js

@@ -0,0 +1,84 @@
+const pending = /* @__PURE__ */ new Map();
+let _counter = 0;
+function newId(prefix) {
+  _counter = (_counter + 1) % 999999;
+  return `${prefix}_ssr_${Date.now()}_${_counter}`;
+}
+export function createSsrRecord(requestId, route, method) {
+  const record = {
+    traceId: newId("trace"),
+    name: `ssr:${route}`,
+    spans: [
+      {
+        id: newId("span"),
+        name: "ssr:navigation",
+        type: "navigation",
+        startTime: 0,
+        status: "active",
+        metadata: {
+          origin: "ssr",
+          route,
+          method
+        }
+      }
+    ]
+  };
+  pending.set(requestId, record);
+  return record;
+}
+export function addSsrFetchSpan(requestId, opts) {
+  const record = pending.get(requestId);
+  if (!record) {
+    return;
+  }
+  const durationMs = Math.max(opts.endMs - opts.startMs, 0);
+  record.spans.push({
+    id: newId("span"),
+    name: opts.url,
+    type: "fetch",
+    startTime: opts.startMs,
+    endTime: opts.endMs,
+    durationMs,
+    status: opts.error ? "error" : "ok",
+    metadata: {
+      origin: "ssr",
+      url: opts.url,
+      method: opts.method,
+      statusCode: opts.statusCode
+    }
+  });
+}
+export function addSsrPhaseSpan(requestId, opts) {
+  const record = pending.get(requestId);
+  if (!record) {
+    return;
+  }
+  const durationMs = Math.max(opts.endMs - opts.startMs, 0);
+  record.spans.push({
+    id: newId("span"),
+    name: opts.name,
+    type: opts.type ?? "server",
+    startTime: opts.startMs,
+    endTime: opts.endMs,
+    durationMs,
+    status: opts.error ? "error" : "ok",
+    metadata: {
+      origin: "ssr",
+      ...opts.metadata ?? {}
+    }
+  });
+}
+export function drainSsrRecord(requestId, durationMs) {
+  const record = pending.get(requestId);
+  pending.delete(requestId);
+  if (!record) {
+    return void 0;
+  }
+  const navSpan = record.spans[0];
+  if (navSpan) {
+    navSpan.endTime = durationMs;
+    navSpan.durationMs = durationMs;
+    navSpan.status = "ok";
+  }
+  return record;
+}

package/dist/runtime/plugin.js

@@ -45,10 +45,54 @@ export default defineNuxtPlugin(() => {
   if (config.transitionTracker) {
     registries.transition = setupTransitionRegistry();
   }
+  function mergeSsrSpans() {
+    if (!import.meta.client) {
+      return;
+    }
+    const el = document.getElementById("__observatory_ssr_spans__");
+    if (!el) {
+      return;
+    }
+    let record;
+    try {
+      record = JSON.parse(el.textContent ?? "");
+    } catch {
+      return;
+    }
+    if (!record?.traceId || !Array.isArray(record.spans)) {
+      return;
+    }
+    const navDurationMs = record.spans[0]?.durationMs ?? 0;
+    const traceStartTime = performance.now() - navDurationMs;
+    traceStore.createTrace({
+      id: record.traceId,
+      name: record.name,
+      startTime: traceStartTime,
+      metadata: { origin: "ssr" }
+    });
+    for (const span of record.spans) {
+      traceStore.addSpan({
+        id: span.id,
+        traceId: record.traceId,
+        name: span.name,
+        type: span.type,
+        startTime: traceStartTime + span.startTime,
+        endTime: span.endTime !== void 0 ? traceStartTime + span.endTime : void 0,
+        status: span.status,
+        metadata: { ...span.metadata ?? {}, origin: "ssr" }
+      });
+    }
+    traceStore.endTrace(record.traceId, {
+      endTime: traceStartTime + navDurationMs,
+      status: "ok",
+      metadata: { origin: "ssr" }
+    });
+  }
   if (import.meta.client) {
     if (config.traceViewer) {
       setupComponentInstrumentation(nuxtApp);
       setupFetchInstrumentation(nuxtApp);
+      mergeSsrSpans();
     }
     delete window.__observatory__;
     window.__observatory__ = registries;

package/dist/runtime/tracing/trace.d.ts

@@ -1,4 +1,4 @@
-export type SpanType = 'render' | 'transition' | 'fetch' | 'composable' | 'navigation' | 'custom' | (string & {});
+export type SpanType = 'render' | 'component' | 'transition' | 'fetch' | 'composable' | 'navigation' | 'custom' | (string & {});
 export type SpanStatus = 'active' | 'ok' | 'error' | 'cancelled';
 export interface Span {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nuxt-devtools-observatory",
-    "version": "0.1.31",
+    "version": "0.1.32",
     "description": "Nuxt DevTools: useFetch Dashboard, provide/inject Graph, Composable Tracker, Render Heatmap",
     "license": "MIT",
     "repository": {
@@ -27,6 +27,10 @@
         "./runtime/fetch-registry": {
             "types": "./dist/runtime/composables/fetch-registry.d.ts",
             "import": "./dist/runtime/composables/fetch-registry.js"
+        },
+        "./runtime/async-data-instrumentation": {
+            "types": "./dist/runtime/instrumentation/asyncData.d.ts",
+            "import": "./dist/runtime/instrumentation/asyncData.js"
         }
     },
     "files": [

package/client/.env

@@ -1,17 +0,0 @@
-# VITE_Observatory registry/configurable limits
-VITE_OBSERVATORY_FETCH_DASHBOARD=true
-VITE_OBSERVATORY_PROVIDE_INJECT_GRAPH=true
-VITE_OBSERVATORY_COMPOSABLE_TRACKER=true
-VITE_OBSERVATORY_RENDER_HEATMAP=true
-VITE_OBSERVATORY_TRANSITION_TRACKER=true
-VITE_OBSERVATORY_TRACE_VIEWER=true
-VITE_OBSERVATORY_MAX_FETCH_ENTRIES=200
-VITE_OBSERVATORY_MAX_PAYLOAD_BYTES=10000
-VITE_OBSERVATORY_MAX_TRANSITIONS=500
-VITE_OBSERVATORY_MAX_COMPOSABLE_HISTORY=50
-VITE_OBSERVATORY_MAX_COMPOSABLE_ENTRIES=300
-VITE_OBSERVATORY_MAX_RENDER_TIMELINE=100
-VITE_OBSERVATORY_HEATMAP_THRESHOLD_COUNT=3
-VITE_OBSERVATORY_HEATMAP_THRESHOLD_TIME=1600
-VITE_OBSERVATORY_HEATMAP_HIDE_INTERNALS=true
-VITE_OBSERVATORY_INSTRUMENT_SERVER=true