@oddsquad/vite-plugin-lit 0.2.3 → 0.3.0

package/lib/timeline/derive.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/**
+ * Derivation over recorded timeline events.
+ *
+ * The capture layers emit one event per phase boundary, which is the right
+ * wire format and the wrong thing to read: a single update tick of one
+ * component is five to ten rows whose durations the reader has to subtract by
+ * hand. Everything needed to do better is already on the events — `groupId`
+ * pairs a start with its end, `data.changed` names the reactive properties
+ * that caused the update — so this module turns a flat event list into the
+ * three shapes the panel and agents actually ask for:
+ *
+ * - {@link TimelineSpan} — a start/end pair collapsed into one entry with a
+ *   duration ("`update` took 1.8ms").
+ * - {@link UpdateCycle} — one component's whole update tick, with the changed
+ *   property keys that triggered it ("`<hmr-counter>` updated because
+ *   `count` changed").
+ * - {@link ComponentRollup} — per-component totals over a recording ("this
+ *   component updated 340 times for 120ms").
+ *
+ * Pure and dependency-free by design: it imports only the shared event types,
+ * so the panel derives client-side over its 5000-event buffer and
+ * `devframe/definition.ts` — which must stay framework-neutral — can derive
+ * server-side over the ring buffer for the agent-facing summary.
+ */
+import type { TimelineEvent } from '../../types/timeline.js';
+/**
+ * A start/end pair collapsed into one entry, or a point event that never had
+ * an end to begin with.
+ */
+export interface TimelineSpan {
+    layerId: string;
+    /**
+     * Stable across re-derivation of the same events, which a Lit `repeat()`
+     * key and a selection comparison both need — the span objects themselves
+     * are rebuilt whenever the event buffer changes.
+     */
+    key: string;
+    /** The event title with its `:start` / `:end` suffix removed. */
+    name: string;
+    /** Pairing id as emitted; `undefined` for point events. */
+    groupId?: number | string;
+    start: number;
+    /** Absent while the span is still open, or if its end was never recorded. */
+    end?: number;
+    /** `end - start`. Absent for open spans and for point events. */
+    duration?: number;
+    /** Reactive property keys that caused this update, where the phase has them. */
+    changed?: string[];
+    subtitle?: string;
+    logType?: TimelineEvent['logType'];
+    meta?: TimelineEvent['meta'];
+    /** The events this span was built from, for the detail pane. */
+    events: TimelineEvent[];
+}
+/** One component's complete update tick. */
+export interface UpdateCycle {
+    /** The `${elementId}:${tick}` groupId the phases share. */
+    key: string;
+    elementId: number;
+    tagName: string;
+    source?: {
+        file: string;
+        line: number;
+    };
+    start: number;
+    /** The `performUpdate` span's duration — see {@link toUpdateCycles}. */
+    duration?: number;
+    /** Union of the changed reactive property keys across the tick's phases. */
+    changed: string[];
+    phases: TimelineSpan[];
+    /** The input event this update followed, if any. See {@link attributeInput}. */
+    cause?: {
+        layerId: string;
+        type: string;
+        detail?: string;
+        time: number;
+    };
+}
+/** Per-component totals over a set of update cycles. */
+export interface ComponentRollup {
+    tagName: string;
+    /** Every instance of this component that updated, in first-seen order. */
+    elementIds: number[];
+    updates: number;
+    /** Summed `performUpdate` durations; excludes cycles with no measured end. */
+    totalMs: number;
+    maxMs: number;
+    /** Changed-key frequency across the cycles, most frequent first. */
+    reasons: Array<{
+        key: string;
+        count: number;
+    }>;
+    source?: {
+        file: string;
+        line: number;
+    };
+}
+/**
+ * Collapses `:start` / `:end` event pairs into spans, passing anything else
+ * through as a point span.
+ *
+ * Pairing is keyed on **layer + groupId + phase name**, never on `groupId`
+ * alone: a whole update tick shares one groupId (`runtime/timeline/
+ * lifecycle.ts` builds it as `${elementId}:${tick}`), so matching on the id
+ * would marry `willUpdate:start` to `performUpdate:end`. Each phase occurs at
+ * most once per tick, which makes the triple unique.
+ *
+ * Unmatched halves survive rather than disappear — the buffer is a bounded
+ * ring, so its oldest end and its newest start routinely have no partner, and
+ * an update that is still running has a genuinely open span.
+ */
+export declare const toSpans: (events: readonly TimelineEvent[]) => TimelineSpan[];
+/**
+ * Groups lifecycle spans into update ticks.
+ *
+ * `duration` is taken from the `performUpdate` span alone, never from a sum of
+ * the phases: `willUpdate` / `update` / `updated` all run *inside*
+ * `performUpdate`, so summing counts the same milliseconds several times over.
+ *
+ * `changed` is the union across the tick's phases because only the phases that
+ * receive a `PropertyValues` argument carry it — `performUpdate` takes none,
+ * so the bracketing span is always silent about the reason.
+ */
+export declare const toUpdateCycles: (spans: readonly TimelineSpan[]) => UpdateCycle[];
+/**
+ * Totals update cycles per component tag.
+ *
+ * Grouped by tag rather than by instance because the question this answers is
+ * "which *component* re-renders too much" — a list of 200 rows each updating
+ * twice is one component's problem, not 200. The instance ids are kept so the
+ * caller can still drill in.
+ */
+export declare const rollup: (cycles: readonly UpdateCycle[]) => ComponentRollup[];
+/**
+ * Attributes each update cycle to the input event that preceded it, within
+ * `windowMs`.
+ *
+ * This is what the mouse and keyboard layers are for. On their own they
+ * duplicate what the browser's own event log already shows; joined to the
+ * updates they precede they answer the question the raw layers only imply —
+ * an update with a cause is an interaction, and an update without one is a
+ * timer, a signal, or a stray `requestUpdate()`.
+ *
+ * Returns a new array; cycles with no cause are returned as-is.
+ */
+export declare const attributeInput: (cycles: readonly UpdateCycle[], events: readonly TimelineEvent[], windowMs?: number) => UpdateCycle[];
+//# sourceMappingURL=derive.d.ts.map

package/lib/timeline/derive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../src/lib/timeline/derive.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AAc3D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IACnC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7B,gEAAgE;IAChE,MAAM,EAAE,aAAa,EAAE,CAAC;CACzB;AAED,4CAA4C;AAC5C,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,gFAAgF;IAChF,KAAK,CAAC,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;CACxE;AAED,wDAAwD;AACxD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAC7C,MAAM,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;CACvC;AAwBD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,WAAY,SAAS,aAAa,EAAE,KAAG,YAAY,EA0DtE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,UAClB,SAAS,YAAY,EAAE,KAC7B,WAAW,EAuCb,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,WAAY,SAAS,WAAW,EAAE,KAAG,eAAe,EAoDtE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,WACjB,SAAS,WAAW,EAAE,UACtB,SAAS,aAAa,EAAE,wBAE/B,WAAW,EA4Bb,CAAC"}

package/lib/timeline/derive.js

@@ -0,0 +1,242 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+/** Layer whose events describe Lit update ticks. */
+const LIFECYCLE_LAYER_ID = 'lit-lifecycle';
+/** Layers whose events are developer input, for {@link attributeInput}. */
+const INPUT_LAYER_IDS = ['mouse', 'keyboard'];
+/** The phase that brackets an entire update tick. */
+const ROOT_PHASE = 'performUpdate';
+const START_SUFFIX = ':start';
+const END_SUFFIX = ':end';
+/** Reads `data.changed` defensively — `data` is `unknown` on the wire. */
+const changedOf = (event) => {
+  const data = event.data;
+  if (data === null || typeof data !== 'object') return undefined;
+  const changed = data.changed;
+  if (!Array.isArray(changed)) return undefined;
+  const keys = changed.filter((key) => typeof key === 'string');
+  return keys.length > 0 ? keys : undefined;
+};
+const pointSpan = (event, index) => ({
+  layerId: event.layerId,
+  key: `${event.layerId}:point:${index}`,
+  name: event.title ?? event.layerId,
+  start: event.time,
+  changed: changedOf(event),
+  subtitle: event.subtitle,
+  logType: event.logType,
+  meta: event.meta,
+  events: [event],
+});
+/**
+ * Collapses `:start` / `:end` event pairs into spans, passing anything else
+ * through as a point span.
+ *
+ * Pairing is keyed on **layer + groupId + phase name**, never on `groupId`
+ * alone: a whole update tick shares one groupId (`runtime/timeline/
+ * lifecycle.ts` builds it as `${elementId}:${tick}`), so matching on the id
+ * would marry `willUpdate:start` to `performUpdate:end`. Each phase occurs at
+ * most once per tick, which makes the triple unique.
+ *
+ * Unmatched halves survive rather than disappear — the buffer is a bounded
+ * ring, so its oldest end and its newest start routinely have no partner, and
+ * an update that is still running has a genuinely open span.
+ */
+export const toSpans = (events) => {
+  const spans = [];
+  const open = new Map();
+  events.forEach((event, index) => {
+    const title = event.title ?? event.layerId;
+    const isStart = title.endsWith(START_SUFFIX);
+    const isEnd = !isStart && title.endsWith(END_SUFFIX);
+    if (event.groupId === undefined || (!isStart && !isEnd)) {
+      spans.push(pointSpan(event, index));
+      return;
+    }
+    const name = title.slice(
+      0,
+      -(isStart ? START_SUFFIX.length : END_SUFFIX.length)
+    );
+    const key = `${event.layerId}:${event.groupId}:${name}`;
+    if (isStart) {
+      const span = {
+        layerId: event.layerId,
+        key,
+        name,
+        groupId: event.groupId,
+        start: event.time,
+        changed: changedOf(event),
+        subtitle: event.subtitle,
+        logType: event.logType,
+        meta: event.meta,
+        events: [event],
+      };
+      open.set(key, span);
+      // Pushed on its start, so the list is already in start order and an
+      // open span keeps its place instead of appearing when it finally ends.
+      spans.push(span);
+      return;
+    }
+    const span = open.get(key);
+    if (span === undefined) {
+      spans.push(pointSpan(event, index));
+      return;
+    }
+    open.delete(key);
+    span.events.push(event);
+    // A negative delta means the buffer straddles a clock reset (the runtime
+    // re-zeroes on the rising edge of recording). Report no duration rather
+    // than a negative one; the span stays open, which is what it honestly is.
+    if (event.time >= span.start) {
+      span.end = event.time;
+      span.duration = event.time - span.start;
+    }
+    span.changed ??= changedOf(event);
+  });
+  return spans.sort((a, b) => a.start - b.start);
+};
+/**
+ * Groups lifecycle spans into update ticks.
+ *
+ * `duration` is taken from the `performUpdate` span alone, never from a sum of
+ * the phases: `willUpdate` / `update` / `updated` all run *inside*
+ * `performUpdate`, so summing counts the same milliseconds several times over.
+ *
+ * `changed` is the union across the tick's phases because only the phases that
+ * receive a `PropertyValues` argument carry it — `performUpdate` takes none,
+ * so the bracketing span is always silent about the reason.
+ */
+export const toUpdateCycles = (spans) => {
+  const byGroup = new Map();
+  for (const span of spans) {
+    const elementId = span.meta?.elementId;
+    if (
+      span.layerId !== LIFECYCLE_LAYER_ID ||
+      span.groupId === undefined ||
+      elementId === undefined
+    ) {
+      // Point lifecycle events (connect/disconnect) have no groupId and are
+      // not update ticks; other layers are not this function's business.
+      continue;
+    }
+    const key = String(span.groupId);
+    let cycle = byGroup.get(key);
+    if (cycle === undefined) {
+      cycle = {
+        key,
+        elementId,
+        tagName: span.meta?.tagName ?? 'unknown',
+        source: span.meta?.source,
+        start: span.start,
+        changed: [],
+        phases: [],
+      };
+      byGroup.set(key, cycle);
+    }
+    cycle.phases.push(span);
+    if (span.start < cycle.start) cycle.start = span.start;
+    if (span.name === ROOT_PHASE) cycle.duration = span.duration;
+    for (const changedKey of span.changed ?? []) {
+      if (!cycle.changed.includes(changedKey)) cycle.changed.push(changedKey);
+    }
+  }
+  return [...byGroup.values()].sort((a, b) => a.start - b.start);
+};
+/**
+ * Totals update cycles per component tag.
+ *
+ * Grouped by tag rather than by instance because the question this answers is
+ * "which *component* re-renders too much" — a list of 200 rows each updating
+ * twice is one component's problem, not 200. The instance ids are kept so the
+ * caller can still drill in.
+ */
+export const rollup = (cycles) => {
+  const byTag = new Map();
+  for (const cycle of cycles) {
+    let record = byTag.get(cycle.tagName);
+    if (record === undefined) {
+      record = {
+        entry: {
+          tagName: cycle.tagName,
+          elementIds: [],
+          updates: 0,
+          totalMs: 0,
+          maxMs: 0,
+          reasons: [],
+          source: cycle.source,
+        },
+        reasons: new Map(),
+      };
+      byTag.set(cycle.tagName, record);
+    }
+    const {entry, reasons} = record;
+    entry.updates++;
+    if (!entry.elementIds.includes(cycle.elementId)) {
+      entry.elementIds.push(cycle.elementId);
+    }
+    entry.source ??= cycle.source;
+    // An open or clock-straddling cycle contributes a count but no time —
+    // better than inventing one, and the count is what flags a hot component.
+    if (cycle.duration !== undefined) {
+      entry.totalMs += cycle.duration;
+      if (cycle.duration > entry.maxMs) entry.maxMs = cycle.duration;
+    }
+    for (const key of cycle.changed) {
+      reasons.set(key, (reasons.get(key) ?? 0) + 1);
+    }
+  }
+  const entries = [];
+  for (const {entry, reasons} of byTag.values()) {
+    entry.reasons = [...reasons]
+      .map(([key, count]) => ({key, count}))
+      .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));
+    entries.push(entry);
+  }
+  // Slowest first, then most frequent: a component with no measured durations
+  // still sorts above a quiet one.
+  return entries.sort((a, b) => b.totalMs - a.totalMs || b.updates - a.updates);
+};
+/**
+ * Attributes each update cycle to the input event that preceded it, within
+ * `windowMs`.
+ *
+ * This is what the mouse and keyboard layers are for. On their own they
+ * duplicate what the browser's own event log already shows; joined to the
+ * updates they precede they answer the question the raw layers only imply —
+ * an update with a cause is an interaction, and an update without one is a
+ * timer, a signal, or a stray `requestUpdate()`.
+ *
+ * Returns a new array; cycles with no cause are returned as-is.
+ */
+export const attributeInput = (cycles, events, windowMs = 200) => {
+  const inputs = events
+    .filter((event) => INPUT_LAYER_IDS.includes(event.layerId))
+    .sort((a, b) => a.time - b.time);
+  if (inputs.length === 0) return [...cycles];
+  // Both sides are sorted by time, so one forward pass suffices.
+  let cursor = 0;
+  return cycles.map((cycle) => {
+    while (
+      cursor + 1 < inputs.length &&
+      inputs[cursor + 1].time <= cycle.start
+    ) {
+      cursor++;
+    }
+    const candidate = inputs[cursor];
+    const delta = cycle.start - candidate.time;
+    if (delta < 0 || delta > windowMs) return cycle;
+    return {
+      ...cycle,
+      cause: {
+        layerId: candidate.layerId,
+        type: candidate.title ?? candidate.layerId,
+        detail: candidate.subtitle,
+        time: candidate.time,
+      },
+    };
+  });
+};
+//# sourceMappingURL=derive.js.map

package/lib/timeline/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../src/lib/timeline/derive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2026 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\n\n/**\n * Derivation over recorded timeline events.\n *\n * The capture layers emit one event per phase boundary, which is the right\n * wire format and the wrong thing to read: a single update tick of one\n * component is five to ten rows whose durations the reader has to subtract by\n * hand. Everything needed to do better is already on the events — `groupId`\n * pairs a start with its end, `data.changed` names the reactive properties\n * that caused the update — so this module turns a flat event list into the\n * three shapes the panel and agents actually ask for:\n *\n * - {@link TimelineSpan} — a start/end pair collapsed into one entry with a\n *   duration (\"`update` took 1.8ms\").\n * - {@link UpdateCycle} — one component's whole update tick, with the changed\n *   property keys that triggered it (\"`<hmr-counter>` updated because\n *   `count` changed\").\n * - {@link ComponentRollup} — per-component totals over a recording (\"this\n *   component updated 340 times for 120ms\").\n *\n * Pure and dependency-free by design: it imports only the shared event types,\n * so the panel derives client-side over its 5000-event buffer and\n * `devframe/definition.ts` — which must stay framework-neutral — can derive\n * server-side over the ring buffer for the agent-facing summary.\n */\n\nimport type {TimelineEvent} from '../../types/timeline.js';\n\n/** Layer whose events describe Lit update ticks. */\nconst LIFECYCLE_LAYER_ID = 'lit-lifecycle';\n\n/** Layers whose events are developer input, for {@link attributeInput}. */\nconst INPUT_LAYER_IDS: readonly string[] = ['mouse', 'keyboard'];\n\n/** The phase that brackets an entire update tick. */\nconst ROOT_PHASE = 'performUpdate';\n\nconst START_SUFFIX = ':start';\nconst END_SUFFIX = ':end';\n\n/**\n * A start/end pair collapsed into one entry, or a point event that never had\n * an end to begin with.\n */\nexport interface TimelineSpan {\n  layerId: string;\n  /**\n   * Stable across re-derivation of the same events, which a Lit `repeat()`\n   * key and a selection comparison both need — the span objects themselves\n   * are rebuilt whenever the event buffer changes.\n   */\n  key: string;\n  /** The event title with its `:start` / `:end` suffix removed. */\n  name: string;\n  /** Pairing id as emitted; `undefined` for point events. */\n  groupId?: number | string;\n  start: number;\n  /** Absent while the span is still open, or if its end was never recorded. */\n  end?: number;\n  /** `end - start`. Absent for open spans and for point events. */\n  duration?: number;\n  /** Reactive property keys that caused this update, where the phase has them. */\n  changed?: string[];\n  subtitle?: string;\n  logType?: TimelineEvent['logType'];\n  meta?: TimelineEvent['meta'];\n  /** The events this span was built from, for the detail pane. */\n  events: TimelineEvent[];\n}\n\n/** One component's complete update tick. */\nexport interface UpdateCycle {\n  /** The `${elementId}:${tick}` groupId the phases share. */\n  key: string;\n  elementId: number;\n  tagName: string;\n  source?: {file: string; line: number};\n  start: number;\n  /** The `performUpdate` span's duration — see {@link toUpdateCycles}. */\n  duration?: number;\n  /** Union of the changed reactive property keys across the tick's phases. */\n  changed: string[];\n  phases: TimelineSpan[];\n  /** The input event this update followed, if any. See {@link attributeInput}. */\n  cause?: {layerId: string; type: string; detail?: string; time: number};\n}\n\n/** Per-component totals over a set of update cycles. */\nexport interface ComponentRollup {\n  tagName: string;\n  /** Every instance of this component that updated, in first-seen order. */\n  elementIds: number[];\n  updates: number;\n  /** Summed `performUpdate` durations; excludes cycles with no measured end. */\n  totalMs: number;\n  maxMs: number;\n  /** Changed-key frequency across the cycles, most frequent first. */\n  reasons: Array<{key: string; count: number}>;\n  source?: {file: string; line: number};\n}\n\n/** Reads `data.changed` defensively — `data` is `unknown` on the wire. */\nconst changedOf = (event: TimelineEvent): string[] | undefined => {\n  const data = event.data;\n  if (data === null || typeof data !== 'object') return undefined;\n  const changed = (data as {changed?: unknown}).changed;\n  if (!Array.isArray(changed)) return undefined;\n  const keys = changed.filter((key): key is string => typeof key === 'string');\n  return keys.length > 0 ? keys : undefined;\n};\n\nconst pointSpan = (event: TimelineEvent, index: number): TimelineSpan => ({\n  layerId: event.layerId,\n  key: `${event.layerId}:point:${index}`,\n  name: event.title ?? event.layerId,\n  start: event.time,\n  changed: changedOf(event),\n  subtitle: event.subtitle,\n  logType: event.logType,\n  meta: event.meta,\n  events: [event],\n});\n\n/**\n * Collapses `:start` / `:end` event pairs into spans, passing anything else\n * through as a point span.\n *\n * Pairing is keyed on **layer + groupId + phase name**, never on `groupId`\n * alone: a whole update tick shares one groupId (`runtime/timeline/\n * lifecycle.ts` builds it as `${elementId}:${tick}`), so matching on the id\n * would marry `willUpdate:start` to `performUpdate:end`. Each phase occurs at\n * most once per tick, which makes the triple unique.\n *\n * Unmatched halves survive rather than disappear — the buffer is a bounded\n * ring, so its oldest end and its newest start routinely have no partner, and\n * an update that is still running has a genuinely open span.\n */\nexport const toSpans = (events: readonly TimelineEvent[]): TimelineSpan[] => {\n  const spans: TimelineSpan[] = [];\n  const open = new Map<string, TimelineSpan>();\n\n  events.forEach((event, index) => {\n    const title = event.title ?? event.layerId;\n    const isStart = title.endsWith(START_SUFFIX);\n    const isEnd = !isStart && title.endsWith(END_SUFFIX);\n\n    if (event.groupId === undefined || (!isStart && !isEnd)) {\n      spans.push(pointSpan(event, index));\n      return;\n    }\n\n    const name = title.slice(\n      0,\n      -(isStart ? START_SUFFIX.length : END_SUFFIX.length)\n    );\n    const key = `${event.layerId}:${event.groupId}:${name}`;\n\n    if (isStart) {\n      const span: TimelineSpan = {\n        layerId: event.layerId,\n        key,\n        name,\n        groupId: event.groupId,\n        start: event.time,\n        changed: changedOf(event),\n        subtitle: event.subtitle,\n        logType: event.logType,\n        meta: event.meta,\n        events: [event],\n      };\n      open.set(key, span);\n      // Pushed on its start, so the list is already in start order and an\n      // open span keeps its place instead of appearing when it finally ends.\n      spans.push(span);\n      return;\n    }\n\n    const span = open.get(key);\n    if (span === undefined) {\n      spans.push(pointSpan(event, index));\n      return;\n    }\n    open.delete(key);\n    span.events.push(event);\n    // A negative delta means the buffer straddles a clock reset (the runtime\n    // re-zeroes on the rising edge of recording). Report no duration rather\n    // than a negative one; the span stays open, which is what it honestly is.\n    if (event.time >= span.start) {\n      span.end = event.time;\n      span.duration = event.time - span.start;\n    }\n    span.changed ??= changedOf(event);\n  });\n\n  return spans.sort((a, b) => a.start - b.start);\n};\n\n/**\n * Groups lifecycle spans into update ticks.\n *\n * `duration` is taken from the `performUpdate` span alone, never from a sum of\n * the phases: `willUpdate` / `update` / `updated` all run *inside*\n * `performUpdate`, so summing counts the same milliseconds several times over.\n *\n * `changed` is the union across the tick's phases because only the phases that\n * receive a `PropertyValues` argument carry it — `performUpdate` takes none,\n * so the bracketing span is always silent about the reason.\n */\nexport const toUpdateCycles = (\n  spans: readonly TimelineSpan[]\n): UpdateCycle[] => {\n  const byGroup = new Map<string, UpdateCycle>();\n\n  for (const span of spans) {\n    const elementId = span.meta?.elementId;\n    if (\n      span.layerId !== LIFECYCLE_LAYER_ID ||\n      span.groupId === undefined ||\n      elementId === undefined\n    ) {\n      // Point lifecycle events (connect/disconnect) have no groupId and are\n      // not update ticks; other layers are not this function's business.\n      continue;\n    }\n\n    const key = String(span.groupId);\n    let cycle = byGroup.get(key);\n    if (cycle === undefined) {\n      cycle = {\n        key,\n        elementId,\n        tagName: span.meta?.tagName ?? 'unknown',\n        source: span.meta?.source,\n        start: span.start,\n        changed: [],\n        phases: [],\n      };\n      byGroup.set(key, cycle);\n    }\n\n    cycle.phases.push(span);\n    if (span.start < cycle.start) cycle.start = span.start;\n    if (span.name === ROOT_PHASE) cycle.duration = span.duration;\n    for (const changedKey of span.changed ?? []) {\n      if (!cycle.changed.includes(changedKey)) cycle.changed.push(changedKey);\n    }\n  }\n\n  return [...byGroup.values()].sort((a, b) => a.start - b.start);\n};\n\n/**\n * Totals update cycles per component tag.\n *\n * Grouped by tag rather than by instance because the question this answers is\n * \"which *component* re-renders too much\" — a list of 200 rows each updating\n * twice is one component's problem, not 200. The instance ids are kept so the\n * caller can still drill in.\n */\nexport const rollup = (cycles: readonly UpdateCycle[]): ComponentRollup[] => {\n  const byTag = new Map<\n    string,\n    {entry: ComponentRollup; reasons: Map<string, number>}\n  >();\n\n  for (const cycle of cycles) {\n    let record = byTag.get(cycle.tagName);\n    if (record === undefined) {\n      record = {\n        entry: {\n          tagName: cycle.tagName,\n          elementIds: [],\n          updates: 0,\n          totalMs: 0,\n          maxMs: 0,\n          reasons: [],\n          source: cycle.source,\n        },\n        reasons: new Map(),\n      };\n      byTag.set(cycle.tagName, record);\n    }\n\n    const {entry, reasons} = record;\n    entry.updates++;\n    if (!entry.elementIds.includes(cycle.elementId)) {\n      entry.elementIds.push(cycle.elementId);\n    }\n    entry.source ??= cycle.source;\n    // An open or clock-straddling cycle contributes a count but no time —\n    // better than inventing one, and the count is what flags a hot component.\n    if (cycle.duration !== undefined) {\n      entry.totalMs += cycle.duration;\n      if (cycle.duration > entry.maxMs) entry.maxMs = cycle.duration;\n    }\n    for (const key of cycle.changed) {\n      reasons.set(key, (reasons.get(key) ?? 0) + 1);\n    }\n  }\n\n  const entries: ComponentRollup[] = [];\n  for (const {entry, reasons} of byTag.values()) {\n    entry.reasons = [...reasons]\n      .map(([key, count]) => ({key, count}))\n      .sort((a, b) => b.count - a.count || a.key.localeCompare(b.key));\n    entries.push(entry);\n  }\n\n  // Slowest first, then most frequent: a component with no measured durations\n  // still sorts above a quiet one.\n  return entries.sort((a, b) => b.totalMs - a.totalMs || b.updates - a.updates);\n};\n\n/**\n * Attributes each update cycle to the input event that preceded it, within\n * `windowMs`.\n *\n * This is what the mouse and keyboard layers are for. On their own they\n * duplicate what the browser's own event log already shows; joined to the\n * updates they precede they answer the question the raw layers only imply —\n * an update with a cause is an interaction, and an update without one is a\n * timer, a signal, or a stray `requestUpdate()`.\n *\n * Returns a new array; cycles with no cause are returned as-is.\n */\nexport const attributeInput = (\n  cycles: readonly UpdateCycle[],\n  events: readonly TimelineEvent[],\n  windowMs = 200\n): UpdateCycle[] => {\n  const inputs = events\n    .filter((event) => INPUT_LAYER_IDS.includes(event.layerId))\n    .sort((a, b) => a.time - b.time);\n  if (inputs.length === 0) return [...cycles];\n\n  // Both sides are sorted by time, so one forward pass suffices.\n  let cursor = 0;\n  return cycles.map((cycle) => {\n    while (\n      cursor + 1 < inputs.length &&\n      inputs[cursor + 1]!.time <= cycle.start\n    ) {\n      cursor++;\n    }\n    const candidate = inputs[cursor]!;\n    const delta = cycle.start - candidate.time;\n    if (delta < 0 || delta > windowMs) return cycle;\n    return {\n      ...cycle,\n      cause: {\n        layerId: candidate.layerId,\n        type: candidate.title ?? candidate.layerId,\n        detail: candidate.subtitle,\n        time: candidate.time,\n      },\n    };\n  });\n};\n"]}

package/lib/timeline-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeline-plugin.d.ts","sourceRoot":"","sources":["../../../packages/labs/vite-plugin-lit/src/lib/timeline-plugin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAC,MAAM,EAAgB,MAAM,MAAM,CAAC;AAChD,OAAO,EAEL,KAAK,eAAe,EAIrB,MAAM,sBAAsB,CAAC;AAkB9B,UAAU,SAAS;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAC3C;AAED,4DAA4D;AAC5D,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAC3C;AAED,UAAU,WAAW;IACnB,KAAK,EAAE;QAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAA;KAAC,CAAC;IACjD,QAAQ,CAAC,EAAE;QAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAA;KAAC,CAAC;IAC1D,GAAG,EAAE;QACH,QAAQ,EAAE,CAAC,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC;QAC9B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC;KAC7D,CAAC;IACF,KAAK,EAAE;QAAC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;KAAC,CAAC;IAChE,UAAU,CAAC,EAAE;QACX,WAAW,EAAE;YACX,GAAG,EAAE,CACH,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CACP,GAAG,EAAE;gBAAC,GAAG,CAAC,EAAE,MAAM,CAAA;aAAC,EACnB,GAAG,EAAE;gBACH,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;gBAC1C,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;aAC7B,EACD,IAAI,EAAE,MAAM,IAAI,KACb,IAAI,KACN,IAAI,CAAC;SACX,CAAC;KACH,CAAC;IACF,UAAU,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;CAC7B;AAID,OAAO,QAAQ,MAAM,CAAC;IACpB,UAAU,MAAM;QACd,QAAQ,CAAC,EAAE;YACT,YAAY,CAAC,EAAE,OAAO,CAAC;YACvB,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;SACnD,CAAC;KACH;CACF;AAyJD,eAAO,MAAM,iBAAiB,GAC5B,cAAc,MAAM,eAAe,GAAG,SAAS,KAC9C,MAwTF,CAAC"}
+{"version":3,"file":"timeline-plugin.d.ts","sourceRoot":"","sources":["../src/lib/timeline-plugin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAC,MAAM,EAAgB,MAAM,MAAM,CAAC;AAEhD,OAAO,EAEL,KAAK,eAAe,EAIrB,MAAM,sBAAsB,CAAC;AAkB9B,UAAU,SAAS;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAC3C;AAED,4DAA4D;AAC5D,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,KAAK,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CAC3C;AAED,UAAU,WAAW;IACnB,KAAK,EAAE;QAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAA;KAAC,CAAC;IACjD,QAAQ,CAAC,EAAE;QAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAA;KAAC,CAAC;IAC1D,GAAG,EAAE;QACH,QAAQ,EAAE,CAAC,EAAE,EAAE,KAAK,KAAK,IAAI,CAAC;QAC9B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAC;KAC7D,CAAC;IACF,KAAK,EAAE;QAAC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;KAAC,CAAC;IAChE,UAAU,CAAC,EAAE;QACX,WAAW,EAAE;YACX,GAAG,EAAE,CACH,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CACP,GAAG,EAAE;gBAAC,GAAG,CAAC,EAAE,MAAM,CAAA;aAAC,EACnB,GAAG,EAAE;gBACH,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;gBAC1C,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;aAC7B,EACD,IAAI,EAAE,MAAM,IAAI,KACb,IAAI,KACN,IAAI,CAAC;SACX,CAAC;KACH,CAAC;IACF,UAAU,CAAC,EAAE;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;CAC7B;AAID,OAAO,QAAQ,MAAM,CAAC;IACpB,UAAU,MAAM;QACd,QAAQ,CAAC,EAAE;YACT,YAAY,CAAC,EAAE,OAAO,CAAC;YACvB,KAAK,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;SACnD,CAAC;KACH;CACF;AA0ID,eAAO,MAAM,iBAAiB,iBACd,MAAM,eAAe,GAAG,SAAS,KAC9C,MAoTF,CAAC"}