miriad-viz 0.1.0

package/dist-lib/index.cjs

@@ -0,0 +1,2369 @@
+'use strict';
+
+// src/shared-constants.ts
+var SIM_HOURS_PER_SECOND = 0.6;
+var AGENT_SHADER_NODE_RADIUS = 0.15;
+var GLOW_RADIUS_RATIO = 3;
+var PILL_GAP_RATIO = 0.2;
+var PILL_GAP_BASE = 0;
+
+// src/engine/pack-rows.ts
+var MIN_BAR_WIDTH_NORM = 3e-3;
+var ROW_GAP_NORM = 1e-3;
+var MAX_BAR_WIDTH_NORM = 0.95;
+function packArtifactRows(bars, progress, minGapNorm, minBarWidthNorm) {
+  const gap = Math.max(ROW_GAP_NORM, minGapNorm ?? ROW_GAP_NORM);
+  const effectiveBarWidth = Math.max(MIN_BAR_WIDTH_NORM, minBarWidthNorm ?? MIN_BAR_WIDTH_NORM);
+  const rowEnds = [];
+  for (const bar of bars) {
+    const start = bar.normalizedTime;
+    if (start < 0 || start > 1) {
+      bar.row = 0;
+      continue;
+    }
+    const rawEnd = start + effectiveBarWidth;
+    const end = Math.min(rawEnd, progress);
+    let row = 0;
+    for (row = 0; row < rowEnds.length; row++) {
+      if (rowEnds[row] <= start) break;
+    }
+    if (row >= rowEnds.length) {
+      rowEnds.push(-1);
+    }
+    rowEnds[row] = end + gap;
+    bar.row = row;
+  }
+  return bars;
+}
+function packPRRows(bars, progress, minGapNorm, minBarWidthNorm) {
+  const gap = Math.max(ROW_GAP_NORM, minGapNorm ?? ROW_GAP_NORM);
+  const minWidth = Math.max(MIN_BAR_WIDTH_NORM, minBarWidthNorm ?? MIN_BAR_WIDTH_NORM);
+  bars.sort((a, b) => a.openedNormalized - b.openedNormalized);
+  const rowEnds = [];
+  for (const bar of bars) {
+    const start = bar.openedNormalized;
+    if (start < 0 || start > 1) {
+      bar.row = 0;
+      continue;
+    }
+    const rawEnd = bar.mergedNormalized ?? progress;
+    const width = Math.min(MAX_BAR_WIDTH_NORM, Math.max(minWidth, rawEnd - start));
+    const end = Math.min(start + width, progress);
+    let row = 0;
+    for (row = 0; row < rowEnds.length; row++) {
+      if (rowEnds[row] <= start) break;
+    }
+    if (row >= rowEnds.length) {
+      rowEnds.push(-1);
+    }
+    rowEnds[row] = end + gap;
+    bar.row = row;
+  }
+  return bars;
+}
+
+// src/engine/get-frame-state.ts
+var AGENT_FADE_DURATION = 0.01;
+var BOUNCE_DURATION = 0.015;
+var MIN_PARTICLE_SECONDS = 3;
+var ACTIVITY_WINDOW = 0.01;
+var ACTIVITY_RADIUS_BOOST = 1.5;
+var WORK_WINDOW = 0.042;
+var WORK_WEIGHTS = {
+  commit: 3,
+  pr_created: 5,
+  pr_merged: 5,
+  message: 1,
+  artifact: 2
+};
+var WORK_INTENSITY_MAX = 25;
+var MIN_PILL_SECONDS = 5;
+var DENSE_WINDOW_RATIO = 0.625;
+var CLUSTER_THRESHOLD_RATIO = 2;
+function secondsToNormalized(realSeconds, durationMs) {
+  const totalHours = durationMs / 36e5;
+  const playbackSeconds = totalHours / SIM_HOURS_PER_SECOND;
+  return realSeconds / playbackSeconds;
+}
+function computeTimeWindows(durationMs) {
+  const narrationWindow = secondsToNormalized(MIN_PILL_SECONDS, durationMs);
+  const narrationWindowDense = narrationWindow * DENSE_WINDOW_RATIO;
+  const narrationClusterThreshold = narrationWindow * CLUSTER_THRESHOLD_RATIO;
+  const particleWindow = secondsToNormalized(MIN_PARTICLE_SECONDS, durationMs);
+  return { narrationWindow, narrationWindowDense, narrationClusterThreshold, particleWindow };
+}
+var NARRATION_FADE_IN = 0.05;
+var NARRATION_FADE_OUT = 0.08;
+var EDITORIAL_FADE = 0;
+var EDGE_SATURATION = 8;
+var EDGE_MIN_STRENGTH = 0.01;
+var NODE_RADIUS_REF = AGENT_SHADER_NODE_RADIUS;
+var HUMAN_SIZE_MULTIPLIER = 1.5;
+var MAX_WORK_GROWTH = 1;
+var ACTIVITY_PULSE = 0.3;
+var LABEL_GAP_RATIO = 0.65;
+function getAgentAppearTime(agentId, events) {
+  for (const e of events) {
+    if (e.agent === agentId || e.targetAgent === agentId) {
+      return e.normalizedTime;
+    }
+  }
+  return null;
+}
+function computeBounceScale(timeSinceJoin) {
+  if (timeSinceJoin < 0) return 0;
+  const t = timeSinceJoin / BOUNCE_DURATION;
+  if (t >= 1) return 1;
+  if (t < 1 / 3) {
+    const p2 = t * 3;
+    return 1.2 * (1 - (1 - p2) ** 3);
+  }
+  if (t < 2 / 3) {
+    const p2 = (t - 1 / 3) * 3;
+    return 1.2 - 0.25 * p2;
+  }
+  const p = (t - 2 / 3) * 3;
+  return 0.95 + 0.05 * p;
+}
+function computeWorkIntensity(agentId, progress, events) {
+  const windowStart = progress - WORK_WINDOW;
+  let totalWork = 0;
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.normalizedTime < windowStart) continue;
+    if (event.agent !== agentId) continue;
+    const weight = WORK_WEIGHTS[event.type];
+    if (weight === void 0) continue;
+    const age = progress - event.normalizedTime;
+    const decayed = weight * Math.exp(-50 * age);
+    totalWork += decayed;
+  }
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.normalizedTime < windowStart) continue;
+    if (event.targetAgent !== agentId) continue;
+    const weight = WORK_WEIGHTS[event.type];
+    if (weight === void 0) continue;
+    const age = progress - event.normalizedTime;
+    const decayed = weight * Math.exp(-50 * age);
+    totalWork += decayed;
+  }
+  return Math.min(1, totalWork / WORK_INTENSITY_MAX);
+}
+var TOTAL_WORK_EVENT_TYPES = /* @__PURE__ */ new Set(["commit", "pr_created", "pr_merged"]);
+function computeTotalWork(agentId, progress, events) {
+  let count = 0;
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.agent !== agentId) continue;
+    if (TOTAL_WORK_EVENT_TYPES.has(event.type)) {
+      count++;
+    }
+  }
+  return count;
+}
+function computeAgentState(agent, progress, events, maxTotalWork, layoutContext) {
+  const appearTime = getAgentAppearTime(agent.id, events);
+  if (appearTime === null || progress < appearTime) {
+    return null;
+  }
+  const timeSinceJoin = progress - appearTime;
+  const opacity = Math.min(1, timeSinceJoin / AGENT_FADE_DURATION);
+  const scale = computeBounceScale(timeSinceJoin);
+  const recentEvents = events.filter(
+    (e) => e.agent === agent.id && e.normalizedTime <= progress && e.normalizedTime > progress - ACTIVITY_WINDOW
+  );
+  const activityFactor = Math.min(1, recentEvents.length / 5);
+  const radiusMultiplier = 1 + activityFactor * (ACTIVITY_RADIUS_BOOST - 1);
+  const workIntensity = computeWorkIntensity(agent.id, progress, events);
+  const totalWork = computeTotalWork(agent.id, progress, events);
+  const isHuman = agent.role === "human";
+  const humanMul = isHuman ? HUMAN_SIZE_MULTIPLIER : 1;
+  const growthFactor = totalWork / maxTotalWork;
+  const activityPulse = 1 + workIntensity * ACTIVITY_PULSE;
+  const nodeRadius = layoutContext?.nodeRadius ?? NODE_RADIUS_REF;
+  const layoutScale = nodeRadius / NODE_RADIUS_REF;
+  const coreScale = humanMul * (1 + growthFactor * MAX_WORK_GROWTH) * activityPulse * scale * layoutScale;
+  const labelHeight = layoutContext?.labelHeight ?? nodeRadius * 1.6;
+  const visualRadius = nodeRadius * coreScale;
+  const labelGap = visualRadius * LABEL_GAP_RATIO;
+  const labelOffsetY = -(visualRadius + labelGap + labelHeight / 2);
+  return {
+    id: agent.id,
+    x: agent.position.x,
+    y: agent.position.y,
+    radius: agent.radius * radiusMultiplier,
+    color: agent.color,
+    opacity,
+    glowIntensity: activityFactor,
+    label: agent.label,
+    labelOpacity: opacity,
+    scale,
+    workIntensity,
+    totalWork,
+    isHuman,
+    role: agent.role,
+    coreScale,
+    labelOffsetY
+  };
+}
+var PARTICLE_TYPES = /* @__PURE__ */ new Set(["message"]);
+var PARTICLE_TRAVEL_FRACTION = 1;
+function computeParticles(agents, events, progress, particleWindow) {
+  const agentMap = new Map(agents.map((a) => [a.id, a]));
+  const particles = [];
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (!PARTICLE_TYPES.has(event.type)) continue;
+    const age = progress - event.normalizedTime;
+    if (age > particleWindow) continue;
+    const sender = agentMap.get(event.agent);
+    if (!sender) continue;
+    const receiver = event.targetAgent ? agentMap.get(event.targetAgent) : null;
+    if (!receiver) continue;
+    const t = age / particleWindow;
+    const travel = Math.min(t / PARTICLE_TRAVEL_FRACTION, 1);
+    const fade = t <= PARTICLE_TRAVEL_FRACTION ? 1 : 1 - (t - PARTICLE_TRAVEL_FRACTION) / (1 - PARTICLE_TRAVEL_FRACTION);
+    const px = sender.position.x + (receiver.position.x - sender.position.x) * travel;
+    const py = sender.position.y + (receiver.position.y - sender.position.y) * travel;
+    particles.push({
+      id: `particle-${event.type}-${event.normalizedTime}-${event.agent}`,
+      type: "message",
+      x: px,
+      y: py,
+      opacity: fade,
+      size: 4,
+      color: sender.color
+    });
+  }
+  return particles;
+}
+var NARRATION_ABOVE_RATIO = PILL_GAP_RATIO;
+var NARRATION_ABOVE_BASE = PILL_GAP_BASE;
+var PILL_QUOTE_FONT_PX = 16;
+var PILL_SPEAKER_FONT_RATIO = 1.2;
+var PILL_MAX_VIEWPORT_FRACTION = 0.75;
+var PILL_MIN_HEIGHT_RATIO = 2;
+var PILL_BG_DARKEN = 0.3;
+var PILL_BG_MIN_BRIGHTNESS = 25;
+var CHAR_WIDTH_RATIO = 0.75;
+var LINE_HEIGHT_RATIO = 1.4;
+function darkenHexForPill(hex, factor) {
+  const h = hex.replace("#", "");
+  const r = Math.max(
+    PILL_BG_MIN_BRIGHTNESS,
+    Math.round(Number.parseInt(h.slice(0, 2), 16) * factor)
+  );
+  const g = Math.max(
+    PILL_BG_MIN_BRIGHTNESS,
+    Math.round(Number.parseInt(h.slice(2, 4), 16) * factor)
+  );
+  const b = Math.max(
+    PILL_BG_MIN_BRIGHTNESS,
+    Math.round(Number.parseInt(h.slice(4, 6), 16) * factor)
+  );
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function computePillLayout(speakerLabel, text, speakerColor, layoutContext) {
+  const nodeRadius = layoutContext?.nodeRadius ?? NODE_RADIUS_REF;
+  const ppu = layoutContext ? layoutContext.viewportPxWidth / layoutContext.worldWidth : 128;
+  const padX = layoutContext?.narrationPadX ?? 0.25;
+  const padY = layoutContext?.narrationPadY ?? 0.14;
+  const maxWidth = layoutContext?.narrationMaxWidth ?? 4;
+  const fontSize = PILL_QUOTE_FONT_PX;
+  const speakerFontSize = Math.round(fontSize * PILL_SPEAKER_FONT_RATIO);
+  const fontWorldUnits = fontSize / ppu;
+  const viewportMaxWorld = layoutContext ? layoutContext.viewportPxWidth * PILL_MAX_VIEWPORT_FRACTION / ppu : maxWidth;
+  const maxPillWidth = Math.min(maxWidth, viewportMaxWorld);
+  const textAreaWidth = maxPillWidth - padX * 2;
+  const speakerPrefix = "";
+  const speakerWidthWorld = speakerPrefix.length * (speakerFontSize / ppu) * CHAR_WIDTH_RATIO;
+  const fullText = text;
+  const fullTextWidthWorld = fullText.length * fontWorldUnits * CHAR_WIDTH_RATIO;
+  const totalTextWidth = speakerWidthWorld + fullTextWidthWorld;
+  let lines;
+  const charWidthWorld = fontWorldUnits * CHAR_WIDTH_RATIO;
+  if (totalTextWidth <= textAreaWidth) {
+    lines = [fullText];
+  } else {
+    const firstLineAvail = textAreaWidth - speakerWidthWorld;
+    const charsPerLine = Math.max(10, Math.floor(textAreaWidth / charWidthWorld));
+    const charsFirstLine = Math.max(5, Math.floor(firstLineAvail / charWidthWorld));
+    lines = [];
+    const words = fullText.split(" ");
+    let currentLine = "";
+    let currentChars = 0;
+    for (const word of words) {
+      const limit = lines.length === 0 ? charsFirstLine : charsPerLine;
+      if (currentLine && currentChars + 1 + word.length > limit) {
+        lines.push(currentLine);
+        currentLine = word;
+        currentChars = word.length;
+      } else {
+        currentLine = currentLine ? `${currentLine} ${word}` : word;
+        currentChars = currentLine.length;
+      }
+    }
+    if (currentLine) lines.push(currentLine);
+    if (lines.length > 3) {
+      lines = lines.slice(0, 3);
+      lines[2] = `${lines[2].slice(0, -3)}...`;
+    }
+  }
+  const lineHeightWorld = fontWorldUnits * LINE_HEIGHT_RATIO;
+  const textHeight = lineHeightWorld * lines.length;
+  const computedHeight = textHeight + padY * 2;
+  const minHeight = nodeRadius * PILL_MIN_HEIGHT_RATIO;
+  const estimatedHeight = Math.max(computedHeight, minHeight);
+  const estimatedWidth = lines.length === 1 ? Math.min(totalTextWidth + padX * 2, maxPillWidth) : maxPillWidth;
+  const pillBgColor = darkenHexForPill(speakerColor, PILL_BG_DARKEN);
+  return {
+    lines,
+    padX,
+    padY,
+    maxPillWidth,
+    estimatedWidth,
+    estimatedHeight,
+    speakerLabel,
+    speakerColor,
+    pillBgColor
+  };
+}
+function computeQuotePillPosition(quote, visibleAgents, agents, layoutContext, estimatedHeight, estimatedWidth) {
+  const nodeRadius = layoutContext?.nodeRadius ?? NODE_RADIUS_REF;
+  const gap = nodeRadius * NARRATION_ABOVE_RATIO + NARRATION_ABOVE_BASE;
+  const speaker = visibleAgents.find((a) => a.id === quote.speaker);
+  const speakerAgent = agents.find((a) => a.id === quote.speaker);
+  if (speaker && speakerAgent) {
+    const speakerCoreScale = speaker.coreScale ?? 1;
+    const coreRadius = nodeRadius * speakerCoreScale;
+    let yOffset = coreRadius + gap + estimatedHeight / 2;
+    if (layoutContext?.agentToWorld && layoutContext.agentsBandTop !== void 0) {
+      const agentWorldY = layoutContext.agentToWorld(
+        speakerAgent.position.x,
+        speakerAgent.position.y
+      ).y;
+      const pillTop = agentWorldY + yOffset + estimatedHeight / 2;
+      const margin = 0.02;
+      const maxPillTop = layoutContext.agentsBandTop - margin;
+      if (pillTop > maxPillTop) {
+        yOffset -= pillTop - maxPillTop;
+      }
+    }
+    let xOffset = 0;
+    if (layoutContext?.agentToWorld) {
+      const agentWorldX = layoutContext.agentToWorld(
+        speakerAgent.position.x,
+        speakerAgent.position.y
+      ).x;
+      const margin = 0.02;
+      const minLeft = layoutContext.worldLeft + margin;
+      const maxRight = layoutContext.worldRight - margin;
+      const clampWidth = estimatedWidth * 1.1;
+      const pillLeft = agentWorldX - clampWidth / 2;
+      const pillRight = agentWorldX + clampWidth / 2;
+      if (pillLeft < minLeft) {
+        xOffset = minLeft - pillLeft;
+      } else if (pillRight > maxRight) {
+        xOffset = maxRight - pillRight;
+      }
+    }
+    return {
+      speakerNormX: speakerAgent.position.x,
+      speakerNormY: speakerAgent.position.y,
+      yOffset,
+      xOffset
+    };
+  }
+  return { speakerNormX: 0.5, speakerNormY: 0.5, yOffset: 0, xOffset: 0 };
+}
+function computePillSchedule(quotes, narrationWindow, narrationWindowDense, narrationClusterThreshold) {
+  const schedule = /* @__PURE__ */ new Map();
+  const bySpeaker = /* @__PURE__ */ new Map();
+  for (let i = 0; i < quotes.length; i++) {
+    const q = quotes[i];
+    let group = bySpeaker.get(q.speaker);
+    if (!group) {
+      group = [];
+      bySpeaker.set(q.speaker, group);
+    }
+    group.push({ idx: i, quote: q });
+  }
+  for (const group of bySpeaker.values()) {
+    group.sort((a, b) => a.quote.normalizedTime - b.quote.normalizedTime);
+    let lastEnd = -1;
+    for (let gi = 0; gi < group.length; gi++) {
+      const { idx, quote } = group[gi];
+      const naturalStart = quote.normalizedTime;
+      const nextQuote = gi + 1 < group.length ? group[gi + 1].quote : null;
+      const isDense = nextQuote !== null && nextQuote.normalizedTime - naturalStart < narrationClusterThreshold;
+      const window = isDense ? narrationWindowDense : narrationWindow;
+      let effectiveStart = Math.max(naturalStart, lastEnd);
+      const minWindow = window * 0.5;
+      if (effectiveStart + minWindow > 1) {
+        effectiveStart = Math.min(effectiveStart, 1 - minWindow);
+      }
+      const effectiveWindow = Math.min(window, 1 - effectiveStart);
+      schedule.set(idx, { effectiveStart, window: Math.max(effectiveWindow, minWindow) });
+      lastEnd = effectiveStart + Math.max(effectiveWindow, minWindow);
+    }
+  }
+  return schedule;
+}
+function computeQuotePills(quotes, progress, agents, visibleAgents, layoutContext, narrationWindow, narrationWindowDense, narrationClusterThreshold) {
+  const result = [];
+  const schedule = computePillSchedule(
+    quotes,
+    narrationWindow,
+    narrationWindowDense,
+    narrationClusterThreshold
+  );
+  for (let i = 0; i < quotes.length; i++) {
+    const quote = quotes[i];
+    const timing = schedule.get(i);
+    if (!timing) continue;
+    const { effectiveStart, window } = timing;
+    const end = effectiveStart + window;
+    if (progress < effectiveStart || progress > end) continue;
+    const elapsed = progress - effectiveStart;
+    const fadeIn = window * NARRATION_FADE_IN;
+    const fadeOut = window * NARRATION_FADE_OUT;
+    let opacity;
+    if (elapsed < fadeIn) {
+      opacity = elapsed / fadeIn;
+    } else if (elapsed > window - fadeOut) {
+      opacity = (window - elapsed) / fadeOut;
+    } else {
+      opacity = 1;
+    }
+    const speakerAgent = visibleAgents.find((a) => a.id === quote.speaker);
+    const speakerColor = speakerAgent?.color ?? "#3b82f6";
+    const speakerLabel = "";
+    const pill = computePillLayout(speakerLabel, quote.text, speakerColor, layoutContext);
+    const { speakerNormX, speakerNormY, yOffset, xOffset } = computeQuotePillPosition(
+      quote,
+      visibleAgents,
+      agents,
+      layoutContext,
+      pill.estimatedHeight,
+      pill.estimatedWidth
+    );
+    result.push({
+      text: quote.text,
+      speaker: quote.speaker,
+      opacity: Math.max(0, Math.min(1, opacity)),
+      speakerNormX,
+      speakerNormY,
+      yOffset,
+      xOffset,
+      lines: pill.lines,
+      padX: pill.padX,
+      padY: pill.padY,
+      maxPillWidth: pill.maxPillWidth,
+      estimatedWidth: pill.estimatedWidth,
+      speakerLabel: pill.speakerLabel,
+      speakerColor: pill.speakerColor,
+      pillBgColor: pill.pillBgColor,
+      ...quote.emoji && { emoji: quote.emoji },
+      ...quote.mood && { mood: quote.mood }
+    });
+  }
+  return result;
+}
+function computeEditorialNarration(queue, progress) {
+  if (queue.length === 0) return null;
+  let lo = 0;
+  let hi = queue.length - 1;
+  let idx = -1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    if (queue[mid].normalizedTime <= progress) {
+      idx = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  if (idx < 0) return null;
+  const entry = queue[idx];
+  const nextTime = idx < queue.length - 1 ? queue[idx + 1].normalizedTime : 1;
+  const entryDuration = nextTime - entry.normalizedTime;
+  const elapsed = progress - entry.normalizedTime;
+  const fadeIn = Math.min(EDITORIAL_FADE, entryDuration * 0.3);
+  const fadeOut = Math.min(EDITORIAL_FADE, entryDuration * 0.3);
+  let opacity;
+  if (elapsed < fadeIn) {
+    opacity = fadeIn > 0 ? elapsed / fadeIn : 1;
+  } else if (elapsed > entryDuration - fadeOut) {
+    opacity = fadeOut > 0 ? (entryDuration - elapsed) / fadeOut : 1;
+  } else {
+    opacity = 1;
+  }
+  return {
+    phaseTitle: entry.phaseTitle,
+    phaseColor: entry.phaseColor,
+    text: entry.text,
+    opacity: Math.max(0, Math.min(1, opacity))
+  };
+}
+function computePhase(phases, progress) {
+  for (const phase of phases) {
+    if (progress >= phase.startNormalized && progress <= phase.endNormalized) {
+      const phaseProgress = (progress - phase.startNormalized) / (phase.endNormalized - phase.startNormalized);
+      return {
+        id: phase.id,
+        name: phase.name,
+        progress: Math.max(0, Math.min(1, phaseProgress)),
+        color: phase.color
+      };
+    }
+  }
+  const lastPhase = phases[phases.length - 1];
+  if (lastPhase) {
+    return {
+      id: lastPhase.id,
+      name: lastPhase.name,
+      progress: progress >= lastPhase.endNormalized ? 1 : 0,
+      color: lastPhase.color
+    };
+  }
+  return { id: "unknown", name: "Unknown", progress: 0, color: "#888888" };
+}
+function computeStats(events, agents, progress) {
+  let commitsToDate = 0;
+  let prsToDate = 0;
+  let messagesToDate = 0;
+  for (const e of events) {
+    if (e.normalizedTime > progress) break;
+    if (e.type === "commit") commitsToDate++;
+    else if (e.type === "pr_merged") prsToDate++;
+    else if (e.type === "message") messagesToDate++;
+  }
+  return {
+    commitsToDate,
+    prsToDate,
+    messagesToDate,
+    activeAgents: agents.length
+  };
+}
+var COMMIT_TYPE_COLORS = {
+  feat: "#00e5cc",
+  // cyan — new features
+  fix: "#ffaa33",
+  // orange — bug fixes
+  hotfix: "#ffaa33",
+  // orange — urgent fixes
+  rework: "#ffaa33",
+  // orange — rework
+  infra: "#4488ff",
+  // blue — infrastructure
+  ci: "#4488ff",
+  // blue — CI/CD
+  refactor: "#4488ff",
+  // blue — refactoring
+  scaffold: "#4488ff",
+  // blue — scaffolding
+  test: "#aa66ff",
+  // purple — tests
+  perf: "#00e5cc",
+  // cyan — performance
+  docs: "#6bcb77",
+  // green — documentation
+  chore: "#555555",
+  // dim — chores
+  tweak: "#555555",
+  // dim — tweaks
+  merge: "#333333",
+  // very dim — merges
+  other: "#555555"
+  // dim — unclassified
+};
+var DEFAULT_COMMIT_COLOR = "#555555";
+function computeCommitDots(events, progress) {
+  const rawDots = [];
+  let maxSize = 0;
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.type !== "commit") continue;
+    const insertions = event.metadata.insertions ?? 0;
+    const deletions = event.metadata.deletions ?? 0;
+    const commitType = event.metadata.commitType ?? "other";
+    const size = insertions + deletions;
+    if (size > maxSize) maxSize = size;
+    rawDots.push({
+      normalizedTime: event.normalizedTime,
+      insertions,
+      deletions,
+      agent: event.agent,
+      commitType,
+      color: COMMIT_TYPE_COLORS[commitType] ?? DEFAULT_COMMIT_COLOR,
+      size
+    });
+  }
+  const sqrtMax = Math.sqrt(maxSize);
+  const dots = rawDots.map((d) => ({
+    normalizedTime: d.normalizedTime,
+    insertions: d.insertions,
+    deletions: d.deletions,
+    agent: d.agent,
+    commitType: d.commitType,
+    color: d.color,
+    heightNorm: sqrtMax > 0 ? Math.sqrt(d.size) / sqrtMax : 0
+  }));
+  return dots;
+}
+function computePRBars(agents, events, progress) {
+  const agentMap = new Map(agents.map((a) => [a.id, a]));
+  const createdMap = /* @__PURE__ */ new Map();
+  const mergedMap = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    const prNumber = event.metadata.prNumber;
+    if (prNumber === void 0) continue;
+    if (event.type === "pr_created") {
+      createdMap.set(prNumber, event);
+    } else if (event.type === "pr_merged") {
+      mergedMap.set(prNumber, event);
+    }
+  }
+  const bars = [];
+  for (const [prNumber, created] of createdMap) {
+    const agent = agentMap.get(created.agent);
+    if (!agent) continue;
+    const merged = mergedMap.get(prNumber);
+    const additions = created.metadata.additions ?? 0;
+    const deletions = created.metadata.deletions ?? 0;
+    bars.push({
+      prNumber,
+      openedNormalized: created.normalizedTime,
+      mergedNormalized: merged ? merged.normalizedTime : null,
+      agent: created.agent,
+      color: agent.color,
+      additions,
+      deletions,
+      row: 0
+      // populated by packPRRows()
+    });
+  }
+  return bars;
+}
+var ARTIFACT_TYPE_COLORS = {
+  task: "#00e5cc",
+  decision: "#ffd93d",
+  doc: "#4d96ff",
+  code: "#c084fc",
+  asset: "#ff8c42"
+};
+var DEFAULT_ARTIFACT_COLOR = "#4d96ff";
+function computeArtifactBars(_agents, events, progress) {
+  const bars = [];
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.type !== "artifact") continue;
+    const artifactType = event.metadata.type ?? "doc";
+    bars.push({
+      normalizedTime: event.normalizedTime,
+      type: artifactType,
+      agent: event.agent,
+      color: ARTIFACT_TYPE_COLORS[artifactType] ?? DEFAULT_ARTIFACT_COLOR,
+      row: 0
+      // populated by packArtifactRows()
+    });
+  }
+  return bars;
+}
+function computeEdges(agents, events, progress) {
+  const agentMap = new Map(agents.map((a) => [a.id, a]));
+  const edgeStrengths = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.normalizedTime > progress) break;
+    if (event.type !== "message" || !event.targetAgent) continue;
+    if (event.agent === event.targetAgent) continue;
+    const pair = event.agent < event.targetAgent ? `${event.agent}:${event.targetAgent}` : `${event.targetAgent}:${event.agent}`;
+    const age = progress - event.normalizedTime;
+    const decayedStrength = Math.exp(-5 * age);
+    edgeStrengths.set(pair, (edgeStrengths.get(pair) ?? 0) + decayedStrength);
+  }
+  if (edgeStrengths.size === 0) return [];
+  const maxRaw = Math.max(...edgeStrengths.values(), 1);
+  const edges = [];
+  for (const [pair, raw] of edgeStrengths) {
+    const strength = Math.min(raw / maxRaw, raw / EDGE_SATURATION);
+    if (strength < EDGE_MIN_STRENGTH) continue;
+    const [fromId, toId] = pair.split(":");
+    const fromAgent = agentMap.get(fromId);
+    const toAgent = agentMap.get(toId);
+    if (!fromAgent) continue;
+    const fromColor = fromAgent.color;
+    const toColor = toAgent?.color ?? fromColor;
+    edges.push({
+      fromId,
+      toId,
+      strength,
+      color: fromColor,
+      fromColor,
+      toColor
+    });
+  }
+  return edges;
+}
+function computeMilestones(vizData, progress) {
+  return vizData.milestones.map((m) => ({
+    normalizedTime: m.normalizedTime,
+    label: m.label,
+    visible: progress >= m.normalizedTime
+  }));
+}
+var LABEL_FADE_ZONE = 5e-3;
+function computePhaseLabelOpacity(progress, startNormalized, endNormalized, isLast = false) {
+  const upperBound = isLast ? 1 : endNormalized;
+  if (progress < startNormalized || progress > upperBound) return 0;
+  const fadeIn = Math.min((progress - startNormalized) / LABEL_FADE_ZONE, 1);
+  const fadeOut = isLast ? 1 : Math.min((endNormalized - progress) / LABEL_FADE_ZONE, 1);
+  return Math.min(fadeIn, fadeOut);
+}
+function computeAllPhases(phases, progress) {
+  return phases.map((p, i) => ({
+    id: p.id,
+    name: p.name,
+    startNormalized: p.startNormalized,
+    endNormalized: p.endNormalized,
+    color: p.color,
+    labelOpacity: computePhaseLabelOpacity(
+      progress,
+      p.startNormalized,
+      p.endNormalized,
+      i === phases.length - 1
+    )
+  }));
+}
+function smoothstep(t) {
+  const x = Math.max(0, Math.min(1, t));
+  return x * x * (3 - 2 * x);
+}
+function computeTrustLevel(keyframes, progress) {
+  if (keyframes.length === 0) return 0.5;
+  if (progress <= keyframes[0].normalizedTime) {
+    return keyframes[0].level;
+  }
+  if (progress >= keyframes[keyframes.length - 1].normalizedTime) {
+    return keyframes[keyframes.length - 1].level;
+  }
+  for (let i = 0; i < keyframes.length - 1; i++) {
+    const a = keyframes[i];
+    const b = keyframes[i + 1];
+    if (progress >= a.normalizedTime && progress <= b.normalizedTime) {
+      const t = (progress - a.normalizedTime) / (b.normalizedTime - a.normalizedTime);
+      return a.level + (b.level - a.level) * smoothstep(t);
+    }
+  }
+  return keyframes[keyframes.length - 1].level;
+}
+function computeMaxTotalWork(agents, progress, events) {
+  let max = 1;
+  for (const agent of agents) {
+    const work = computeTotalWork(agent.id, progress, events);
+    if (work > max) max = work;
+  }
+  return max;
+}
+function getFrameState(progress, vizData, layoutContext) {
+  const p = Math.max(0, Math.min(1, progress));
+  const tw = computeTimeWindows(vizData.timeRange.durationMs);
+  const maxTotalWork = computeMaxTotalWork(vizData.agents, p, vizData.events);
+  const agents = [];
+  for (const agent of vizData.agents) {
+    const state = computeAgentState(agent, p, vizData.events, maxTotalWork, layoutContext);
+    if (state) agents.push(state);
+  }
+  const particles = computeParticles(vizData.agents, vizData.events, p, tw.particleWindow);
+  const quotePills = computeQuotePills(
+    vizData.quotes,
+    p,
+    vizData.agents,
+    agents,
+    layoutContext,
+    tw.narrationWindow,
+    tw.narrationWindowDense,
+    tw.narrationClusterThreshold
+  );
+  const phase = computePhase(vizData.phases, p);
+  const stats = computeStats(vizData.events, agents, p);
+  const commitDots = computeCommitDots(vizData.events, p);
+  const MIN_GAP_PX = 3;
+  const timeWidth = layoutContext?.timeWidth;
+  const minGapNorm = layoutContext && layoutContext.viewportPxWidth > 0 && timeWidth && timeWidth > 0 ? MIN_GAP_PX / (layoutContext.viewportPxWidth / layoutContext.worldWidth * timeWidth) : void 0;
+  const minBarWidthNorm = layoutContext?.minBarWidthNorm;
+  const prBars = packPRRows(
+    computePRBars(vizData.agents, vizData.events, p),
+    p,
+    minGapNorm,
+    minBarWidthNorm
+  );
+  const artifactBars = packArtifactRows(
+    computeArtifactBars(vizData.agents, vizData.events, p),
+    p,
+    minGapNorm,
+    minBarWidthNorm
+  );
+  const edges = computeEdges(vizData.agents, vizData.events, p);
+  const visibleMilestones = computeMilestones(vizData, p);
+  const allPhases = computeAllPhases(vizData.phases, p);
+  const editorialNarration = computeEditorialNarration(vizData.editorialNarration ?? [], p);
+  const trustLevel = computeTrustLevel(vizData.trustKeyframes ?? [], p);
+  const totalHours = vizData.timeRange.durationMs / (1e3 * 60 * 60);
+  const currentHours = totalHours * p;
+  return {
+    projectTitle: vizData.projectTitle ?? "miriad-viz",
+    progress: p,
+    agents,
+    particles,
+    quotePills,
+    editorialNarration,
+    phase,
+    stats,
+    commitDots,
+    prBars,
+    artifactBars,
+    edges,
+    visibleMilestones,
+    allPhases,
+    trustLevel,
+    totalHours,
+    currentHours
+  };
+}
+
+// src/processing/process-data.ts
+function deriveCommitType(message) {
+  if (!message) return "other";
+  const match = message.match(/^(\w+)(?:\([^)]*\))?:/);
+  return match ? match[1].toLowerCase() : "other";
+}
+var TIMELINE_TAIL_FRACTION = 0.02;
+function deriveTimeRange(rawData, curationData, options) {
+  const timestamps = [];
+  for (const c of rawData.commits) timestamps.push(c.timestamp);
+  for (const p of rawData.prs) {
+    timestamps.push(p.createdAt);
+    if (p.mergedAt) timestamps.push(p.mergedAt);
+  }
+  for (const m of rawData.messages) timestamps.push(m.timestamp);
+  for (const a of rawData.agents) timestamps.push(a.joinedAt);
+  for (const p of curationData.phases) {
+    timestamps.push(p.startTime);
+    timestamps.push(p.endTime);
+  }
+  for (const m of curationData.milestones) timestamps.push(m.timestamp);
+  for (const q of curationData.quotes) timestamps.push(q.timestamp);
+  if (timestamps.length === 0) {
+    throw new Error("processData: no timestamps found in data \u2014 cannot derive time range");
+  }
+  const dataStart = Math.min(...timestamps);
+  const dataEnd = Math.max(...timestamps);
+  const padStartMs = options?.padStartMs ?? 0;
+  const padEndMs = options?.padEndMs ?? 0;
+  const start = dataStart - padStartMs;
+  const end = dataEnd + padEndMs;
+  const rawDuration = end - start;
+  const ONE_HOUR_MS = 36e5;
+  const effectiveDuration = rawDuration > 0 ? rawDuration : ONE_HOUR_MS;
+  const durationMs = effectiveDuration * (1 + TIMELINE_TAIL_FRACTION);
+  return { start, end, durationMs };
+}
+function buildAgents(rawData) {
+  return rawData.agents.map((agent) => ({
+    id: agent.id,
+    role: agent.role,
+    joinedAt: agent.joinedAt,
+    label: `@${agent.id}`
+  }));
+}
+function mergeEvents(rawData, curationData) {
+  const events = [];
+  for (const agent of rawData.agents) {
+    events.push({
+      timestamp: agent.joinedAt,
+      type: "agent_join",
+      agent: agent.id,
+      metadata: { role: agent.role }
+    });
+  }
+  for (const commit of rawData.commits) {
+    events.push({
+      timestamp: commit.timestamp,
+      type: "commit",
+      agent: commit.agent,
+      metadata: {
+        sha: commit.sha,
+        filesChanged: commit.filesChanged,
+        insertions: commit.insertions,
+        deletions: commit.deletions,
+        prNumber: commit.prNumber,
+        commitType: deriveCommitType(commit.message)
+      }
+    });
+  }
+  for (const pr of rawData.prs) {
+    events.push({
+      timestamp: pr.createdAt,
+      type: "pr_created",
+      agent: pr.agent,
+      metadata: {
+        prNumber: pr.number,
+        title: pr.title,
+        additions: pr.additions,
+        deletions: pr.deletions
+      }
+    });
+    if (pr.mergedAt) {
+      events.push({
+        timestamp: pr.mergedAt,
+        type: "pr_merged",
+        agent: pr.agent,
+        metadata: {
+          prNumber: pr.number,
+          title: pr.title
+        }
+      });
+    }
+  }
+  for (const msg of rawData.messages) {
+    events.push({
+      timestamp: msg.timestamp,
+      type: "message",
+      agent: msg.sender,
+      targetAgent: msg.mentions[0],
+      // primary target
+      metadata: {
+        mentions: msg.mentions
+      }
+    });
+  }
+  for (const milestone of curationData.milestones) {
+    events.push({
+      timestamp: milestone.timestamp,
+      type: "milestone",
+      agent: "",
+      // milestones aren't agent-specific
+      metadata: {
+        label: milestone.label,
+        phase: milestone.phase
+      }
+    });
+  }
+  for (const artifact of rawData.artifacts) {
+    events.push({
+      timestamp: artifact.createdAt,
+      type: "artifact",
+      agent: artifact.agent ?? "",
+      metadata: {
+        slug: artifact.slug,
+        type: artifact.type
+      }
+    });
+  }
+  events.sort((a, b) => a.timestamp - b.timestamp);
+  return events;
+}
+var PHASE_COLORS = [
+  "#3b82f6",
+  // blue
+  "#ef4444",
+  // red
+  "#f59e0b",
+  // amber
+  "#8b5cf6",
+  // purple
+  "#10b981",
+  // emerald
+  "#ec4899",
+  // pink
+  "#f97316",
+  // orange
+  "#06b6d4"
+  // cyan
+];
+function mapPhases(curationData, timeRange) {
+  const phases = curationData.phases;
+  if (phases.length === 0) return [];
+  return phases.map((p, i) => ({
+    id: p.id,
+    name: p.name,
+    startTime: i === 0 ? Math.min(p.startTime, timeRange.start) : p.startTime,
+    endTime: i === phases.length - 1 ? Math.max(p.endTime, timeRange.end) : p.endTime,
+    color: PHASE_COLORS[i % PHASE_COLORS.length]
+  }));
+}
+function mapQuotes(curationData) {
+  return curationData.quotes.map((q) => ({
+    text: q.text,
+    speaker: q.speaker,
+    timestamp: q.timestamp,
+    phase: q.phase,
+    ...q.emoji && { emoji: q.emoji },
+    ...q.mood && { mood: q.mood }
+  }));
+}
+function mapMilestones(curationData) {
+  return curationData.milestones.map((m) => ({
+    label: m.label,
+    timestamp: m.timestamp,
+    phase: m.phase
+  }));
+}
+function mapTrustKeyframes(curationData) {
+  return curationData.trustKeyframes.map((k) => ({
+    timestamp: k.timestamp,
+    level: k.level,
+    label: k.label
+  }));
+}
+var DEFAULT_PHASE_COLOR = "#6b7280";
+function buildEditorialNarration(durationMs, curationData) {
+  if (durationMs <= 0) return [];
+  if (curationData.editorialNarration && curationData.editorialNarration.length > 0) {
+    const timeRangeStart = deriveTimeRangeStart(curationData);
+    return curationData.editorialNarration.map((entry) => ({
+      normalizedTime: Math.max(0, Math.min(1, (entry.timestamp - timeRangeStart) / durationMs)),
+      phaseTitle: entry.phaseTitle,
+      phaseColor: entry.phaseColor,
+      text: entry.text,
+      type: entry.type
+    })).sort((a, b) => a.normalizedTime - b.normalizedTime);
+  }
+  return buildGenericNarration(durationMs, curationData);
+}
+function deriveTimeRangeStart(curationData) {
+  if (curationData.phases.length === 0) return 0;
+  return Math.min(...curationData.phases.map((p) => p.startTime));
+}
+function buildGenericNarration(durationMs, curationData) {
+  if (curationData.phases.length === 0) return [];
+  const timeRangeStart = deriveTimeRangeStart(curationData);
+  return curationData.phases.map((phase) => ({
+    normalizedTime: Math.max(0, Math.min(1, (phase.startTime - timeRangeStart) / durationMs)),
+    phaseTitle: phase.name.toUpperCase(),
+    phaseColor: DEFAULT_PHASE_COLOR,
+    text: phase.name,
+    type: "phase"
+  })).sort((a, b) => a.normalizedTime - b.normalizedTime);
+}
+function processData(rawData, curationData, options) {
+  const timeRange = deriveTimeRange(rawData, curationData, options);
+  const agents = buildAgents(rawData);
+  const events = mergeEvents(rawData, curationData);
+  const phases = mapPhases(curationData, timeRange);
+  const quotes = mapQuotes(curationData);
+  const milestones = mapMilestones(curationData);
+  const trustKeyframes = mapTrustKeyframes(curationData);
+  const editorialNarration = buildEditorialNarration(timeRange.durationMs, curationData);
+  return {
+    projectTitle: rawData.project.name,
+    agents,
+    events,
+    phases,
+    quotes,
+    milestones,
+    trustKeyframes,
+    editorialNarration,
+    timeRange,
+    stats: {
+      totalCommits: rawData.commits.length,
+      totalPRs: rawData.prs.length,
+      totalMessages: rawData.messages.length,
+      totalAgents: rawData.agents.length
+    }
+  };
+}
+
+// src/processing/agent-layout.ts
+var MARGIN = 0.04;
+var MIN_Y_GAP = 0.08;
+var MIN_X_GAP = 0.12;
+var DEFAULT_BAND_ASPECT = 5;
+var PHI = (1 + Math.sqrt(5)) / 2;
+var JITTER_AMP = 3;
+function computeAgentPositions(agents, messages, optsOrMinYGap) {
+  const opts = typeof optsOrMinYGap === "number" ? { minYGapNorm: optsOrMinYGap } : optsOrMinYGap ?? {};
+  if (agents.length === 0) return /* @__PURE__ */ new Map();
+  if (agents.length === 1) {
+    return /* @__PURE__ */ new Map([[agents[0].id, { x: 0.5, y: 0.5 }]]);
+  }
+  if (agents.length === 2) {
+    const [a, b] = agents;
+    const humanFirst = a.role === "human" ? [a, b] : b.role === "human" ? [b, a] : [a, b];
+    return /* @__PURE__ */ new Map([
+      [humanFirst[0].id, { x: 0.35, y: 0.45 }],
+      [humanFirst[1].id, { x: 0.65, y: 0.55 }]
+    ]);
+  }
+  const bandAspect = opts.bandAspect ?? DEFAULT_BAND_ASPECT;
+  const minYGap = Math.max(MIN_Y_GAP, opts.minYGapNorm ?? MIN_Y_GAP);
+  const minXGap = opts.minXGapNorm ?? Math.max(MIN_X_GAP, minYGap / bandAspect);
+  const adjacency = buildAdjacency(agents, messages);
+  const ordered = orderAgents(agents, adjacency);
+  const { cols, rows } = computeGridDims(ordered.length, minXGap, minYGap);
+  const positions = assignGridPositions(ordered, cols, rows, minXGap, minYGap);
+  return positions;
+}
+function orderAgents(agents, adjacency) {
+  const humans = [];
+  const coordination = [];
+  const support = [];
+  const builders = [];
+  for (const agent of agents) {
+    switch (agent.role) {
+      case "human":
+        humans.push(agent);
+        break;
+      case "lead":
+      case "pm":
+      case "reviewer":
+        coordination.push(agent);
+        break;
+      case "ideation":
+      case "researcher":
+      case "tester":
+      case "auditor":
+        support.push(agent);
+        break;
+      default:
+        builders.push(agent);
+        break;
+    }
+  }
+  const orderedCoord = orderByCliques(coordination, adjacency);
+  const orderedSupport = orderByCliques(support, adjacency);
+  const orderedBuilders = orderByCliques(builders, adjacency);
+  return [...humans, ...orderedCoord, ...orderedSupport, ...orderedBuilders];
+}
+function orderByCliques(agents, adjacency) {
+  if (agents.length === 0) return [];
+  const cliques = findCliques(agents, adjacency);
+  return cliques.flat();
+}
+function computeGridDims(n, minXGap, minYGap) {
+  const usable = 1 - 2 * MARGIN;
+  const maxCols = Math.max(1, Math.floor(usable / minXGap) + 1);
+  const maxRows = Math.max(1, Math.floor(usable / minYGap) + 1);
+  let bestCols = Math.min(maxCols, n);
+  let bestRows = 1;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  for (let r = 1; r <= Math.min(maxRows, n); r++) {
+    const c = Math.ceil(n / r);
+    if (c > maxCols) continue;
+    if (c * r < n) continue;
+    const waste = c * r - n;
+    const oddRowBonus = r % 2 === 1 ? 5 : 0;
+    const ratio = c / r;
+    const balanceScore = -Math.abs(Math.log(ratio)) * 5;
+    const score = oddRowBonus + balanceScore - waste;
+    if (score > bestScore) {
+      bestScore = score;
+      bestCols = c;
+      bestRows = r;
+    }
+  }
+  return { cols: bestCols, rows: bestRows };
+}
+function assignGridPositions(agents, cols, rows, minXGap, minYGap) {
+  const positions = /* @__PURE__ */ new Map();
+  const usable = 1 - 2 * MARGIN;
+  const slots = spiralOrder(cols, rows);
+  const COMPRESS_PAD = 1.4;
+  const effectiveCols = cols > 1 && rows > 1 ? cols - 0.5 : Math.max(1, cols - 1);
+  const fullSpreadX = cols > 1 ? usable / effectiveCols : 0;
+  const fullSpreadY = rows > 1 ? usable / (rows - 1) : 0;
+  const xStep = cols > 1 ? Math.min(fullSpreadX, minXGap * COMPRESS_PAD) : 0;
+  const yStep = rows > 1 ? Math.min(fullSpreadY, minYGap * COMPRESS_PAD) : 0;
+  const useHex = cols > 1 && rows > 1;
+  const staggerX = useHex ? xStep * 0.5 : 0;
+  const gridWidth = cols > 1 ? (cols - 1) * xStep + staggerX : 0;
+  const gridHeight = rows > 1 ? (rows - 1) * yStep : 0;
+  const xOrigin = Math.max(MARGIN, 0.5 - gridWidth / 2);
+  const yOrigin = Math.max(MARGIN, 0.5 - gridHeight / 2);
+  const maxJitterX = cols > 1 ? Math.max(0, (xStep - minXGap) * 0.6) : 0;
+  const maxJitterY = rows > 1 ? Math.max(0, (yStep - minYGap) * 0.6) : 0;
+  for (let i = 0; i < agents.length && i < slots.length; i++) {
+    const { col, row } = slots[i];
+    let x = cols > 1 ? xOrigin + col * xStep : 0.5;
+    let y = rows > 1 ? yOrigin + row * yStep : 0.5;
+    if (row % 2 === 0 && cols > 1) {
+      x += staggerX;
+    }
+    const EDGE_ZONE = 0.15;
+    const edgeDampX = Math.min((x - MARGIN) / EDGE_ZONE, (1 - MARGIN - x) / EDGE_ZONE, 1);
+    const edgeDampY = Math.min((y - MARGIN) / EDGE_ZONE, (1 - MARGIN - y) / EDGE_ZONE, 1);
+    const dampX = Math.max(0, edgeDampX);
+    const dampY = Math.max(0, edgeDampY);
+    const jitterX = (i * PHI % 1 - 0.5) * 2 * maxJitterX * JITTER_AMP * dampX;
+    const jitterY = (i * PHI * PHI % 1 - 0.5) * 2 * maxJitterY * JITTER_AMP * dampY;
+    x += jitterX;
+    y += jitterY;
+    x = Math.max(MARGIN, Math.min(1 - MARGIN, x));
+    y = Math.max(MARGIN, Math.min(1 - MARGIN, y));
+    positions.set(agents[i].id, { x, y });
+  }
+  return positions;
+}
+function spiralOrder(cols, rows) {
+  const centerCol = (cols - 1) / 2;
+  const centerRow = (rows - 1) / 2;
+  const cells = [];
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const dx = c - centerCol;
+      const dy = r - centerRow;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      const angle = Math.atan2(dy, dx);
+      cells.push({ col: c, row: r, dist, angle });
+    }
+  }
+  cells.sort((a, b) => {
+    if (Math.abs(a.dist - b.dist) > 0.01) return a.dist - b.dist;
+    return a.angle - b.angle;
+  });
+  return cells;
+}
+function buildAdjacency(agents, messages) {
+  const agentIds = new Set(agents.map((a) => a.id));
+  const adj = /* @__PURE__ */ new Map();
+  for (const agent of agents) {
+    adj.set(agent.id, /* @__PURE__ */ new Map());
+  }
+  for (const msg of messages) {
+    if (!agentIds.has(msg.sender)) continue;
+    for (const mention of msg.mentions) {
+      if (!agentIds.has(mention)) continue;
+      if (mention === msg.sender) continue;
+      const senderMap = adj.get(msg.sender);
+      senderMap.set(mention, (senderMap.get(mention) ?? 0) + 1);
+      const mentionMap = adj.get(mention);
+      mentionMap.set(msg.sender, (mentionMap.get(msg.sender) ?? 0) + 1);
+    }
+  }
+  return adj;
+}
+function findCliques(agents, adjacency) {
+  const agentSet = new Set(agents.map((a) => a.id));
+  const visited = /* @__PURE__ */ new Set();
+  const cliques = [];
+  const agentMap = new Map(agents.map((a) => [a.id, a]));
+  const sorted = [...agents].sort((a, b) => a.joinedAt - b.joinedAt);
+  for (const agent of sorted) {
+    if (visited.has(agent.id)) continue;
+    const clique = [];
+    const queue = [agent.id];
+    visited.add(agent.id);
+    while (queue.length > 0) {
+      const current = queue.shift();
+      clique.push(agentMap.get(current));
+      const neighbors = adjacency.get(current);
+      if (!neighbors) continue;
+      for (const [neighborId] of neighbors) {
+        if (!agentSet.has(neighborId)) continue;
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+        queue.push(neighborId);
+      }
+    }
+    cliques.push(clique);
+  }
+  cliques.sort((a, b) => {
+    if (b.length !== a.length) return b.length - a.length;
+    return Math.min(...a.map((x) => x.joinedAt)) - Math.min(...b.map((x) => x.joinedAt));
+  });
+  for (const clique of cliques) {
+    clique.sort((a, b) => {
+      const wA = totalWeight(a.id, adjacency);
+      const wB = totalWeight(b.id, adjacency);
+      if (wB !== wA) return wB - wA;
+      return a.joinedAt - b.joinedAt;
+    });
+  }
+  return cliques;
+}
+function totalWeight(agentId, adjacency) {
+  const neighbors = adjacency.get(agentId);
+  if (!neighbors) return 0;
+  let total = 0;
+  for (const [, weight] of neighbors) {
+    total += weight;
+  }
+  return total;
+}
+function computeLayoutPositions(raw, optsOrMinYGap) {
+  const agents = raw.agents.map((a) => ({
+    id: a.id,
+    role: a.role,
+    joinedAt: a.joinedAt
+  }));
+  const messages = raw.events.filter((e) => e.type === "message" && e.targetAgent).map((e) => ({
+    sender: e.agent,
+    mentions: [e.targetAgent]
+  }));
+  return computeAgentPositions(agents, messages, optsOrMinYGap);
+}
+
+// src/processing/enrich.ts
+var HUMAN_COLOR = "#ff922b";
+var AGENT_PALETTE = [
+  "#ff6b6b",
+  // coral red
+  "#ff4da6",
+  // hot pink
+  "#ffd93d",
+  // gold
+  "#4d96ff",
+  // sky blue
+  "#ff8c42",
+  // tangerine
+  "#00e5cc",
+  // cyan
+  "#7c5cfc",
+  // purple
+  "#22d3ee",
+  // light cyan
+  "#10b981",
+  // emerald
+  "#a78bfa",
+  // lavender
+  "#6bcb77",
+  // green
+  "#c084fc",
+  // violet
+  "#f472b6"
+  // pink
+];
+function getAgentColor(_id, role, index) {
+  if (role === "human") return HUMAN_COLOR;
+  return AGENT_PALETTE[index % AGENT_PALETTE.length];
+}
+function getAgentRadius(role) {
+  return role === "human" ? 0.04 : 0.03;
+}
+function normalize(timestamp, start, durationMs) {
+  return (timestamp - start) / durationMs;
+}
+function enrichVizData(raw, layoutOpts) {
+  const { start, end } = raw.timeRange;
+  const rawDuration = end - start;
+  const expectedDuration = rawDuration * (1 + TIMELINE_TAIL_FRACTION);
+  const durationMs = raw.timeRange.durationMs < expectedDuration * 0.99 ? expectedDuration : raw.timeRange.durationMs;
+  const positions = computeLayoutPositions(raw, layoutOpts);
+  const agents = raw.agents.map((a, i) => ({
+    id: a.id,
+    role: a.role,
+    color: getAgentColor(a.id, a.role, i),
+    position: positions.get(a.id) ?? { x: 0.5, y: 0.5 },
+    radius: getAgentRadius(a.role),
+    label: a.label
+  }));
+  const events = raw.events.map((e) => ({
+    ...e,
+    normalizedTime: normalize(e.timestamp, start, durationMs)
+  }));
+  const phases = raw.phases.map((p) => ({
+    id: p.id,
+    name: p.name,
+    startNormalized: normalize(p.startTime, start, durationMs),
+    endNormalized: normalize(p.endTime, start, durationMs),
+    color: p.color
+  }));
+  const quotes = raw.quotes.map((q) => ({
+    text: q.text,
+    speaker: q.speaker,
+    normalizedTime: normalize(q.timestamp, start, durationMs),
+    phase: q.phase,
+    ...q.emoji && { emoji: q.emoji },
+    ...q.mood && { mood: q.mood }
+  }));
+  const milestones = raw.milestones.map((m) => ({
+    label: m.label,
+    normalizedTime: normalize(m.timestamp, start, durationMs),
+    phase: m.phase
+  }));
+  const trustKeyframes = raw.trustKeyframes.map((k) => ({
+    normalizedTime: normalize(k.timestamp, start, durationMs),
+    level: k.level,
+    label: k.label
+  }));
+  const durationChanged = durationMs !== raw.timeRange.durationMs;
+  const editorialNarration = durationChanged && raw.editorialNarration ? raw.editorialNarration.map((entry) => ({
+    ...entry,
+    normalizedTime: entry.normalizedTime * (raw.timeRange.durationMs / durationMs)
+  })) : raw.editorialNarration ?? [];
+  return {
+    projectTitle: raw.projectTitle ?? "miriad-viz",
+    agents,
+    events,
+    phases,
+    quotes,
+    milestones,
+    trustKeyframes,
+    editorialNarration,
+    timeRange: { start, end, durationMs },
+    stats: raw.stats
+  };
+}
+
+// src/transform/transform-raw.ts
+function inferRole(roleString) {
+  const s = roleString.toLowerCase();
+  if (s.includes("human") || s === "user") return "human";
+  if (s.includes("lead")) return "lead";
+  if (s.includes("pm")) return "pm";
+  if (s.includes("tester") || s.includes("qa")) return "tester";
+  if (s.includes("reviewer") || s.includes("review")) return "reviewer";
+  if (s.includes("auditor") || s.includes("audit")) return "auditor";
+  if (s.includes("challenger") || s.includes("challenge")) return "challenger";
+  if (s.includes("scout")) return "scout";
+  if (s.includes("ideation")) return "ideation";
+  if (s.includes("research")) return "researcher";
+  if (s.includes("builder") || s.includes("build")) return "builder";
+  return "builder";
+}
+function transformToRawData(sources) {
+  const defaultAgent = sources.retroPageData.teamAssembly[0]?.agent.replace("@", "") ?? "unknown";
+  return {
+    project: {
+      name: sources.retroPageData.meta.title,
+      description: sources.retroPageData.meta.subtitle
+    },
+    agents: transformAgents(
+      sources.retroPageData,
+      sources.chatActivity.agentTotals,
+      sources.timelineEvents
+    ),
+    commits: transformCommits(sources.commits, sources.prAgentMap, defaultAgent),
+    prs: transformPRs(sources.prs, sources.prAgentMap),
+    messages: transformMessages(sources.timelineEvents),
+    artifacts: sources.artifactData ? transformArtifacts(
+      sources.artifactData,
+      sources.retroPageData,
+      sources.prs,
+      sources.prAgentMap
+    ) : []
+  };
+}
+function buildFirstMessageTimeMap(timelineEvents) {
+  const map = /* @__PURE__ */ new Map();
+  if (!timelineEvents) return map;
+  for (const evt of timelineEvents.events) {
+    if (evt.type !== "message" && evt.type !== "beam") continue;
+    const sender = evt.from;
+    const ts = new Date(evt.t).getTime();
+    const existing = map.get(sender);
+    if (existing === void 0 || ts < existing) {
+      map.set(sender, ts);
+    }
+  }
+  return map;
+}
+function transformAgents(retroData, agentTotals, timelineEvents, agentRoles) {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  const firstMessageTime = buildFirstMessageTimeMap(timelineEvents);
+  const assemblyRoles = /* @__PURE__ */ new Map();
+  for (const entry of retroData.teamAssembly) {
+    const id = entry.agent.replace("@", "");
+    assemblyRoles.set(id, entry.role);
+  }
+  function resolveRole(id) {
+    const assemblyRole = assemblyRoles.get(id);
+    if (assemblyRole) {
+      return inferRole(assemblyRole);
+    }
+    return "builder";
+  }
+  function resolveJoinedAt(id, assemblyTime) {
+    const msgTime = firstMessageTime.get(id);
+    if (msgTime !== void 0 && assemblyTime !== void 0) {
+      return Math.min(msgTime, assemblyTime);
+    }
+    if (msgTime !== void 0) return msgTime;
+    if (assemblyTime !== void 0) return assemblyTime;
+    return new Date(retroData.meta.startDate).getTime();
+  }
+  for (const entry of retroData.teamAssembly) {
+    const id = entry.agent.replace("@", "");
+    if (seen.has(id)) continue;
+    seen.add(id);
+    agents.push({
+      id,
+      role: resolveRole(id),
+      joinedAt: resolveJoinedAt(id, new Date(entry.time).getTime())
+    });
+  }
+  for (const id of Object.keys(agentTotals)) {
+    if (seen.has(id)) continue;
+    agents.push({
+      id,
+      role: resolveRole(id),
+      joinedAt: resolveJoinedAt(id)
+    });
+    seen.add(id);
+  }
+  return agents;
+}
+function transformCommits(commits, prAgentMap, defaultAgent = "unknown") {
+  return commits.map((c) => {
+    const agent = resolveCommitAgent(c, prAgentMap, defaultAgent);
+    return {
+      sha: c.hash,
+      timestamp: new Date(c.date).getTime(),
+      agent,
+      message: c.subject,
+      filesChanged: c.files.length,
+      insertions: c.totalInsertions,
+      deletions: c.totalDeletions,
+      prNumber: c.prNumber ?? void 0
+    };
+  });
+}
+function resolveCommitAgent(commit, prAgentMap, defaultAgent = "unknown") {
+  if (commit.prNumber != null) {
+    const agent = prAgentMap[String(commit.prNumber)];
+    if (agent) return agent;
+  }
+  const mergeMatch = commit.subject.match(/^Merge pull request #(\d+)/);
+  if (mergeMatch) {
+    const agent = prAgentMap[mergeMatch[1]];
+    if (agent) return agent;
+  }
+  const suffixMatch = commit.subject.match(/\(#(\d+)\)\s*$/);
+  if (suffixMatch) {
+    const agent = prAgentMap[suffixMatch[1]];
+    if (agent) return agent;
+  }
+  return defaultAgent;
+}
+function transformPRs(prs, prAgentMap) {
+  return prs.map((pr) => {
+    const agent = prAgentMap[String(pr.number)] ?? "unknown";
+    return {
+      number: pr.number,
+      title: pr.title,
+      agent,
+      createdAt: new Date(pr.createdAt).getTime(),
+      mergedAt: pr.mergedAt ? new Date(pr.mergedAt).getTime() : null,
+      additions: pr.additions,
+      deletions: pr.deletions,
+      branch: pr.headRefName
+    };
+  });
+}
+function inferArtifactType(slug) {
+  if (slug.includes(".app.") || slug.endsWith(".ts") || slug.endsWith(".js")) return "code";
+  if (slug.includes("screenshot") || slug.includes("qa-")) return "asset";
+  if (slug.includes("decision")) return "decision";
+  if (slug.includes("task") || slug.includes("phase-")) return "task";
+  if (slug.startsWith("spec-") || slug.startsWith("spec")) return "doc";
+  if (slug.includes("concept")) return "doc";
+  return "doc";
+}
+function resolveArtifactAgent(slug, prAgentMap, createdBy, defaultAgent) {
+  if (createdBy) return createdBy;
+  const prMatch = slug.match(/#?(\d+)/);
+  if (prMatch) {
+    const agent = prAgentMap[prMatch[1]];
+    if (agent) return agent;
+  }
+  return defaultAgent;
+}
+var CATEGORY_TYPE_MAP = {
+  qaScreenshots: "asset",
+  transitionSpecs: "doc",
+  transitionConcepts: "doc",
+  scenes: "doc",
+  vizConcepts: "code",
+  teamPrinciples: "doc",
+  retroData: "doc",
+  decisions: "decision"
+};
+function distributeTimestamps(count, bounds, prTimestamps) {
+  const phasePRTimes = prTimestamps.filter((t) => t >= bounds.start && t <= bounds.end);
+  const timestamps = [];
+  for (let i = 0; i < count; i++) {
+    let timestamp;
+    if (phasePRTimes.length > 0) {
+      const prIdx = i % phasePRTimes.length;
+      timestamp = phasePRTimes[prIdx] + i * 6e4;
+    } else {
+      const fraction = count > 1 ? i / (count - 1) : 0.5;
+      timestamp = bounds.start + fraction * (bounds.end - bounds.start);
+    }
+    timestamps.push(Math.round(Math.max(bounds.start, Math.min(bounds.end, timestamp))));
+  }
+  return timestamps;
+}
+function buildCategoryDistribution(categories) {
+  const entries = [];
+  let total = 0;
+  for (const [categoryName, categoryData] of Object.entries(categories)) {
+    if (categoryData.count === 0) continue;
+    entries.push({
+      type: CATEGORY_TYPE_MAP[categoryName] ?? "doc",
+      count: categoryData.count
+    });
+    total += categoryData.count;
+  }
+  if (total === 0) return [{ type: "doc", weight: 1 }];
+  return entries.sort((a, b) => b.count - a.count).map((e) => ({ type: e.type, weight: e.count / total }));
+}
+function buildCreatedByLookup(categories) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const categoryData of Object.values(categories)) {
+    for (const item of categoryData.items ?? []) {
+      if (typeof item === "object" && item.createdBy) {
+        lookup.set(item.slug, item.createdBy);
+      }
+    }
+  }
+  return lookup;
+}
+function transformArtifacts(artifactData, retroData, prs, prAgentMap) {
+  const artifacts = [];
+  const agentIds = retroData.teamAssembly.map((e) => e.agent.replace("@", ""));
+  const defaultAgent = agentIds[0] ?? "unknown";
+  const phaseBoundaries = retroData.phases.map((p) => ({
+    start: new Date(p.start).getTime(),
+    end: new Date(p.end).getTime()
+  }));
+  const prTimestamps = prs.map((pr) => new Date(pr.createdAt).getTime()).sort((a, b) => a - b);
+  const distribution = buildCategoryDistribution(artifactData.categories);
+  const createdByLookup = buildCreatedByLookup(artifactData.categories);
+  let phaseIndex = 0;
+  let globalBulkIndex = 0;
+  for (const [_phaseName, phaseData] of Object.entries(artifactData.phases)) {
+    if (phaseIndex >= phaseBoundaries.length) break;
+    const bounds = phaseBoundaries[phaseIndex];
+    phaseIndex++;
+    const totalCount = phaseData.count;
+    const slugs = phaseData.artifacts;
+    const bulkCount = Math.max(0, totalCount - slugs.length);
+    const timestamps = distributeTimestamps(totalCount, bounds, prTimestamps);
+    let tsIdx = 0;
+    for (const slug of slugs) {
+      artifacts.push({
+        slug,
+        type: inferArtifactType(slug),
+        createdAt: timestamps[tsIdx],
+        updatedAt: timestamps[tsIdx],
+        agent: resolveArtifactAgent(slug, prAgentMap, createdByLookup.get(slug), defaultAgent)
+      });
+      tsIdx++;
+    }
+    let distIdx = 0;
+    let distBudget = Math.round(distribution[0].weight * bulkCount);
+    for (let i = 0; i < bulkCount; i++) {
+      while (distBudget <= 0 && distIdx < distribution.length - 1) {
+        distIdx++;
+        distBudget = Math.round(distribution[distIdx].weight * bulkCount);
+      }
+      distBudget--;
+      const entry = distribution[distIdx];
+      const agent = agentIds.length > 0 ? agentIds[globalBulkIndex % agentIds.length] : defaultAgent;
+      artifacts.push({
+        slug: `phase${phaseIndex}-${entry.type}-${String(globalBulkIndex + 1).padStart(3, "0")}`,
+        type: entry.type,
+        createdAt: timestamps[tsIdx],
+        updatedAt: timestamps[tsIdx],
+        agent
+      });
+      tsIdx++;
+      globalBulkIndex++;
+    }
+  }
+  artifacts.sort((a, b) => a.createdAt - b.createdAt);
+  return artifacts;
+}
+function transformMessages(timelineEvents) {
+  const messageEvents = timelineEvents.events.filter(
+    (e) => e.type === "message" || e.type === "beam"
+  );
+  return messageEvents.map((evt, i) => ({
+    id: `msg-${String(i).padStart(4, "0")}`,
+    timestamp: new Date(evt.t).getTime(),
+    sender: evt.from,
+    mentions: [evt.to]
+  }));
+}
+
+// src/transform/transform-curation.ts
+function transformToCurationData(sources) {
+  const narration = transformNarration(sources.retroPageData);
+  return {
+    phases: transformPhases(sources.retroPageData),
+    quotes: transformQuotes(sources.retroPageData, sources.retroPageQuotes),
+    milestones: transformMilestones(sources.retroPageData),
+    trustKeyframes: transformTrustKeyframes(sources.retroPageData),
+    ...narration.length > 0 ? { editorialNarration: narration } : {}
+  };
+}
+function transformPhases(retroData) {
+  return retroData.phases.map((p) => ({
+    id: p.id,
+    name: p.name,
+    startTime: new Date(p.start).getTime(),
+    endTime: new Date(p.end).getTime()
+  }));
+}
+function transformMilestones(retroData) {
+  const phases = retroData.phases;
+  return retroData.milestones.map((m) => {
+    const milestoneTime = new Date(m.time).getTime();
+    const phase = findPhaseForTimestamp(milestoneTime, phases);
+    return {
+      label: m.label,
+      timestamp: milestoneTime,
+      phase: phase?.id ?? "unknown"
+    };
+  });
+}
+var CATEGORY_MOOD = {
+  theGood: "good",
+  theBad: "bad",
+  theUgly: "angry",
+  theFunny: "good"
+};
+var ADDITION_MOOD = {
+  good: "good",
+  bad: "bad",
+  ugly: "angry"
+};
+function transformQuotes(retroData, retroQuotes) {
+  const phases = retroData.phases;
+  const quotes = [];
+  const firstPhaseStart = phases[0]?.start;
+  const referenceYear = firstPhaseStart ? new Date(firstPhaseStart).getUTCFullYear() : (/* @__PURE__ */ new Date()).getUTCFullYear();
+  for (const [category, entries] of Object.entries(retroData.quotes)) {
+    if (!Array.isArray(entries)) continue;
+    const mood = CATEGORY_MOOD[category] ?? "good";
+    for (const entry of entries) {
+      const timestamp = parseInformalTimestamp(entry.time, referenceYear);
+      if (timestamp == null) continue;
+      const phase = findPhaseForTimestamp(timestamp, phases);
+      quotes.push({
+        text: entry.text,
+        speaker: entry.author.replace(/^@/, ""),
+        timestamp,
+        phase: phase?.id ?? "unknown",
+        mood
+      });
+    }
+  }
+  for (const [category, entries] of Object.entries(retroQuotes)) {
+    if (!Array.isArray(entries)) continue;
+    const mood = ADDITION_MOOD[category] ?? "good";
+    for (const entry of entries) {
+      const timestamp = parseInformalTimestamp(entry.timestamp, referenceYear);
+      if (timestamp == null) continue;
+      const phase = findPhaseForTimestamp(timestamp, phases);
+      quotes.push({
+        text: entry.text,
+        speaker: entry.author.replace(/^@/, ""),
+        timestamp,
+        phase: phase?.id ?? "unknown",
+        mood
+      });
+    }
+  }
+  quotes.sort((a, b) => a.timestamp - b.timestamp);
+  return quotes;
+}
+function transformTrustKeyframes(retroData) {
+  if (!retroData.trustArc || retroData.trustArc.length === 0) return [];
+  return retroData.trustArc.map((entry) => ({
+    timestamp: new Date(entry.time).getTime(),
+    level: entry.level / 100,
+    // normalize 0-100 → 0-1
+    label: entry.label
+  })).sort((a, b) => a.timestamp - b.timestamp);
+}
+var MONTH_ABBREVS = {
+  jan: 0,
+  feb: 1,
+  mar: 2,
+  apr: 3,
+  may: 4,
+  jun: 5,
+  jul: 6,
+  aug: 7,
+  sep: 8,
+  oct: 9,
+  nov: 10,
+  dec: 11
+};
+function transformNarration(retroData) {
+  if (!retroData.editorialNarration || retroData.editorialNarration.length === 0) return [];
+  return retroData.editorialNarration.map((entry) => ({
+    timestamp: new Date(entry.time).getTime(),
+    phaseTitle: entry.phaseTitle,
+    phaseColor: entry.phaseColor,
+    text: entry.text,
+    type: entry.type
+  })).sort((a, b) => a.timestamp - b.timestamp);
+}
+function parseInformalTimestamp(timeStr, referenceYear) {
+  if (!timeStr) return null;
+  const isoDate = new Date(timeStr);
+  if (!Number.isNaN(isoDate.getTime()) && timeStr.includes("-")) {
+    return isoDate.getTime();
+  }
+  const cleaned = timeStr.replace(/~/g, "").replace(/\(.*?\)/g, "").trim();
+  const match = cleaned.match(/([A-Za-z]{3})\s+(\d{1,2})(?:\s+(\d{1,2}):(\d{2}))?/);
+  if (!match) return null;
+  const monthIdx = MONTH_ABBREVS[match[1].toLowerCase()];
+  if (monthIdx === void 0) return null;
+  const day = Number.parseInt(match[2], 10);
+  const hour = match[3] ? Number.parseInt(match[3], 10) : 12;
+  const minute = match[4] ? Number.parseInt(match[4], 10) : 0;
+  const date = new Date(Date.UTC(referenceYear, monthIdx, day, hour, minute, 0));
+  return date.getTime();
+}
+function findPhaseForTimestamp(timestamp, phases) {
+  return phases.find((p) => {
+    const start = new Date(p.start).getTime();
+    const end = new Date(p.end).getTime();
+    return timestamp >= start && timestamp <= end;
+  });
+}
+
+// src/renderer/layout.ts
+var CONTENT_WIDTH = 10;
+var CONTENT_HEIGHT = 6;
+var CONTENT_ASPECT = CONTENT_WIDTH / CONTENT_HEIGHT;
+var DEFAULT_BAND_AGENTS = 0.55;
+var DEFAULT_BAND_ARTIFACTS = 0.08;
+var DEFAULT_BAND_PRS = 0.12;
+var DEFAULT_BAND_COMMITS = 0.12;
+var DEFAULT_BAND_TIMELINE = 0.07;
+var GAP_AGENTS_ARTIFACTS = 0.02;
+var GAP_ARTIFACTS_PRS = 0.02;
+var GAP_PRS_COMMITS = 0.015;
+var GAP_COMMITS_TIMELINE = 5e-3;
+function buildStackElements(worldHeight, textScale, bandProportions, gapScale) {
+  const labelRowH = computeLabelRowHeight(textScale);
+  const phaseBarRowH = worldHeight * 0.03;
+  const labelTextScaleCapped = Math.min(textScale, 1.5);
+  const playheadLabelZoneH = 0.06 + // playheadLabelOffsetY
+  0.4 * labelTextScaleCapped * (48 / 128) + // playheadLabelHeight
+  0.02;
+  const gap1 = worldHeight * GAP_AGENTS_ARTIFACTS * gapScale;
+  const gap2 = worldHeight * GAP_ARTIFACTS_PRS * gapScale;
+  const gap3 = worldHeight * GAP_PRS_COMMITS * gapScale;
+  const gap4 = worldHeight * GAP_COMMITS_TIMELINE * gapScale;
+  const fixedTotal = 4 * labelRowH + playheadLabelZoneH + phaseBarRowH + gap1 + gap2 + gap3 + gap4;
+  const bandBudget = worldHeight - fixedTotal;
+  const bp = bandProportions;
+  const rawTotal = bp.agents + bp.artifacts + bp.prs + bp.commits + bp.timeline;
+  const scale = bandBudget / rawTotal;
+  return [
+    { id: "label-agents", height: labelRowH },
+    { id: "band-agents", height: bp.agents * scale },
+    { id: "gap-1", height: gap1 },
+    { id: "label-artifacts", height: labelRowH },
+    { id: "band-artifacts", height: bp.artifacts * scale },
+    { id: "gap-2", height: gap2 },
+    { id: "label-prs", height: labelRowH },
+    { id: "band-prs", height: bp.prs * scale },
+    { id: "gap-3", height: gap3 },
+    { id: "label-commits", height: labelRowH },
+    { id: "band-commits", height: bp.commits * scale },
+    { id: "playhead-zone", height: playheadLabelZoneH },
+    { id: "gap-4", height: gap4 },
+    { id: "phase-bar", height: phaseBarRowH },
+    { id: "band-timeline", height: bp.timeline * scale }
+  ];
+}
+function computeStackPositions(elements, worldTop) {
+  const positions = /* @__PURE__ */ new Map();
+  let y = worldTop;
+  for (const el of elements) {
+    const top = y;
+    y -= el.height;
+    positions.set(el.id, { id: el.id, top, bottom: y, height: el.height });
+  }
+  return positions;
+}
+function getPos(positions, id) {
+  const pos = positions.get(id);
+  if (!pos) throw new Error(`Stack element '${id}' not found`);
+  return pos;
+}
+var MIN_AGENTS = 0.35;
+var MIN_ARTIFACTS = 0.06;
+var MIN_PRS = 0.06;
+var MIN_COMMITS = 0.06;
+var MIN_TIMELINE = 0.05;
+var BASE_BAND_PADDING = {
+  /** Offset from band top for count labels (e.g., "456 commits").
+   *  Provides breathing room between the band label row above and the count text.
+   *  At textScale=1.0 (desktop): 0.08 * sqrt(1) = 0.08 → ~10px margin.
+   *  At textScale=2.3 (mobile): 0.08 * sqrt(2.3) ≈ 0.12 → ~5px margin. */
+  countLabel: 0.08,
+  /** Minimum gap between packed rows */
+  rowGap: 0.01
+};
+var BAND_LABEL_MIN_WU = 0.182;
+var MIN_TIMESTAMP_PX = 7;
+var COUNT_LABEL_GAP = 0.01;
+function computeLabelRowHeight(textScale) {
+  const labelTextScale = Math.min(textScale, 1.5);
+  const labelFontHeight = Math.max(0.105 * labelTextScale, BAND_LABEL_MIN_WU);
+  const padding = 0.04;
+  return labelFontHeight + padding;
+}
+function getBandPadding(textScale = 1) {
+  const s = Math.sqrt(textScale);
+  return {
+    countLabel: BASE_BAND_PADDING.countLabel * s,
+    rowGap: BASE_BAND_PADDING.rowGap * s
+  };
+}
+var BAND_PADDING = getBandPadding(1);
+function makeBand(top, bottom, textScale = 1) {
+  const padding = getBandPadding(textScale);
+  return {
+    top,
+    bottom,
+    center: (top + bottom) / 2,
+    height: top - bottom,
+    contentTop: top,
+    // Labels are in dedicated rows above — full band for content
+    countLabelY: top - padding.countLabel
+  };
+}
+function computeBandProportions(data) {
+  const agentWeight = Math.max(1, Math.sqrt(data.agentCount / 5));
+  const artifactWeight = Math.max(0.5, Math.sqrt(data.maxArtifactRows / 5));
+  const prWeight = Math.max(0.5, Math.sqrt(data.maxPRRows / 3));
+  const commitWeight = 0.5;
+  const timelineWeight = 0.3;
+  const totalWeight2 = agentWeight + artifactWeight + prWeight + commitWeight + timelineWeight;
+  const totalGaps = GAP_AGENTS_ARTIFACTS + GAP_ARTIFACTS_PRS + GAP_PRS_COMMITS + GAP_COMMITS_TIMELINE;
+  const availableForBands = 1 - totalGaps;
+  const totalMin = MIN_AGENTS + MIN_ARTIFACTS + MIN_PRS + MIN_COMMITS + MIN_TIMELINE;
+  const extraSpace = Math.max(0, availableForBands - totalMin);
+  const agents = MIN_AGENTS + extraSpace * (agentWeight / totalWeight2);
+  const artifacts = MIN_ARTIFACTS + extraSpace * (artifactWeight / totalWeight2);
+  const prs = MIN_PRS + extraSpace * (prWeight / totalWeight2);
+  const commits = MIN_COMMITS + extraSpace * (commitWeight / totalWeight2);
+  const timeline = MIN_TIMELINE + extraSpace * (timelineWeight / totalWeight2);
+  return { agents, artifacts, prs, commits, timeline };
+}
+var BAR_GAP_RATIO = 0.2;
+function deriveBarHeightInternal(bandHeight, maxRows) {
+  return bandHeight / (maxRows * (1 + BAR_GAP_RATIO));
+}
+function getLayout(aspect, dataSummary, textScale = 1, viewportPxWidth) {
+  const worldHeight = CONTENT_HEIGHT;
+  const worldWidth = worldHeight * aspect;
+  const STABLE_WIDTH_PX = 1280;
+  const MIN_SIZE_FACTOR = 0.6;
+  const sizeFactor = viewportPxWidth ? Math.max(MIN_SIZE_FACTOR, Math.min(1, viewportPxWidth / STABLE_WIDTH_PX)) : 1;
+  const halfW = worldWidth / 2;
+  const halfH = worldHeight / 2;
+  const ppu = viewportPxWidth ? viewportPxWidth / worldWidth : 0;
+  const timePadLeft = worldWidth * 0.06;
+  const timePadRight = worldWidth * 0.06;
+  const timeLeft = -halfW + timePadLeft;
+  const timeRight = halfW - timePadRight;
+  const timeWidth = timeRight - timeLeft;
+  const bp = dataSummary ? computeBandProportions(dataSummary) : {
+    agents: DEFAULT_BAND_AGENTS,
+    artifacts: DEFAULT_BAND_ARTIFACTS,
+    prs: DEFAULT_BAND_PRS,
+    commits: DEFAULT_BAND_COMMITS,
+    timeline: DEFAULT_BAND_TIMELINE
+  };
+  const gapScale = Math.sqrt(textScale);
+  const stackElements = buildStackElements(worldHeight, textScale, bp, gapScale);
+  const stackPositions = computeStackPositions(stackElements, halfH);
+  const pos = (id) => getPos(stackPositions, id);
+  const bands = {
+    agents: makeBand(pos("band-agents").top, pos("band-agents").bottom, textScale),
+    artifacts: makeBand(pos("band-artifacts").top, pos("band-artifacts").bottom, textScale),
+    prs: makeBand(pos("band-prs").top, pos("band-prs").bottom, textScale),
+    commits: makeBand(pos("band-commits").top, pos("band-commits").bottom, textScale),
+    timeline: makeBand(pos("band-timeline").top, pos("band-timeline").bottom, textScale)
+  };
+  const separators = [
+    pos("band-artifacts").top + pos("gap-1").height * 0.3,
+    pos("band-prs").top + pos("gap-2").height * 0.3,
+    pos("band-commits").top + pos("gap-3").height * 0.3,
+    pos("band-timeline").top + pos("gap-4").height * 0.3
+  ];
+  const phaseBarTopY = pos("phase-bar").top;
+  const phaseBarBtm = pos("phase-bar").bottom;
+  const phaseBackgroundTop = separators[0];
+  const agentBandW = timeWidth - 0.1;
+  const agentBandH = bands.agents.height - 0.1;
+  const agentBandMin = Math.min(agentBandW, agentBandH);
+  const nodeRadiusRaw = Math.max(0.06, Math.min(0.25, agentBandMin * 0.047));
+  const nodeRadius = nodeRadiusRaw * sizeFactor;
+  const labelHeight = nodeRadius * 2.08 * textScale;
+  const timeToX = (normalizedTime) => {
+    return timeLeft + normalizedTime * timeWidth;
+  };
+  const xToProgress = (worldX) => {
+    return Math.max(0, Math.min(1, (worldX - timeLeft) / timeWidth));
+  };
+  const hoursToX = (hours, totalHours) => {
+    return timeToX(hours / totalHours);
+  };
+  const agentToWorld = (nx, ny) => {
+    const xMin = timeLeft + 0.05;
+    const xMax = timeRight - 0.05;
+    const yMin = bands.agents.bottom + labelHeight + nodeRadius;
+    const yMax = bands.agents.top - pillHeadroom;
+    const bandW = xMax - xMin;
+    const bandH = yMax - yMin;
+    return {
+      x: xMin + nx * bandW,
+      y: yMax - ny * bandH
+    };
+  };
+  const worldXFn = (nx) => {
+    return (nx - 0.5) * worldWidth;
+  };
+  const worldYFn = (ny) => {
+    return (0.5 - ny) * worldHeight;
+  };
+  const worldRadiusFn = (nr) => {
+    return nr * worldWidth;
+  };
+  const artifactMaxRows = dataSummary?.maxArtifactRows ?? 3;
+  const prMaxRows = dataSummary?.maxPRRows ?? 3;
+  const artifactBarHeight = deriveBarHeightInternal(bands.artifacts.height, artifactMaxRows);
+  const prBarHeight = deriveBarHeightInternal(bands.prs.height, prMaxRows);
+  const artifactRowStride = artifactBarHeight * (1 + BAR_GAP_RATIO);
+  const prRowStride = prBarHeight * (1 + BAR_GAP_RATIO);
+  const MIN_BAR_PX = 2;
+  const worstCasePPU = 390 / worldWidth;
+  const minBarWidth = Math.max(0.02, MIN_BAR_PX / worstCasePPU);
+  const maxBarWidth = timeWidth;
+  const agentCoreRadius = nodeRadius;
+  const humanSizeMultiplier = 1.5;
+  const maxWorkGrowth = 1;
+  const glowRadiusRatio = GLOW_RADIUS_RATIO;
+  const glowIntensity = 0.5;
+  const humanRingGap = 0;
+  const humanRingThickness = 0.012 * sizeFactor;
+  const humanRingOpacity = 0.9;
+  const humanGlowRadiusRatio = 1.8;
+  const humanGlowBaseIntensity = 0.15;
+  const humanGlowPeakIntensity = 0.5;
+  const activityPulse = 0.3;
+  const minBrightness = 0.35;
+  const agentShaderNodeRadius = AGENT_SHADER_NODE_RADIUS;
+  const singleLinePillHeight = nodeRadius * 1.2;
+  const pillGap = nodeRadius * PILL_GAP_RATIO + PILL_GAP_BASE;
+  const pillHeadroom = pillGap + singleLinePillHeight;
+  const agentQuadAAMargin = 0.02 * sizeFactor;
+  const agentQuadSizeMultiplier = 2.2;
+  const narrationOffsetY = nodeRadius * 2.2 + 0.1 * sizeFactor;
+  const narrationPadX = 0.015 * sizeFactor;
+  const narrationPadY = 0.03 * sizeFactor;
+  const narrationMaxWidth = Math.min(4 * sizeFactor, worldWidth * 0.75);
+  const narrationMinScale = 0.92;
+  const labelTextScale = Math.min(textScale, 1.5);
+  const playheadDotRadius = 0.04 * sizeFactor;
+  const playheadLabelMinHeight = ppu > 0 ? MIN_TIMESTAMP_PX / ppu : 0;
+  const playheadLabelMinWidth = playheadLabelMinHeight / (48 / 128);
+  const playheadLabelWidth = Math.max(0.4 * labelTextScale * sizeFactor, playheadLabelMinWidth);
+  const playheadLabelHeight = playheadLabelWidth * (48 / 128);
+  const playheadLabelOffsetY = 0.06 * sizeFactor;
+  const playheadCanvasWidth = 128;
+  const playheadCanvasHeight = 48;
+  const playheadFontSize = 24;
+  const agentsBandHeight = bands.agents.top - bands.agents.bottom;
+  const trustBarWidth = nodeRadius * 0.9;
+  const trustBarHeight = agentsBandHeight * 0.17 * sizeFactor;
+  const trustBarOffsetX = -(nodeRadius + trustBarWidth / 2 + 0.08 * sizeFactor);
+  const trustBarLabelHeight = 0.07 * labelTextScale * sizeFactor;
+  const trustBarLabelDisplayHeight = trustBarLabelHeight * textScale;
+  const phaseLabelFontSize = 0.045 * labelTextScale * sizeFactor;
+  const phaseLabelLeftPad = 0.15 * sizeFactor;
+  const phaseMinLabelWidth = 0.04 * sizeFactor;
+  const phaseGradientFraction = 0.15;
+  const commitLineWidth = 0.02 * sizeFactor;
+  const commitMinLineHeight = 0.01 * sizeFactor;
+  const particleBaseRadius = 7e-3 * sizeFactor;
+  const particleSizeScale = 28e-4 * sizeFactor;
+  const commitGlowWidthScale = 4;
+  const commitGlowHeightScale = 1.5;
+  const commitGlowOpacity = 0.35;
+  const commitCoreOpacity = 0.85;
+  const bandLabelLeftX = -halfW + 0.15;
+  const bandLabelRightX = Math.min(halfW, timeRight + 0.3 * sizeFactor);
+  const atlasBasePxPerUnit = 128;
+  const atlasMinFontPx = 12;
+  const hourLabelMinWu = ppu > 0 ? MIN_TIMESTAMP_PX / ppu : 0;
+  const hourLabelFontSizeWu = Math.max(0.07 * textScale * sizeFactor, hourLabelMinWu);
+  const bandLabelFontSizeWu = Math.max(
+    0.105 * labelTextScale * sizeFactor,
+    BAND_LABEL_MIN_WU * sizeFactor
+  );
+  const countLabelHeight = bandLabelFontSizeWu;
+  const bandLabelColor = "#888888";
+  return {
+    sizeFactor,
+    worldWidth,
+    worldHeight,
+    worldLeft: -halfW,
+    worldRight: halfW,
+    worldTop: halfH,
+    worldBottom: -halfH,
+    timeLeft,
+    timeRight,
+    timeWidth,
+    bands,
+    separators,
+    nodeRadius,
+    labelHeight,
+    // Band content sizing
+    artifactBarHeight,
+    prBarHeight,
+    artifactRowStride,
+    prRowStride,
+    minBarWidth,
+    maxBarWidth,
+    // Atlas text sizing
+    atlasBasePxPerUnit,
+    atlasMinFontPx,
+    hourLabelFontSizeWu,
+    bandLabelFontSizeWu,
+    bandLabelColor,
+    // Agent visual sizing
+    agentCoreRadius,
+    humanSizeMultiplier,
+    maxWorkGrowth,
+    glowRadiusRatio,
+    pillHeadroom,
+    glowIntensity,
+    humanRingGap,
+    humanRingThickness,
+    humanRingOpacity,
+    humanGlowRadiusRatio,
+    humanGlowBaseIntensity,
+    humanGlowPeakIntensity,
+    activityPulse,
+    minBrightness,
+    agentShaderNodeRadius,
+    agentQuadAAMargin,
+    agentQuadSizeMultiplier,
+    // Narration positioning
+    narrationOffsetY,
+    narrationPadX,
+    narrationPadY,
+    narrationMaxWidth,
+    narrationMinScale,
+    // Playhead sizing
+    playheadDotRadius,
+    playheadLabelWidth,
+    playheadLabelHeight,
+    playheadLabelOffsetY,
+    playheadCanvasWidth,
+    playheadCanvasHeight,
+    playheadFontSize,
+    // Trust bar sizing
+    trustBarWidth,
+    trustBarHeight,
+    trustBarOffsetX,
+    trustBarLabelHeight,
+    trustBarLabelDisplayHeight,
+    // Phase background positioning
+    phaseBarTop: phaseBarTopY,
+    phaseBarBottom: phaseBarBtm,
+    phaseBackgroundTop,
+    phaseLabelFontSize,
+    phaseLabelLeftPad,
+    phaseMinLabelWidth,
+    phaseGradientFraction,
+    // Commit band sizing
+    commitLineWidth,
+    commitMinLineHeight,
+    // Particle sizing
+    particleBaseRadius,
+    particleSizeScale,
+    // Commit band glow
+    commitGlowWidthScale,
+    commitGlowHeightScale,
+    commitGlowOpacity,
+    commitCoreOpacity,
+    // Label positioning
+    bandLabelLeftX,
+    bandLabelRightX,
+    countLabelHeight,
+    // Band label font size — also used for count labels (same size per @snorre)
+    countLabelFontSizeWu: bandLabelFontSizeWu,
+    // Band label row Y positions (from stacking loop)
+    // Band label is in upper portion of label row, count label below it.
+    // Small top padding (0.02) prevents label mesh from touching worldTop edge.
+    bandLabelY: {
+      agents: pos("label-agents").top - 0.02 - bandLabelFontSizeWu / 2,
+      artifacts: pos("label-artifacts").top - 0.02 - bandLabelFontSizeWu / 2,
+      prs: pos("label-prs").top - 0.02 - bandLabelFontSizeWu / 2,
+      commits: pos("label-commits").top - 0.02 - bandLabelFontSizeWu / 2
+    },
+    // Count label Y positions — in the gutter, just below band label text.
+    // These overlap into the band area below the label row. Zero extra Y space consumed.
+    countLabelY: {
+      agents: pos("label-agents").top - 0.02 - bandLabelFontSizeWu - COUNT_LABEL_GAP - countLabelHeight / 2,
+      artifacts: pos("label-artifacts").top - 0.02 - bandLabelFontSizeWu - COUNT_LABEL_GAP - countLabelHeight / 2,
+      prs: pos("label-prs").top - 0.02 - bandLabelFontSizeWu - COUNT_LABEL_GAP - countLabelHeight / 2,
+      commits: pos("label-commits").top - 0.02 - bandLabelFontSizeWu - COUNT_LABEL_GAP - countLabelHeight / 2
+    },
+    // Dedicated row bounds (for invariant tests + consumers)
+    playheadLabelZoneTop: pos("playhead-zone").top,
+    playheadLabelZoneBottom: pos("playhead-zone").bottom,
+    // Stacking loop data (for invariant tests)
+    stackElements,
+    stackPositions,
+    // Helper functions
+    timeToX,
+    xToProgress,
+    hoursToX,
+    agentToWorld,
+    worldX: worldXFn,
+    worldY: worldYFn,
+    worldRadius: worldRadiusFn
+  };
+}
+var MAX_TEXT_SCALE = 2;
+function getTextScale(_viewportPxWidth, _worldWidth) {
+  return MAX_TEXT_SCALE;
+}
+function computeMinYGapNorm(layout) {
+  const { nodeRadius, labelHeight } = layout;
+  const agentBandHeight = layout.bands.agents.height;
+  if (agentBandHeight <= 0) return MIN_Y_GAP_FALLBACK;
+  const NODE_RADIUS_REF2 = 0.15;
+  const layoutScale = nodeRadius / NODE_RADIUS_REF2;
+  const typicalCoreScale = 1.5 * layoutScale;
+  const visualRadius = nodeRadius * typicalCoreScale;
+  const labelGap = visualRadius * 0.65;
+  const halfExtent = visualRadius + labelGap + labelHeight / 2;
+  const gapWu = halfExtent * 2;
+  return gapWu / agentBandHeight;
+}
+var MIN_Y_GAP_FALLBACK = 0.06;
+function computeMinXGapNorm(layout) {
+  const { nodeRadius, labelHeight } = layout;
+  const p0 = layout.agentToWorld(0, 0.5);
+  const p1 = layout.agentToWorld(1, 0.5);
+  const bandWidth = Math.abs(p1.x - p0.x);
+  if (bandWidth <= 0) return 0.1;
+  const NODE_RADIUS_REF2 = 0.15;
+  const layoutScale = nodeRadius / NODE_RADIUS_REF2;
+  const typicalCoreScale = 1.5 * layoutScale;
+  const visualRadius = nodeRadius * typicalCoreScale;
+  const labelWidth = labelHeight * 3;
+  const halfExtentX = Math.max(visualRadius, labelWidth / 2);
+  const gapWu = halfExtentX * 2;
+  return gapWu / bandWidth;
+}
+function computeBandAspect(layout) {
+  const p00 = layout.agentToWorld(0, 0);
+  const p11 = layout.agentToWorld(1, 1);
+  const bandW = Math.abs(p11.x - p00.x);
+  const bandH = Math.abs(p11.y - p00.y);
+  if (bandH <= 0) return 5;
+  return bandW / bandH;
+}
+var DEFAULT_LAYOUT = getLayout(CONTENT_ASPECT);
+
+// src/renderer/band-sizing.ts
+var MIN_ROWS = 3;
+function computeArtifactPeakRows(events) {
+  const times = [];
+  for (const e of events) {
+    if (e.type === "artifact") {
+      times.push(e.normalizedTime);
+    }
+  }
+  if (times.length === 0) return MIN_ROWS;
+  times.sort((a, b) => a - b);
+  const barWidth = 3e-3;
+  const gap = 1e-3;
+  const rows = [];
+  let maxRows = 0;
+  for (const t of times) {
+    let placed = false;
+    for (let r = 0; r < rows.length; r++) {
+      if (rows[r] <= t) {
+        rows[r] = t + barWidth + gap;
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      rows.push(t + barWidth + gap);
+    }
+    if (rows.length > maxRows) {
+      maxRows = rows.length;
+    }
+  }
+  return Math.max(MIN_ROWS, maxRows);
+}
+function computePRPeakRows(events) {
+  const created = /* @__PURE__ */ new Map();
+  const merged = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const prNumber = e.metadata.prNumber;
+    if (prNumber === void 0) continue;
+    if (e.type === "pr_created") {
+      created.set(prNumber, e.normalizedTime);
+    } else if (e.type === "pr_merged") {
+      merged.set(prNumber, e.normalizedTime);
+    }
+  }
+  if (created.size === 0) return MIN_ROWS;
+  const intervals = [];
+  for (const [prNumber, openTime] of created) {
+    const closeTime = merged.get(prNumber) ?? 1;
+    intervals.push({ open: openTime, close: closeTime });
+  }
+  intervals.sort((a, b) => a.open - b.open);
+  const rows = [];
+  let maxRows = 0;
+  for (const iv of intervals) {
+    let placed = false;
+    for (let r = 0; r < rows.length; r++) {
+      if (rows[r] <= iv.open) {
+        rows[r] = iv.close + 1e-3;
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      rows.push(iv.close + 1e-3);
+    }
+    if (rows.length > maxRows) {
+      maxRows = rows.length;
+    }
+  }
+  return Math.max(MIN_ROWS, maxRows);
+}
+
+exports.BAND_PADDING = BAND_PADDING;
+exports.DEFAULT_LAYOUT = DEFAULT_LAYOUT;
+exports.computeAgentPositions = computeAgentPositions;
+exports.computeArtifactPeakRows = computeArtifactPeakRows;
+exports.computeBandAspect = computeBandAspect;
+exports.computeLayoutPositions = computeLayoutPositions;
+exports.computeMinXGapNorm = computeMinXGapNorm;
+exports.computeMinYGapNorm = computeMinYGapNorm;
+exports.computePRPeakRows = computePRPeakRows;
+exports.enrichVizData = enrichVizData;
+exports.getFrameState = getFrameState;
+exports.getLayout = getLayout;
+exports.getTextScale = getTextScale;
+exports.processData = processData;
+exports.transformToCurationData = transformToCurationData;
+exports.transformToRawData = transformToRawData;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map