@buoy-gg/agent-core 7.0.33

package/lib/commonjs/blocks/receipts.js

@@ -0,0 +1,702 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectReceipt = projectReceipt;
+exports.shallowDiff = shallowDiff;
+var _types = require("./types");
+/**
+ * Receipts — blocks the engine builds from tool results, deterministically.
+ *
+ * The model never authors these, so they cannot hallucinate, and a weak model
+ * cannot fail to produce them. They render the SAME redacted result the model
+ * gets, so what the user sees and what the model reasons about are one thing.
+ *
+ * Every projector is small and honest about caps: it truncates and records
+ * `total` so the renderer can say "+38 more" truthfully.
+ */
+
+let seq = 0;
+const id = () => `rc${++seq}`;
+const rec = v => v && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+const arr = v => Array.isArray(v) ? v : [];
+const str = v => typeof v === "string" ? v : undefined;
+const num = v => typeof v === "number" ? v : undefined;
+function pathOf(url) {
+  try {
+    const u = new URL(url);
+    return u.pathname + (u.search.length > 1 ? "?…" : "");
+  } catch {
+    return url;
+  }
+}
+function requestSummary(r) {
+  const rid = str(r.id);
+  const url = str(r.url);
+  if (!rid || !url) return undefined;
+  return {
+    id: rid,
+    method: str(r.method) ?? "GET",
+    url,
+    status: num(r.status),
+    durationMs: num(r.durationMs),
+    // Both spellings: the snapshot projection says `overridden`, a raw event
+    // carries the `override` mark object.
+    mocked: r.overridden === true || r.override != null && typeof r.override === "object" || undefined
+  };
+}
+
+/** Shallow diff of two plain objects: top-level keys that differ. */
+function shallowDiff(before, after) {
+  const a = rec(before) ?? {};
+  const b = rec(after) ?? {};
+  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  const out = [];
+  for (const k of keys) {
+    if (typeof a[k] === "function" || typeof b[k] === "function") continue;
+    if (JSON.stringify(a[k]) !== JSON.stringify(b[k])) {
+      out.push({
+        path: k,
+        before: a[k],
+        after: b[k]
+      });
+    }
+  }
+  return out;
+}
+
+/** Group console entries by message, newest first, counting repeats. */
+function groupLogs(entries) {
+  const map = new Map();
+  for (const e of entries) {
+    const r = rec(e);
+    if (!r) continue;
+    const message = str(r.message) ?? "";
+    const level = str(r.level) ?? "log";
+    const key = `${level}:${message}`;
+    const cur = map.get(key);
+    if (cur) cur.count += 1;else map.set(key, {
+      level,
+      message,
+      count: 1
+    });
+  }
+  return [...map.values()];
+}
+
+/** A bag-line / product heuristic: an array of objects with a name and a price/qty/image. */
+function looksLikeItems(v) {
+  const items = arr(v).map(rec).filter(Boolean);
+  if (items.length < 2) return undefined;
+  const ok = items.every(i => str(i.name) && (i.image !== undefined || i.qty !== undefined || i.price !== undefined || i.unitPrice !== undefined));
+  return ok ? items : undefined;
+}
+function money(cents) {
+  const n = num(cents);
+  return n === undefined ? undefined : `$${(n / 100).toFixed(2)}`;
+}
+/**
+ * The receipt for one successful call, or nothing. Adding a projector is the
+ * whole job of making a tool's result visible — no UI change needed.
+ */
+function projectReceipt(input) {
+  const {
+    toolId,
+    action,
+    params,
+    result
+  } = input;
+  const r = rec(result);
+  const source = input.effect === "read" ? "live" : "changed";
+
+  // ---- network --------------------------------------------------------
+  if (toolId === "network" && action === "getSnapshot" && r) {
+    const requests = arr(r.requests).map(rec).filter(Boolean).map(x => requestSummary(x)).filter(Boolean);
+    if (requests.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "requestList",
+      requests: requests.slice(0, _types.CAPS.listItems * 2),
+      total: num(r.totalCaptured) ?? requests.length,
+      source
+    };
+  }
+  if (toolId === "network" && action === "getEventBody" && r) {
+    const reqId = str(params.id) ?? "";
+    const wasMocked = r.override != null && typeof r.override === "object";
+    return {
+      id: id(),
+      kind: "requestCard",
+      request: {
+        id: reqId,
+        method: str(r.method) ?? "",
+        url: str(r.url) ?? reqId,
+        status: num(r.status),
+        mocked: wasMocked || undefined
+      },
+      requestBody: r.requestData ?? undefined,
+      responseBody: r.responseData ?? undefined,
+      // A body an override rule synthesized must never render as "live".
+      source: wasMocked ? "mocked" : source
+    };
+  }
+  if (toolId === "network" && (action === "upsertOverrideRule" || action === "getOverrideRuleBody") && r) {
+    const rule = rec(r.rule) ?? r;
+    const ruleId = str(rule.id);
+    const pattern = str(rule.urlPattern);
+    if (!ruleId || !pattern) return undefined;
+    const kind = str(rule.kind) ?? "respond";
+    const asked = rec(params.rule) ?? {};
+    return {
+      id: id(),
+      kind: "ruleCard",
+      rule: {
+        id: ruleId,
+        name: str(rule.name) ?? str(asked.name),
+        urlPattern: pattern,
+        methods: arr(rule.methods ?? asked.methods).map(String),
+        kind,
+        status: num(rule.status) ?? num(asked.status),
+        delayMs: num(rule.delayMs) ?? num(asked.delayMs),
+        times: num(rule.times) ?? num(asked.times),
+        enabled: rule.enabled !== false,
+        hits: num(rule.hits)
+      },
+      source: action === "upsertOverrideRule" ? "changed" : "live"
+    };
+  }
+  if (toolId === "network" && action === "listOverrideRules" && r) {
+    const rules = arr(r.rules).map(rec).filter(Boolean);
+    if (rules.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${rules.length} network override${rules.length === 1 ? "" : "s"}`,
+      items: rules.slice(0, _types.CAPS.listItems).map(x => ({
+        id: str(x.id),
+        title: str(x.name) ?? str(x.urlPattern) ?? "rule",
+        subtitle: `${arr(x.methods).join("/") || "ANY"} ${str(x.urlPattern) ?? ""} → ${str(x.kind) ?? ""}${x.status ? ` ${String(x.status)}` : ""}`,
+        trailing: x.enabled === false ? "off" : `on · ${num(x.hits) ?? 0} hit${num(x.hits) === 1 ? "" : "s"}`,
+        tone: x.enabled === false ? "muted" : "warning"
+      })),
+      total: rules.length,
+      source: "live"
+    };
+  }
+
+  // ---- routes ---------------------------------------------------------
+  if (toolId === "route-events" && action === "getSnapshot" && r) {
+    const routes = [...new Set(arr(r.routes).map(String))];
+    if (routes.length === 0) return undefined;
+    const current = rec(r.currentRoute);
+    return {
+      id: id(),
+      kind: "routeChips",
+      routes: routes.map(p => ({
+        path: p,
+        dynamic: /\[.+\]/.test(p)
+      })),
+      current: str(current?.path),
+      total: routes.length,
+      source: "live"
+    };
+  }
+  if (toolId === "route-events" && action === "navigate" && r) {
+    const path = str(r.navigated) ?? str(params.path);
+    return path ? {
+      id: id(),
+      kind: "peek",
+      label: `Opened ${path}`,
+      path
+    } : undefined;
+  }
+  if (toolId === "route-events" && (action === "stackGoBack" || action === "stackPopToTop")) {
+    return {
+      id: id(),
+      kind: "peek",
+      label: action === "stackPopToTop" ? "Went back to the first screen" : "Went back"
+    };
+  }
+
+  // ---- screen ---------------------------------------------------------
+  if (toolId === "highlight-updates" && action === "describeScreen" && r) {
+    const els = arr(r.elements).map(rec).filter(Boolean);
+    const interactive = els.filter(e => e.interactive === true && !String(str(e.testID) ?? "").startsWith("buoy-"));
+    if (interactive.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "screenElements",
+      elements: interactive.slice(0, _types.CAPS.chips).map(e => ({
+        nativeTag: num(e.nativeTag) ?? 0,
+        name: str(e.name) ?? "",
+        label: str(e.label) ?? str(e.text),
+        testID: str(e.testID),
+        interactive: true
+      })),
+      total: interactive.length,
+      source: "live"
+    };
+  }
+  if (toolId === "highlight-updates" && action === "tapElement" && r?.tapped === true) {
+    const m = rec(r.matched);
+    const what = str(m?.label) ?? str(m?.text) ?? str(m?.testID) ?? "element";
+    return {
+      id: id(),
+      kind: "peek",
+      label: `Tapped ${what}`
+    };
+  }
+
+  // ---- console --------------------------------------------------------
+  if (toolId === "console" && action === "getSnapshot" && r) {
+    const entries = arr(r.entries);
+    if (entries.length === 0) return undefined;
+    const grouped = groupLogs(entries);
+    return {
+      id: id(),
+      kind: "logList",
+      entries: grouped.slice(0, _types.CAPS.listItems * 2),
+      total: num(r.totalCaptured) ?? entries.length,
+      source: "live"
+    };
+  }
+
+  // ---- state stores ---------------------------------------------------
+  if (toolId === "zustand" && action === "getStoreState" && r?.found !== false) {
+    const state = rec(r?.currentState);
+    if (!state) return undefined;
+    const items = looksLikeItems(state.lines ?? state.items);
+    if (items) {
+      return {
+        id: id(),
+        kind: "list",
+        title: str(params.storeName),
+        items: items.slice(0, _types.CAPS.listItems).map(i => ({
+          id: str(i.lineId) ?? str(i.id),
+          title: str(i.name) ?? "",
+          subtitle: [str(i.sizeName), i.qty !== undefined ? `×${String(i.qty)}` : undefined].filter(Boolean).join(" · "),
+          trailing: money(i.unitPrice ?? i.price),
+          image: str(i.image)
+        })),
+        total: items.length,
+        source: "live"
+      };
+    }
+    const pairs = Object.entries(state).filter(([, v]) => typeof v !== "function").slice(0, _types.CAPS.keyValuePairs).map(([key, value]) => ({
+      key,
+      value
+    }));
+    return {
+      id: id(),
+      kind: "keyValue",
+      title: str(params.storeName),
+      pairs,
+      source: "live"
+    };
+  }
+  if (toolId === "zustand" && action === "setState" && r?.ok !== false) {
+    const changes = shallowDiff(rec(input.before)?.currentState ?? input.before, params.state);
+    if (changes.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "diff",
+      title: `${str(params.storeName) ?? "store"} — what changed`,
+      changes,
+      source: "changed"
+    };
+  }
+  if (toolId === "zustand" && action === "listStores" && r) {
+    const stores = arr(r.stores).map(rec).filter(Boolean);
+    if (stores.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${stores.length} store${stores.length === 1 ? "" : "s"}`,
+      items: stores.slice(0, _types.CAPS.listItems * 2).map(s => ({
+        id: str(s.name),
+        title: str(s.name) ?? "",
+        subtitle: arr(s.keys).slice(0, 6).join(", "),
+        trailing: s.isPersisted ? "persisted" : undefined
+      })),
+      total: stores.length,
+      source: "live"
+    };
+  }
+  if (toolId === "redux" && action === "getState" && r?.available !== false) {
+    const state = rec(r?.state) ?? r;
+    if (!state) return undefined;
+    const pairs = Object.entries(state).slice(0, _types.CAPS.keyValuePairs).map(([key, value]) => ({
+      key,
+      value
+    }));
+    return {
+      id: id(),
+      kind: "keyValue",
+      title: "Redux state",
+      pairs,
+      source: "live"
+    };
+  }
+
+  // ---- storage --------------------------------------------------------
+  if (toolId === "storage" && (action === "async.getItem" || action === "mmkv.get" || action === "secure.get")) {
+    const key = str(params.key) ?? "";
+    let value = r && "value" in r ? r.value : result;
+    if (r?.found === false || value === null || value === undefined) return undefined;
+    if (typeof value === "string") {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        /* plain string */
+      }
+    }
+    const obj = rec(value);
+    const items = looksLikeItems(rec(obj?.state)?.lines ?? obj?.lines ?? obj?.items);
+    if (items) {
+      return {
+        id: id(),
+        kind: "list",
+        title: key,
+        items: items.slice(0, _types.CAPS.listItems).map(i => ({
+          id: str(i.lineId) ?? str(i.id),
+          title: str(i.name) ?? "",
+          subtitle: [str(i.sizeName), i.qty !== undefined ? `×${String(i.qty)}` : undefined].filter(Boolean).join(" · "),
+          trailing: money(i.unitPrice ?? i.price),
+          image: str(i.image)
+        })),
+        total: items.length,
+        source: "live"
+      };
+    }
+    if (obj) {
+      const pairs = Object.entries(obj).slice(0, _types.CAPS.keyValuePairs).map(([k, v]) => ({
+        key: k,
+        value: v
+      }));
+      return {
+        id: id(),
+        kind: "keyValue",
+        title: key,
+        pairs,
+        source: "live"
+      };
+    }
+    return {
+      id: id(),
+      kind: "keyValue",
+      title: key,
+      pairs: [{
+        key: "value",
+        value
+      }],
+      source: "live"
+    };
+  }
+  if (toolId === "storage" && action === "async.getAllKeys") {
+    const keys = arr(result).map(String);
+    if (keys.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${keys.length} stored key${keys.length === 1 ? "" : "s"}`,
+      items: keys.slice(0, _types.CAPS.listItems * 2).map(k => ({
+        id: k,
+        title: k,
+        action: {
+          label: "Read",
+          dispatch: {
+            toolId: "storage",
+            action: "async.getItem",
+            params: {
+              key: k
+            }
+          }
+        }
+      })),
+      total: keys.length,
+      source: "live"
+    };
+  }
+  if (toolId === "storage" && (action === "async.setItem" || action === "mmkv.set" || action === "secure.set")) {
+    const key = str(params.key) ?? "";
+    const b = rec(input.before);
+    const beforeVal = b?.had ? b.value : undefined;
+    return {
+      id: id(),
+      kind: "diff",
+      title: `${key} — saved`,
+      changes: [{
+        path: key,
+        before: beforeVal,
+        after: params.value
+      }],
+      source: "changed"
+    };
+  }
+
+  // ---- env ------------------------------------------------------------
+  if (toolId === "env" && action === "getSnapshot" && r) {
+    const env = rec(r.env);
+    if (!env || Object.keys(env).length === 0) return undefined;
+    const pairs = Object.entries(env).slice(0, _types.CAPS.keyValuePairs).map(([key, value]) => ({
+      key,
+      value
+    }));
+    return {
+      id: id(),
+      kind: "keyValue",
+      title: `Environment — ${Object.keys(env).length} var${Object.keys(env).length === 1 ? "" : "s"}`,
+      pairs,
+      source: "live"
+    };
+  }
+
+  // ---- sentry ---------------------------------------------------------
+  if (toolId === "sentry" && action === "getSnapshot" && r) {
+    const envelopes = arr(r.envelopes).map(rec).filter(Boolean);
+    const status = str(r.status);
+    if (envelopes.length === 0) {
+      // The status IS the answer when nothing was captured: "no client" and
+      // "nothing errored" are different findings and must not look alike.
+      if (status === "sdk-not-found" || status === "no-client") {
+        return {
+          id: id(),
+          kind: "notice",
+          tone: "warning",
+          text: "This app has no live Sentry client, so nothing can ever be captured here — that's different from \"nothing was sent\"."
+        };
+      }
+      return undefined;
+    }
+    return {
+      id: id(),
+      kind: "list",
+      title: `${num(r.totalCaptured) ?? envelopes.length} envelope${(num(r.totalCaptured) ?? envelopes.length) === 1 ? "" : "s"} sent to Sentry`,
+      items: envelopes.slice(0, _types.CAPS.listItems * 2).map(e => {
+        const items = arr(e.items).map(rec).filter(Boolean);
+        const first = items[0];
+        const isError = items.some(i => i.type === "event");
+        return {
+          id: e.id !== undefined ? String(e.id) : undefined,
+          title: str(first?.summary) ?? str(first?.type) ?? "envelope",
+          subtitle: items.map(i => str(i.type)).filter(Boolean).join(" · "),
+          trailing: str(e.origin),
+          tone: isError ? "danger" : undefined
+        };
+      }),
+      total: num(r.totalCaptured) ?? envelopes.length,
+      source: "live"
+    };
+  }
+
+  // ---- impersonate ----------------------------------------------------
+  if (toolId === "impersonate" && action === "searchUsers") {
+    const users = arr(result).map(rec).filter(Boolean);
+    if (users.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${users.length} user${users.length === 1 ? "" : "s"} found`,
+      items: users.slice(0, _types.CAPS.listItems).map(u => ({
+        id: str(u.id),
+        title: str(u.displayName) ?? str(u.email) ?? str(u.id) ?? "user",
+        subtitle: [str(u.email), str(rec(u.metadata)?.role)].filter(Boolean).join(" · "),
+        image: str(u.avatarUrl),
+        // The tap goes through runGatedAction, so it carries the same policy,
+        // approval and ledger path a model call would.
+        action: {
+          label: "Impersonate",
+          dispatch: {
+            toolId: "impersonate",
+            action: "startImpersonation",
+            params: {
+              user: u
+            }
+          }
+        }
+      })),
+      total: users.length,
+      source: "live"
+    };
+  }
+  if (toolId === "impersonate" && action === "startImpersonation" && r?.ok !== false) {
+    const u = rec(params.user);
+    const who = str(u?.displayName) ?? str(u?.email) ?? str(u?.id) ?? "that user";
+    return {
+      id: id(),
+      kind: "notice",
+      tone: "warning",
+      text: `Now viewing the app as ${who}. Cached data was cleared so everything refetches as them — stopping clears caches again.`
+    };
+  }
+  if (toolId === "impersonate" && action === "stopImpersonation") {
+    return {
+      id: id(),
+      kind: "notice",
+      tone: "info",
+      text: "Stopped impersonating — back to the real account. Cached app data was cleared again."
+    };
+  }
+
+  // ---- scenarios ------------------------------------------------------
+  if (toolId === "scenarios" && action === "listScenarios" && r) {
+    const all = [...arr(r.code), ...arr(r.device), ...arr(r.drafts)].map(rec).filter(Boolean);
+    if (all.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${all.length} scenario${all.length === 1 ? "" : "s"}`,
+      items: all.slice(0, _types.CAPS.listItems * 2).map(s => ({
+        id: str(s.id),
+        title: str(s.name) ?? str(s.id) ?? "scenario",
+        subtitle: str(s.description),
+        trailing: str(s.source) === "draft" ? "draft — needs accepting" : num(s.stepCount) !== undefined ? `${String(num(s.stepCount))} step${num(s.stepCount) === 1 ? "" : "s"}` : undefined,
+        tone: str(s.source) === "draft" ? "muted" : undefined
+      })),
+      total: all.length,
+      source: "live"
+    };
+  }
+  if (toolId === "scenarios" && action === "run" && r) {
+    if (r.ok === false) {
+      const errs = arr(r.preflightErrors).map(String).join("; ");
+      return {
+        id: id(),
+        kind: "notice",
+        tone: "warning",
+        text: `The scenario did not run — pre-flight failed${errs ? `: ${errs}` : ""}. Nothing was applied.`
+      };
+    }
+    const steps = arr(r.steps).map(rec).filter(Boolean);
+    if (steps.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "steps",
+      title: `Ran ${str(r.name) ?? "the scenario"}`,
+      steps: steps.slice(0, _types.CAPS.listItems * 2).map(s => ({
+        text: str(s.label) ?? "step",
+        state: s.skipped === true ? "todo" : s.ok === false ? "failed" : "done"
+      }))
+    };
+  }
+
+  // ---- time machine ---------------------------------------------------
+  if (toolId === "time-machine" && action === "list" && r) {
+    const snaps = arr(r.snapshots).map(rec).filter(Boolean);
+    if (snaps.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${snaps.length} restore point${snaps.length === 1 ? "" : "s"}`,
+      items: snaps.slice(0, _types.CAPS.listItems * 2).map(s => ({
+        id: str(s.id),
+        title: str(s.name) ?? str(s.id) ?? "snapshot",
+        subtitle: str(rec(s.route)?.pathname),
+        trailing: s.baseline === true ? "baseline" : undefined
+      })),
+      total: snaps.length,
+      source: "live"
+    };
+  }
+  if (toolId === "time-machine" && action === "capture" && r) {
+    return {
+      id: id(),
+      kind: "notice",
+      tone: "info",
+      text: `Saved a restore point${typeof params.name === "string" ? ` — "${params.name}"` : ""}. The app can be brought back to this exact state any time.`
+    };
+  }
+  if (toolId === "time-machine" && action === "restore" && r) {
+    return {
+      id: id(),
+      kind: "notice",
+      tone: "warning",
+      text: "Restored the snapshot — the app's state just jumped back. What's on screen now reflects the restore point, not what happened since."
+    };
+  }
+
+  // ---- jotai ----------------------------------------------------------
+  if (toolId === "jotai" && action === "listAtoms" && r) {
+    const atoms = arr(r.atoms).map(rec).filter(Boolean);
+    if (atoms.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${num(r.total) ?? atoms.length} atom${(num(r.total) ?? atoms.length) === 1 ? "" : "s"}`,
+      items: atoms.slice(0, _types.CAPS.listItems * 2).map(a => ({
+        id: str(a.label),
+        title: str(a.label) ?? "atom",
+        subtitle: a.writable === true ? "writable" : "read-only (derived)",
+        trailing: num(a.changes) !== undefined ? `${String(num(a.changes))} change${num(a.changes) === 1 ? "" : "s"}` : undefined
+      })),
+      total: num(r.total) ?? atoms.length,
+      source: "live"
+    };
+  }
+
+  // ---- images ---------------------------------------------------------
+  if (toolId === "images" && action === "list" && r) {
+    const records = arr(r.records).map(rec).filter(Boolean);
+    const images = records.map(x => ({
+      url: str(x.uri) ?? "",
+      alt: str(x.uri)?.split("/").pop() ?? "image",
+      caption: x.ms !== undefined ? `${String(x.ms)} ms · ${str(x.cache) ?? ""}` : undefined
+    })).filter(i => i.url);
+    if (images.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "imageGrid",
+      title: "Images the app has loaded",
+      images: images.slice(0, _types.CAPS.gridMax),
+      total: num(r.total) ?? images.length,
+      source: "live"
+    };
+  }
+
+  // ---- react-query ----------------------------------------------------
+  if (toolId === "query" && action === "listQueries" && r) {
+    const qs = arr(r.queries).map(rec).filter(Boolean);
+    if (qs.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "list",
+      title: `${qs.length} cached quer${qs.length === 1 ? "y" : "ies"}`,
+      items: qs.slice(0, _types.CAPS.listItems * 2).map(q => {
+        const key = arr(q.queryKey).filter(k => typeof k === "string").join(" › ") || str(q.queryHash) || "query";
+        const stale = q.isStale === true;
+        return {
+          id: str(q.queryHash),
+          title: key,
+          subtitle: `${str(q.status) ?? ""}${q.fetchStatus && q.fetchStatus !== "idle" ? ` · ${String(q.fetchStatus)}` : ""}`,
+          trailing: stale ? "stale" : "fresh",
+          tone: stale ? "warning" : "accent"
+        };
+      }),
+      total: qs.length,
+      source: "live"
+    };
+  }
+
+  // ---- render measurement → chart --------------------------------------
+  if (toolId === "highlight-updates" && action === "endMeasurement" && r) {
+    const comps = arr(r.components ?? r.renders).map(rec).filter(Boolean);
+    const bars = comps.map(c => ({
+      label: str(c.name) ?? str(c.componentName) ?? "?",
+      value: num(c.renders) ?? num(c.count) ?? 0
+    })).filter(b => b.value > 0).sort((a, b) => b.value - a.value).slice(0, _types.CAPS.chartBars);
+    if (bars.length === 0) return undefined;
+    return {
+      id: id(),
+      kind: "chart",
+      title: "Renders during the measurement",
+      bars: bars.map(b => ({
+        ...b,
+        unit: "renders"
+      })),
+      source: "live"
+    };
+  }
+  return undefined;
+}
+//# sourceMappingURL=receipts.js.map