@slack/radar-mcp 1.6.0 → 1.7.0

package/dist/web/public/next/store.js

@@ -0,0 +1,714 @@
+import { STREAM_KINDS, DETAILABLE_KINDS } from "./registry.js";
+// Logcat-scale retention. At the live firehose (~400+ events/sec on the unified Live tab) a
+// small ring recycles in seconds, so a rare signal (a once-per-5s heartbeat) gets evicted
+// before you can filter for it. Android Studio / Flipper keep the whole session and filter
+// across all of it, so we match that: a big in-memory ring + filter over the entire buffer.
+// 100k events ~ a few minutes of the full firehose, or hours of any single low-rate tag. The
+// cost is heap (bounded, ~tens of MB) + a full-buffer filter pass, which is why the feed only
+// does that pass on a user action and prepends incrementally while tailing (see feed.ts). TTL
+// is the secondary bound for a quiet session. These are named constants, not inline magic, so
+// the retention rationale stays attached to the numbers.
+const CACHE_CAP = 100000;
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const DETAILABLE = new Set(DETAILABLE_KINDS); // sources with a server /detail endpoint
+const DETAIL_CACHE_CAP = 1500; // bounded full-detail cache (eager-captured + click-fetched)
+const CAPTURE_CONCURRENCY = 3; // max parallel background /detail fetches
+const CAP_SEEN_CAP = 4000; // bound on the dedup set for eager capture
+const POLL_SPEC_MS = 700;
+const POLL_HEALTH_MS = 2000;
+const POLL_PROFILE_MS = 5000;
+const GRAPH_N = 60;
+const PERSEC_N = 30;
+const SUGGEST_FIELDS = ["event_type", "event_name", "tag", "status_code", "channel", "url", "package"];
+const PACKAGE_CAP = 1000; // package values learned off the stream; bounded (was Infinity in the PoC, B4)
+// ---- pre-built dashboards: one tab each. Presets carry only generic placeholders; real
+// endpoints/channels/event-names are learned LIVE from the device stream. The one baked value
+// is com.Slack.internal.debug (the debug build's package), which is already public. ----
+export const MODES = [
+    { key: "all", label: "Live", spec: { title: "Live", summary: "Live: network, RTM, analytics clogs, and Slack-app logcat in one timeline. (Logs filtered to the Slack app; clear the package chip for all apps.)", source: "all", viz: ["rate", "sparkline", "feed", "inspector"], match: { package: "com.Slack.internal.debug" } } },
+    { key: "network", label: "Network", spec: { title: "Network", summary: "Network calls per second vs average response time, every call listed, slow ones flagged.", source: "network", viz: ["rate", "graph", "feed", "inspector"], series: [{ metric: "ratePerSec", label: "calls/s", unit: "/s" }, { metric: "avg", field: "duration_ms", label: "avg ms", unit: "ms" }], highlight: { field: "duration_ms", op: ">", value: 800, label: "slow (>800ms)" }, rateWindowSec: 10 } },
+    { key: "rtm", label: "RTM", spec: { title: "RTM", summary: "Real-time websocket events as they happen.", source: "rtm", viz: ["rate", "feed", "inspector"] } },
+    { key: "clog", label: "Clogs", spec: { title: "Clogs", summary: "Analytics clog events, click any to see its full payload.", source: "clog", viz: ["rate", "feed", "inspector"] } },
+    { key: "log", label: "Logs", spec: { title: "Device Logs", summary: "Live Slack app logcat, color-coded by level. Scroll the full session buffer, select a range, copy raw lines.", source: "log", viz: ["feed", "inspector"], match: { package: "com.Slack.internal.debug" } } },
+    { key: "db", label: "Database", spec: { title: "Device DB", summary: "Browse the on-device SQLite databases (read-only snapshot).", source: "db" } },
+];
+// A preset is identified by what it DOES, not how it is labelled. canonicalSpecKey reduces a
+// spec to its behavioral identity so a spec that is semantically a preset still matches it
+// despite cosmetic drift:
+//   - title / summary are DISPLAY COPY, dropped before comparing. (They legitimately change
+//     between releases; an old saved spec carrying last release's summary wording must still
+//     resolve to its preset, not orphan into a phantom ✎ custom tab.)
+//   - `counter` in viz is a documented no-op the dashboard never renders, dropped.
+//   - object keys are sorted so key ORDER never matters.
+// The presets stay mutually distinct under this reduction (verified by test), so dropping the
+// copy never collapses two different dashboards into one.
+function canonicalSpecKey(spec) {
+    const norm = (v) => {
+        if (Array.isArray(v))
+            return v.map(norm);
+        if (v && typeof v === "object") {
+            const out = {};
+            for (const k of Object.keys(v).sort()) {
+                out[k] = norm(v[k]);
+            }
+            return out;
+        }
+        return v;
+    };
+    const cleaned = { ...spec };
+    delete cleaned.title;
+    delete cleaned.summary;
+    if (Array.isArray(cleaned.viz))
+        cleaned.viz = cleaned.viz.filter((x) => x !== "counter");
+    return JSON.stringify(norm(cleaned));
+}
+export function specMatchesMode(spec) {
+    if (!spec || spec.blank)
+        return null;
+    const key = canonicalSpecKey(spec);
+    return MODES.find((m) => canonicalSpecKey(m.spec) === key)?.key ?? null;
+}
+class Store {
+    spec = { blank: true, viz: [] };
+    conn = { state: "waiting", msg: "connecting…" };
+    profileLabel = "detecting…";
+    profiles = [];
+    cache = [];
+    cacheKeys = new Set();
+    seen = {};
+    total = 0;
+    // The count cap, as an instance field defaulted from the const, so a test can shrink it to
+    // exercise the count-eviction branch without pushing 100k frames. The TTL bound is separate.
+    cacheCap = CACHE_CAP;
+    times = [];
+    perSec = new Array(PERSEC_N).fill(0);
+    liveMatches = 0;
+    graph = null;
+    feedVersion = 0;
+    customActive = false;
+    lastCustomSpec = null;
+    detailCache = new Map();
+    _capSeen = new Set();
+    _capQueue = [];
+    _capInflight = 0;
+    _subs = {};
+    _es = null;
+    _tick = null;
+    _lastEventTs = 0;
+    _healthMisses = 0;
+    _specKey = "";
+    _localPushKey = null;
+    _lastBoundLabel = null;
+    _backfillToken = 0;
+    _rafPending = false;
+    _intervals = [];
+    // ---- shared detail cache (bounded FIFO) ----
+    cacheDetail(kind, id, detail) {
+        const key = kind + ":" + id;
+        this.detailCache.set(key, detail);
+        while (this.detailCache.size > DETAIL_CACHE_CAP) {
+            this.detailCache.delete(this.detailCache.keys().next().value);
+        }
+    }
+    getDetail(kind, id) {
+        return this.detailCache.get(kind + ":" + id);
+    }
+    // ---- eager body capture (any DETAILABLE tab, while it is open) ----
+    // The device keeps only the last ~200 network calls, so a row clicked later is gone. While a
+    // detailable tab is active we proactively fetch each NEW frame's full body in the background
+    // (concurrency-bounded) and cache it, so clicking an old row never hits eviction. Off on
+    // every other tab (mirrors Flipper's shouldStripResponseBody). Forward-only: no backfill.
+    //
+    // detailCache holds full bodies unredacted (bounded to DETAIL_CACHE_CAP), same as the
+    // inspector copy paths: a dev-only tool against a local debug build, where the inspector
+    // showing the real body is the point. Nothing to gain from scrubbing on localhost.
+    maybeCapture(ev) {
+        const src = this.spec.source;
+        const kind = ev._type || "";
+        if (ev.id == null || !DETAILABLE.has(kind))
+            return;
+        if (src !== "all" && src !== kind)
+            return;
+        const key = kind + ":" + ev.id;
+        if (this._capSeen.has(key) || this.detailCache.has(key))
+            return;
+        this._capSeen.add(key);
+        if (this._capSeen.size > CAP_SEEN_CAP)
+            this._capSeen.delete(this._capSeen.values().next().value);
+        this._capQueue.push({ kind, id: ev.id });
+        this._drainCapture();
+    }
+    _drainCapture() {
+        while (this._capInflight < CAPTURE_CONCURRENCY && this._capQueue.length) {
+            const { kind, id } = this._capQueue.shift();
+            this._capInflight++;
+            fetch("/detail?kind=" + kind + "&id=" + id)
+                .then((r) => r.json())
+                .then((d) => {
+                // skip the eviction error / empty; only cache a real payload
+                if (d && !(d.error && d.url == null && d.method == null)) {
+                    this.cacheDetail(kind, id, { ...d, _type: kind });
+                }
+            })
+                .catch(() => { })
+                .finally(() => {
+                this._capInflight--;
+                if (this._capQueue.length)
+                    this._drainCapture();
+            });
+        }
+    }
+    // ---- pub/sub (payload-aware; satisfies the Emitter contract) ----
+    on(evt, fn) {
+        const set = (this._subs[evt] || (this._subs[evt] = new Set()));
+        set.add(fn);
+        return () => set.delete(fn);
+    }
+    emit(evt, payload) {
+        const s = this._subs[evt];
+        if (s)
+            for (const fn of [...s])
+                fn(payload);
+    }
+    // Test-only: how many live subscribers an event has. Lets a test assert a component
+    // unsubscribed on unmount (the per-tab-switch listener-leak class).
+    subscriberCount(evt) {
+        return this._subs[evt]?.size ?? 0;
+    }
+    // Test-only: reset all mutable state to construction defaults. Centralized so the reset list
+    // cannot drift from the fields (a hand-maintained reset in the test omitted half of them).
+    _resetForTest() {
+        this.spec = { blank: true, viz: [] };
+        this.conn = { state: "waiting", msg: "connecting…" };
+        this.profileLabel = "detecting…";
+        this.profiles = [];
+        this.cache = [];
+        this.cacheKeys = new Set();
+        this.seen = {};
+        this.total = 0;
+        this.cacheCap = CACHE_CAP;
+        this.times = [];
+        this.perSec = new Array(PERSEC_N).fill(0);
+        this.liveMatches = 0;
+        this.graph = null;
+        this.feedVersion = 0;
+        this.customActive = false;
+        this.lastCustomSpec = null;
+        this.detailCache = new Map();
+        this._capSeen = new Set();
+        this._capQueue = [];
+        this._capInflight = 0;
+        this._lastEventTs = 0;
+        this._healthMisses = 0;
+        this._specKey = "";
+        this._localPushKey = null;
+        this._lastBoundLabel = null;
+        this._backfillToken = 0;
+        this._rafPending = false;
+    }
+    // ---- start everything ----
+    start() {
+        this.bootDefault();
+        this.pollSpec();
+        this._intervals.push(setInterval(() => this.pollSpec(), POLL_SPEC_MS));
+        this.pollHealth();
+        this._intervals.push(setInterval(() => this.pollHealth(), POLL_HEALTH_MS));
+        this.pollProfile();
+        this._intervals.push(setInterval(() => this.pollProfile(), POLL_PROFILE_MS));
+        this._intervals.push(setInterval(() => this.evictCache(), 30000));
+    }
+    // Stop all timers + the stream. Not used by the live page (the store is a singleton for the
+    // life of the tab), but lets a test tear the engine down so it does not leak timers.
+    stop() {
+        this._intervals.forEach((i) => clearInterval(i));
+        this._intervals = [];
+        if (this._tick) {
+            clearInterval(this._tick);
+            this._tick = null;
+        }
+        this.closeStream();
+    }
+    setConn(state, msg) {
+        if (this.conn.state === state && this.conn.msg === (msg || ""))
+            return;
+        this.conn = { state, msg: msg || "" };
+        this.emit("conn", this.conn);
+    }
+    async pollSpec() {
+        try {
+            const spec = await (await fetch("/spec")).json();
+            const key = JSON.stringify(spec);
+            if (key === this._specKey)
+                return;
+            this._specKey = key;
+            const isLocalEdit = key === this._localPushKey;
+            if (isLocalEdit)
+                this._localPushKey = null;
+            this.customActive = !isLocalEdit && !!spec && !spec.blank && specMatchesMode(spec) === null;
+            if (this.customActive && (!this.lastCustomSpec || JSON.stringify(this.lastCustomSpec) !== key)) {
+                this.lastCustomSpec = spec;
+            }
+            this.applySpec(spec);
+        }
+        catch {
+            /* transient; next poll retries */
+        }
+    }
+    async bootDefault() {
+        try {
+            const cur = await (await fetch("/spec")).json();
+            if (!cur || cur.blank) {
+                await fetch("/setspec", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(MODES[0].spec) }).catch(() => { });
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    markLocalPush(spec) {
+        this._localPushKey = JSON.stringify(spec);
+    }
+    async setSpec(spec, opts = {}) {
+        if (opts.local)
+            this.markLocalPush(spec);
+        try {
+            return await (await fetch("/setspec", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(spec) })).json();
+        }
+        catch {
+            return { ok: false, error: "request failed" };
+        }
+    }
+    activeModeKey() {
+        return this.customActive ? "__custom__" : specMatchesMode(this.spec);
+    }
+    // Rebuild all derived state for a new spec, reconnect the stream (so the server
+    // attaches/detaches the host-side logcat session for log/all sources), replay the cache, and
+    // backfill the device ring. Mirrors vanilla build(spec).
+    applySpec(spec) {
+        this.spec = spec || { blank: true, viz: [] };
+        this.total = 0;
+        this.liveMatches = 0;
+        this.times = [];
+        this.perSec = new Array(PERSEC_N).fill(0);
+        this.graph = null;
+        this._capQueue.length = 0;
+        if (!this.spec.blank && this.spec.source !== "db" && Array.isArray(this.spec.viz) && this.spec.viz.includes("graph") && Array.isArray(this.spec.series)) {
+            this.graph = { N: GRAPH_N, series: this.spec.series.map((s) => ({ def: s, buckets: new Array(GRAPH_N).fill(0), counts: new Array(GRAPH_N).fill(0) })) };
+        }
+        this.emit("spec", this.spec);
+        // DB browser + blank: fully quiet the streaming engine so it does not compete with the DB
+        // pull. Close the SSE stream AND stop the per-second tick. The 100k cache is left intact.
+        if (this.spec.blank || this.spec.source === "db") {
+            this.closeStream();
+            if (this._tick) {
+                clearInterval(this._tick);
+                this._tick = null;
+            }
+            return;
+        }
+        this.openStream();
+        if (!this._tick)
+            this._tick = setInterval(() => this.tick(), 1000);
+        this.replayCache();
+        this.backfill();
+    }
+    // ---- stream ----
+    openStream() {
+        this.closeStream();
+        const es = new EventSource("/stream");
+        es.onmessage = (m) => this.onFrame(m);
+        es.onerror = () => this.setConn("waiting", "reconnecting…");
+        this._es = es;
+    }
+    closeStream() {
+        if (this._es) {
+            this._es.close();
+            this._es = null;
+        }
+    }
+    onFrame(m, live = true) {
+        let f;
+        try {
+            f = JSON.parse(m.data);
+        }
+        catch {
+            return;
+        }
+        if (f.type === "_status") {
+            const e = f.event;
+            this.setConn(e.state, e.msg);
+            return;
+        }
+        if (f.type === "_error") {
+            const e = f.event;
+            this.setConn("waiting", e.msg);
+            return;
+        }
+        if (f.replay)
+            live = false; // server-replayed history: never alerts/counts twice
+        if (!STREAM_KINDS.includes(f.type))
+            return;
+        this._lastEventTs = Date.now();
+        this.setConn("connected", "");
+        const ev = f.event || {};
+        ev._type = f.type;
+        const isNew = this.cacheFrame(f.type, ev);
+        if (this.spec.source !== "all" && f.type !== this.spec.source)
+            return;
+        if (!isNew)
+            return;
+        // eager body capture: live, new, for-this-tab frames of a detailable kind. BEFORE the match
+        // filter so even filtered-out rows have their body cached for when the filter clears.
+        if (live)
+            this.maybeCapture(ev);
+        if (!this.matches(ev))
+            return;
+        this.accept(ev, live);
+    }
+    // ---- CACHE ring (dedup + bounded by count and age) ----
+    frameKey(type, ev) {
+        return type + ":" + (ev.id != null ? ev.id : (ev.log_ts || "") + "|" + (ev.pid || "") + "|" + (ev.message || ev.event_type || ev.event_name || ""));
+    }
+    cacheFrame(type, ev) {
+        const k = this.frameKey(type, ev);
+        if (this.cacheKeys.has(k))
+            return false;
+        this.cacheKeys.add(k);
+        this.cache.push({ type, ev, ts: ev.timestamp || Date.now() });
+        this.observe(ev);
+        this.evictCache();
+        return true;
+    }
+    evictCache() {
+        const cutoff = Date.now() - CACHE_TTL_MS;
+        const drop = () => {
+            const old = this.cache.shift();
+            if (old)
+                this.cacheKeys.delete(this.frameKey(old.type, old.ev));
+        };
+        while (this.cache.length && this.cache[0].ts < cutoff)
+            drop();
+        while (this.cache.length > this.cacheCap)
+            drop();
+    }
+    observe(ev) {
+        for (const f of SUGGEST_FIELDS) {
+            let v = ev[f];
+            if (v == null || v === "")
+                continue;
+            if (f === "url") {
+                try {
+                    v = new URL(String(v)).pathname.replace("/api/", "");
+                }
+                catch {
+                    /* keep raw */
+                }
+            }
+            const sv = String(v);
+            if (sv.length > 80)
+                continue;
+            (this.seen[f] || (this.seen[f] = new Set())).add(sv);
+            const cap = f === "package" ? PACKAGE_CAP : 500;
+            while (this.seen[f].size > cap) {
+                this.seen[f].delete(this.seen[f].values().next().value);
+            }
+        }
+    }
+    candidates(field) {
+        const fixed = { direction: ["OUTGOING", "INCOMING"], level: ["VERBOSE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"], method: ["GET", "POST", "PUT", "DELETE", "PATCH"] };
+        if (fixed[field])
+            return fixed[field].slice();
+        const seen = this.seen[field];
+        return seen ? [...seen].sort() : [];
+    }
+    // Replay recent cache into the fresh spec's WIDGETS (rate / sparkline / graph), live=false.
+    // The widgets only span the last ~60s, so we only feed accept() the recent tail (replaying
+    // all 100k rows was the tab-switch freeze). Walk newest->oldest, STOP once past the window.
+    // 90s covers every widget window (rate 10s, sparkline 30s, graph 60s) with margin.
+    replayCache() {
+        const src = this.spec.source;
+        const WINDOW_MS = 90 * 1000;
+        const cutoff = Date.now() - WINDOW_MS;
+        const recent = [];
+        for (let i = this.cache.length - 1; i >= 0; i--) {
+            const c = this.cache[i];
+            if (c.ts < cutoff)
+                break;
+            if (src !== "all" && c.type !== src)
+                continue;
+            recent.push(c);
+        }
+        recent.reverse();
+        for (const c of recent) {
+            const ev = c.ev;
+            ev._type = c.type;
+            if (this.matches(ev))
+                this.accept(ev, false);
+        }
+    }
+    async backfill() {
+        const myToken = ++this._backfillToken;
+        const src = this.spec.source;
+        if (!src)
+            return;
+        if (src === "log")
+            return; // host-side capture: nothing device-buffered to replay
+        try {
+            const r = await (await fetch("/backfill?source=" + encodeURIComponent(src) + "&limit=200")).json();
+            if (myToken !== this._backfillToken)
+                return;
+            for (const f of r?.frames || [])
+                this.onFrame({ data: JSON.stringify(f) }, false);
+        }
+        catch {
+            /* device unreachable; live stream still self-heals */
+        }
+    }
+    // ---- accept a matched event into the live aggregates ----
+    accept(ev, live = true) {
+        const now = Date.now();
+        const ets = ev.timestamp || now;
+        const ageSec = Math.max(0, Math.floor((now - ets) / 1000));
+        this.total++;
+        this.times.push(ets);
+        const si = this.perSec.length - 1 - ageSec;
+        if (si >= 0 && si < this.perSec.length)
+            this.perSec[si]++;
+        if (this.graph) {
+            const gi = this.graph.N - 1 - ageSec;
+            if (gi >= 0 && gi < this.graph.N) {
+                for (const s of this.graph.series) {
+                    const d = s.def;
+                    if (d.metric === "ratePerSec" || d.metric === "count")
+                        s.buckets[gi]++;
+                    else if (d.metric === "avg") {
+                        const v = Number(ev[d.field]);
+                        if (!isNaN(v)) {
+                            s.buckets[gi] += v;
+                            s.counts[gi]++;
+                        }
+                    }
+                    else if (d.metric === "errorRate") {
+                        s.counts[gi]++;
+                        if (Number(ev.status_code) >= 400)
+                            s.buckets[gi]++;
+                    }
+                }
+            }
+        }
+        if (live) {
+            this.liveMatches++;
+            if (this.spec.alert) {
+                const at = Number(this.spec.alert.at) || 0;
+                if (at > 0) {
+                    if (this.liveMatches === at)
+                        this.emit("alert", { spec: this.spec.alert, ev, note: "reached " + at });
+                }
+                else {
+                    this.emit("alert", { spec: this.spec.alert, ev });
+                }
+            }
+        }
+        this.bumpFeed();
+    }
+    // rAF-batched feed bump: coalesce N store mutations/sec into one "feed" emit per frame.
+    bumpFeed() {
+        if (this._rafPending)
+            return;
+        this._rafPending = true;
+        requestAnimationFrame(() => {
+            this._rafPending = false;
+            this.feedVersion++;
+            this.emit("feed", this.feedVersion);
+        });
+    }
+    // Per-second tick: slide the rate window, shift the sparkline + graph buckets.
+    tick() {
+        const now = Date.now();
+        const w = (this.spec.rateWindowSec || 10) * 1000;
+        while (this.times.length && this.times[0] < now - w)
+            this.times.shift();
+        this.perSec.push(0);
+        if (this.perSec.length > PERSEC_N)
+            this.perSec.shift();
+        if (this.graph) {
+            for (const s of this.graph.series) {
+                s.buckets.push(0);
+                s.buckets.shift();
+                s.counts.push(0);
+                s.counts.shift();
+            }
+        }
+        this.emit("tick", now);
+    }
+    get rate() {
+        const now = Date.now();
+        const w = (this.spec.rateWindowSec || 10) * 1000;
+        return this.times.filter((t) => t >= now - w).length;
+    }
+    // Events the current tab's feed should show, chronological (oldest->newest). The feed owns
+    // inversion/sort; chronological keeps a locked scroll stable (appends never shift an index).
+    viewFrames() {
+        const src = this.spec.source;
+        const out = [];
+        for (const c of this.cache) {
+            if (src !== "all" && c.type !== src)
+                continue;
+            const ev = c.ev;
+            ev._type = c.type;
+            if (!this.matches(ev))
+                continue;
+            out.push(ev);
+        }
+        return out;
+    }
+    // The honest "matched" count: events CURRENTLY retained in the ring (= what the feed holds),
+    // not the cumulative-since-open total (which grows past what the buffer holds — misleading).
+    get matchedRetained() {
+        return this.viewFrames().length;
+    }
+    matches(ev) {
+        const m = this.spec.match;
+        if (!m)
+            return true;
+        return Object.entries(m).every(([k, v]) => {
+            // package only exists on log rows; in the "all" timeline a package filter must not drop
+            // network/rtm/clog (they have no package, already come from the app).
+            if (k === "package" && ev._type && ev._type !== "log")
+                return true;
+            return String(ev[k] ?? "").toLowerCase().includes(String(v).toLowerCase());
+        });
+    }
+    breaches(ev) {
+        const h = this.spec.highlight;
+        if (!h)
+            return false;
+        const v = Number(ev[h.field]);
+        if (isNaN(v))
+            return false;
+        const op = h.op || ">";
+        return op === ">" ? v > h.value : op === ">=" ? v >= h.value : op === "<" ? v < h.value : op === "<=" ? v <= h.value : v === h.value;
+    }
+    // ---- health + profile ----
+    async pollHealth() {
+        if (Date.now() - this._lastEventTs < 6000) {
+            this._healthMisses = 0;
+            this.setConn("connected", "");
+            return;
+        }
+        try {
+            const h = await (await fetch("/health")).json();
+            if (h.device) {
+                this._healthMisses = 0;
+                this.setConn("connected", "");
+            }
+            else if (++this._healthMisses >= 2) {
+                this.setConn("waiting", "device offline, retrying…");
+            }
+        }
+        catch {
+            if (++this._healthMisses >= 2)
+                this.setConn("waiting", "reconnecting…");
+        }
+    }
+    async pollProfile() {
+        try {
+            const [profilesR, healthR] = await Promise.all([
+                fetch("/_control/profiles").then((r) => r.json()).catch(() => null),
+                fetch("/health").then((r) => r.json()).catch(() => null),
+            ]);
+            const uid = healthR && healthR.boundUserId;
+            this.profiles = (profilesR && profilesR.profiles) || [];
+            if (uid == null) {
+                this.profileLabel = this._lastBoundLabel ? "last seen " + this._lastBoundLabel + " — reconnecting…" : "waiting for device…";
+                this.emit("profile", this.profileLabel);
+                return;
+            }
+            const match = this.profiles.find((p) => p.userId === uid);
+            const cap = (s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
+            const label = match ? match.label : healthR.boundProfile ? cap(healthR.boundProfile) + " (user " + uid + ")" : "user " + uid;
+            this._lastBoundLabel = label;
+            this.profileLabel = label;
+            this.emit("profile", this.profileLabel);
+        }
+        catch {
+            /* leave the last label */
+        }
+    }
+    async reconnect() {
+        try {
+            await fetch("/enable", { method: "POST" });
+        }
+        catch {
+            /* ignore */
+        }
+        this.pollHealth();
+        this.pollProfile();
+        this.pollSpec();
+    }
+}
+// ---- aggregate math (moved here from widgets per the plan: it belongs WITH the aggregate
+// engine, not the renderer). seriesValues turns a graph series' raw buckets into plotted
+// values; unitFor/fmtNum format them. The widgets import these. ----
+export function seriesValues(s) {
+    if (s.def.metric === "count") {
+        let run = 0;
+        return s.buckets.map((b) => (run += b));
+    }
+    if (s.def.metric === "avg")
+        return s.buckets.map((b, i) => (s.counts[i] ? b / s.counts[i] : null));
+    if (s.def.metric === "errorRate")
+        return s.buckets.map((b, i) => (s.counts[i] ? b / s.counts[i] : null));
+    return s.buckets.slice();
+}
+export function unitFor(def) {
+    if (def.unit)
+        return def.unit;
+    if (def.metric === "ratePerSec")
+        return "/s";
+    if (def.metric === "avg")
+        return def.field && /ms|duration/i.test(def.field) ? "ms" : "";
+    if (def.metric === "errorRate")
+        return "%";
+    return "";
+}
+export function fmtNum(v) {
+    if (v == null)
+        return "—";
+    const a = Math.abs(v);
+    return a >= 100 ? Math.round(v) : a >= 10 ? Math.round(v * 10) / 10 : Math.round(v * 100) / 100;
+}
+// Human-readable one-line summary of a spec's filters/constraints (for the sub-header).
+export function describeConstraints(spec) {
+    const parts = ["source " + spec.source];
+    if (spec.match && Object.keys(spec.match).length)
+        parts.push("where " + Object.entries(spec.match).map(([k, v]) => k + "=" + v).join(", "));
+    if (spec.bodyContains)
+        parts.push('body contains "' + spec.bodyContains + '"');
+    if (spec.highlight && spec.highlight.field)
+        parts.push("flag " + spec.highlight.field + " " + (spec.highlight.op || ">") + " " + spec.highlight.value + (spec.highlight.label ? " (" + spec.highlight.label + ")" : ""));
+    if (Array.isArray(spec.series) && spec.series.length)
+        parts.push("graph " + spec.series.map((s) => s.label || s.metric + (s.field ? " of " + s.field : "")).join(" vs "));
+    if (spec.extract && spec.extract.field)
+        parts.push("extract " + spec.extract.field);
+    if (spec.alert)
+        parts.push("alert" + (spec.alert.at ? " at " + spec.alert.at : "") + (spec.alert.say ? ' "' + spec.alert.say + '"' : ""));
+    if (spec.rateWindowSec)
+        parts.push("rate window " + spec.rateWindowSec + "s");
+    return parts.join("  ·  ");
+}
+export function shortUrl(u) {
+    try {
+        return new URL(String(u)).pathname.replace("/api/", "");
+    }
+    catch {
+        return u || "";
+    }
+}
+export function shortPkg(p) {
+    if (!p)
+        return "";
+    const parts = String(p).split(".");
+    return parts.length <= 2 ? p : parts.slice(-2).join(".");
+}
+export const store = new Store();