splitsmith 0.77.0__tar.gz → 0.78.0__tar.gz

{splitsmith-0.77.0 → splitsmith-0.78.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.78.0](https://github.com/mandakan/splitsmith/compare/v0.77.0...v0.78.0) (2026-10-17)
+
+
+### Features
+
+* **beep:** put the detected beep on the timer tone's start; audit the corpus beep labels ([#1532](https://github.com/mandakan/splitsmith/issues/1532)) ([487bb62](https://github.com/mandakan/splitsmith/commit/487bb6274eb95320fb39370b558cdd6d7f4e67dd))
+* **looks:** a Broadcast Look that fills every slot and shows every region ([#1537](https://github.com/mandakan/splitsmith/issues/1537)) ([dc7cf99](https://github.com/mandakan/splitsmith/commit/dc7cf99f80b237b6e99040d72efef579c051a3ae))
+
+
+### Bug Fixes
+
+* **events:** a region before a moved beep starts at the beep; one bad region no longer hides the rest ([#1534](https://github.com/mandakan/splitsmith/issues/1534)) ([6a09a55](https://github.com/mandakan/splitsmith/commit/6a09a5575e485ecb545bde5d825d576b74ad4d86))
+* **hud:** a reload refills to the magazine's capacity, never one over ([#1536](https://github.com/mandakan/splitsmith/issues/1536)) ([753e98d](https://github.com/mandakan/splitsmith/commit/753e98dbd5da6e78a2ab08b618b039d8f90b3456))
+
 ## [0.77.0](https://github.com/mandakan/splitsmith/compare/v0.76.0...v0.77.0) (2026-10-17)
 
 

{splitsmith-0.77.0 → splitsmith-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: splitsmith
-Version: 0.77.0
+Version: 0.78.0
 Summary: Extract IPSC shot splits from head-mounted camera footage
 Author: Mathias Axell
 License: MIT

{splitsmith-0.77.0 → splitsmith-0.78.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "splitsmith"
-version = "0.77.0"
+version = "0.78.0"
 description = "Extract IPSC shot splits from head-mounted camera footage"
 readme = "README.md"
 requires-python = ">=3.11"

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/__init__.py

@@ -1,3 +1,3 @@
 """splitsmith: extract IPSC shot splits from head-mounted camera footage."""
 
-__version__ = "0.77.0"
+__version__ = "0.78.0"

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/beep_detect.py

@@ -65,6 +65,7 @@ import soundfile as sf
 from scipy.fft import next_fast_len
 from scipy.signal import butter, hilbert, sosfiltfilt
 
+from . import beep_tone
 from .beep_features import candidate_features, feature_vector
 from .config import BeepCandidate, BeepDetectConfig, BeepDetection, BeepFeatures, BeepRankerConfig
 
@@ -454,9 +455,14 @@ def detect_beep(
     ranked_models: list[BeepCandidate] = []
     for run, score, confidence in sorted(scored, key=lambda t: t[1], reverse=True):
         leading_idx = _rise_foot_leading_edge(env_fine, run.start, run.end, noise_floor)
+        time = leading_idx / sample_rate
+        if config.tone_onset:
+            onset = beep_tone.tone_onset(window, sample_rate, time)
+            if onset is not None:
+                time = max(0.0, onset)
         ranked_models.append(
             BeepCandidate(
-                time=leading_idx / sample_rate,
+                time=time,
                 score=score,
                 peak_amplitude=run.run_peak,
                 duration_ms=(run.end - run.start) * 1000.0 / sample_rate,

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/beep_tone.py

@@ -31,6 +31,18 @@ _LEVEL_FRAC = 0.15
 _TONE_HALF_HZ = 200.0
 _LINE_PROMINENCE = 4.0
 _LINE_MIN_SHARE = 0.15
+# A line at a half or a third of the winner's frequency is the fundamental
+# when it stands out in at least this share of the winner's columns.
+_FUNDAMENTAL_SHARE = 0.5
+# Where a line starts (tone_onset): the window and hop of its spectrogram,
+# how long it must keep standing out and in what share of that time, how far
+# from the given time to look, and how close a line start counts as "at" it.
+_ONSET_NPERSEG = 1024
+_ONSET_HOP_S = 0.002
+_ONSET_SUSTAIN_S = 0.1
+_ONSET_SHARE = 0.8
+_ONSET_REACH_S = 0.3
+_ONSET_KEEP_S = 0.04
 
 
 class Spectrogram(BaseModel):
@@ -63,35 +75,132 @@ def default_band() -> tuple[float, float]:
     return (cfg.tonal_band_lo_hz, cfg.tonal_band_hi_hz)
 
 
-def tone_band(audio: np.ndarray, sr: int, beep_s: float) -> tuple[float, float]:
-    """+-``_TONE_HALF_HZ`` around the timer's own frequency: the steadiest
-    tonal line within 1.5 to 7 kHz from 0.3 s before the beep to 0.5 s after
-    (the bin that stands ``_LINE_PROMINENCE``x over its +-300 Hz neighbours in
-    the most columns). The corpus's timers run from 1.6 to 5.4 kHz, so a fixed
-    band misses some, and a narrow one keeps most of a shot out. The
-    detector's band when no line stands out (silence, a timer drowned out).
-    On the 2026-10-17 corpus pass it agreed with the audited beep within 6 ms
-    on 57 of 66 primaries."""
+def tone_line_hz(audio: np.ndarray, sr: int, beep_s: float) -> float | None:
+    """The timer's own frequency near ``beep_s``: the steadiest tonal line
+    within 1.5 to 7 kHz from 0.3 s before it to 0.5 s after (the bin that
+    stands ``_LINE_PROMINENCE``x over its +-300 Hz neighbours in the most
+    columns), else None when no line stands out (silence, a timer drowned
+    out). The corpus's timers run from 1.6 to 5.4 kHz.
+
+    A timer's harmonic can stand out more than the tone itself where the
+    noise is quieter up there (Stockholm IPSC Open 6 on an iPhone: a 2.7 kHz
+    timer read as 5.4 kHz, and the start measured on the harmonic was 158 ms
+    early), so a line at half or a third of the winner's frequency that
+    stands out in at least half as many columns is taken instead."""
     lo = max(0, int(round((beep_s - 0.3) * sr)))
     hi = min(len(audio), int(round((beep_s + 0.5) * sr)))
     if hi - lo < 4096:
-        return default_band()
+        return None
     f, _t, z = stft(audio[lo:hi], fs=sr, nperseg=4096, noverlap=4096 - int(0.01 * sr))
     keep = (f >= 1500) & (f <= 7000)
     m, f = np.abs(z[keep]), f[keep]
     if m.size == 0 or m.max() <= 0:
-        return default_band()
+        return None
     k = max(1, int(round(300 / (f[1] - f[0]))))
     pad = np.pad(m, ((k, k), (0, 0)), mode="edge")
     med = np.stack([np.median(pad[i : i + 2 * k + 1], axis=0) for i in range(m.shape[0])])
     score = (m / (med + 1e-12) > _LINE_PROMINENCE).mean(axis=1)
     i = int(score.argmax())
     if score[i] < _LINE_MIN_SHARE:
+        return None
+    step = f[1] - f[0]
+    for div in (3, 2):
+        j = int(round((f[i] / div - f[0]) / step))
+        if j < 1 or j >= len(f) - 1:
+            continue
+        near = j - 1 + int(score[j - 1 : j + 2].argmax())
+        if score[near] >= max(_LINE_MIN_SHARE, _FUNDAMENTAL_SHARE * score[i]):
+            return float(f[near])
+    return float(f[i])
+
+
+def tone_band(audio: np.ndarray, sr: int, beep_s: float) -> tuple[float, float]:
+    """+-``_TONE_HALF_HZ`` around :func:`tone_line_hz`: a fixed band misses
+    some timers, and a narrow one keeps most of a shot out. The detector's
+    band when no line stands out. On the 2026-10-17 corpus pass it agreed
+    with the audited beep within 6 ms on 57 of 66 primaries."""
+    hz = tone_line_hz(audio, sr, beep_s)
+    if hz is None:
         return default_band()
-    hz = float(f[i])
     return (hz - _TONE_HALF_HZ, hz + _TONE_HALF_HZ)
 
 
+def _line_onset(audio: np.ndarray, sr: int, near_s: float, hz: float) -> float | None:
+    """The first moment within ``_ONSET_REACH_S`` of ``near_s`` where a line
+    at ``hz`` stands ``_LINE_PROMINENCE``x over its +-300 Hz neighbours and
+    keeps standing out for ``_ONSET_SHARE`` of the next ``_ONSET_SUSTAIN_S``.
+    Prominence, not level: a broadband sound never makes a line, and a quiet
+    tone still does."""
+    lo = max(0, int((near_s - _ONSET_REACH_S - 0.05) * sr))
+    hi = min(len(audio), int((near_s + _ONSET_REACH_S + _ONSET_SUSTAIN_S + 0.05) * sr))
+    if hi - lo < _ONSET_NPERSEG:
+        return None
+    hop = int(_ONSET_HOP_S * sr)
+    f, t, z = stft(audio[lo:hi], fs=sr, nperseg=_ONSET_NPERSEG, noverlap=_ONSET_NPERSEG - hop, boundary=None)
+    m = np.abs(z)
+    step = f[1] - f[0]
+    b = int(round(hz / step))
+    k = max(2, int(round(300 / step)))
+    if b - k < 0 or b + k >= len(f):
+        return None
+    line = m[b - 1 : b + 2].max(axis=0)
+    neigh = np.median(np.concatenate([m[b - k : b - 2], m[b + 3 : b + k + 1]]), axis=0)
+    present = line / (neigh + 1e-12) > _LINE_PROMINENCE
+    times = lo / sr + t
+    n = max(1, int(round(_ONSET_SUSTAIN_S / _ONSET_HOP_S)))
+    csum = np.concatenate([[0], np.cumsum(present)])
+    for i in range(len(present) - n):
+        if times[i] < near_s - _ONSET_REACH_S:
+            continue
+        if times[i] > near_s + _ONSET_REACH_S:
+            break
+        if present[i] and csum[i + n] - csum[i] >= _ONSET_SHARE * n:
+            # The first window holding the line: the tone entered it about a
+            # quarter window before its centre.
+            return float(times[i]) - _ONSET_NPERSEG / (4 * sr)
+    return None
+
+
+def tone_onset(audio: np.ndarray, sr: int, near_s: float) -> float | None:
+    """Where the timer's tone starts, seconds, when ``near_s`` is clearly off
+    it; None to keep ``near_s``.
+
+    The timer's line (:func:`tone_line_hz`) and its half, double and triple
+    are each found where they start (:func:`_line_onset`). When any of them
+    starts within ``_ONSET_KEEP_S`` of ``near_s`` it is kept: a weak
+    fundamental can rise late where a harmonic is plain (Tallmilan 7). Else
+    the fundamental's start, refined to its band's sustained rise
+    (:func:`tone_offset_ms`) when that lies within ``_ONSET_KEEP_S``.
+
+    Taking the earliest line instead moved good beeps early onto stray lines,
+    and keeping ``near_s`` when the level rule agreed on any line put back
+    confident mistakes: a harmonic passed it at a wrong pick (HFO Masters 6,
+    Little Trouble 2). On the corrected 2026-10-17 corpus the detector's
+    top-1 went from 284 to 295 of 329, and no wrong beep kept 0.95 or more.
+    The three it moved off a right beep are weak tones on two Samsung clips
+    and Oden Cup 5, all below 0.7."""
+    hz = tone_line_hz(audio, sr, near_s)
+    if hz is None:
+        return None
+    found: list[tuple[float, float]] = []
+    for mult in (0.5, 1.0, 2.0, 3.0):
+        h = hz * mult
+        if 1200 <= h <= 9000:
+            onset = _line_onset(audio, sr, near_s, h)
+            if onset is not None:
+                found.append((onset, h))
+    if any(abs(onset - near_s) <= _ONSET_KEEP_S for onset, _h in found):
+        return None
+    fundamental = [onset for onset, h in found if h == hz]
+    if not fundamental:
+        return None
+    onset = fundamental[0]
+    off = tone_offset_ms(audio, sr, onset, (hz - _TONE_HALF_HZ, hz + _TONE_HALF_HZ))
+    if off is not None and abs(off) <= _ONSET_KEEP_S * 1000:
+        return onset + off / 1000.0
+    return onset
+
+
 def band_pass(audio: np.ndarray, sr: int, lo_hz: float, hi_hz: float) -> np.ndarray:
     """Zero-phase 4th-order Butterworth band-pass: zero phase, because a
     phase shift would move the rise this exists to find."""

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/config.py

@@ -447,6 +447,13 @@ class BeepDetectConfig(BaseModel):
     # pick the right one without typing a timestamp by hand (issue #22).
     # ``0`` returns just the winner (legacy behaviour).
     top_n_candidates: int = 5
+    # Place each candidate's time on its timer tone's sustained rise, in the
+    # band of the timer's own line (``beep_tone.tone_onset``), instead of
+    # the rise foot of the run's envelope in the fixed band above. The run
+    # can start on a sound just before the tone, or after its start, and
+    # some timers sit outside the fixed band. A candidate with no tonal line
+    # keeps its rise foot. ``False`` is the old leading edge.
+    tone_onset: bool = True
     # How candidates are ranked and how confident the winner is (#949).
     ranker: BeepRankerConfig = Field(default_factory=BeepRankerConfig)
 

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/data/looks/_history.json

@@ -3,6 +3,8 @@
  "078cb1ba1108077b5091b2da33000db304d95360ce302b09862854f364984e04": "hud-timeline.html",
  "085dca804aa72ad344962481bcde0d61ef443188a7982db7ad37a7f47ff3b835": "hud-plate.html",
  "114b41e43fdc9b455330f3b3d0810313ad119b44e6b6dbb0c16d07764a53bbc4": "hud-ticker.html",
+ "12b3711e21b15b89a5b23a9eafa1629b631db82259e4d62edd5f9b684bb5ba2b": "broadcast-summary.html",
+ "1f508fbcbb677c41433ee31fa260d06fae5ab2fa96dea0c5d51d9f48f24ad405": "broadcast-sting.html",
  "21497c1e102d3cdaea8d00ea14b0ccab0219a2f4a8e2ce7bdb90b16da93f189f": "hud-ticker.html",
  "28e314b3cc5161594500afdd11c78bd75fc9015ea83220d22a1d40890c31eb0a": "hud-minimal.html",
  "29546017a237c43bb75a0087aed09c80e26eb78b007bd9ccfc31dde0da9f7600": "hud-timeline.html",
@@ -10,18 +12,21 @@
  "2f00e2f3d38acc96b0203fcac87a93566cbb0a5c0f25d54ed7f0823e7446a368": "card-rise.html",
  "3015c7885b10a9487b78716642724e6c0eb9b3e0621fb5cc2ef458af2a48fc93": "hud-minimal.html",
  "396618aceb25094800cda6a874bbc10af39721e39322a0e19ab0e5cdaf91e010": "card.html",
+ "3cd64bf59601ca4ed48c6e2e0f9c93256a1d523789a8b5d7102a7c82b3bcbaca": "broadcast-hud.html",
  "45bf7a97b0abc800703d2f3df4e77619c49d9518e093cb0843121184900d4935": "hud-timeline.html",
+ "482876198439541e5a6f13a1129e302d9b1932dfb8730955377c4f9ec1b95406": "broadcast-match.html",
  "505e9839fc6a08b55d81e1fcaf64ecb1a454ac110183bde1110dc55d20364d54": "hud-plate.html",
  "54e553f50479c232839d5dbb38bba7d15f287eed977568f527520d9eb2f99989": "sting-wipe.html",
- "592cce4db8f1dcd934327658ae923f1ee495e0a9d098989372c5b611c95a4003": "card-end-screen.html",
  "5bf59a9c746e95c78d5974a3b63a2c4d4908bf4f7b667bdbd5cce9b724e63001": "hud-timeline.html",
  "5c53273ef918b01dde2b9a884c3857493e8dd546d7d8c864e84ad4b80d04ccd2": "hud-minimal.html",
  "5df1cfe362897a4ebf5de245cc02b393751be7aa881304809b7c2a60be006a24": "hud-pips.html",
+ "60c2a9023f702082c46f8810b558ed136fd570d466c2050e14669840212131ef": "broadcast-thumbnail.html",
  "60eef66ea3ddb3986aee008d0679b79c3cfe047a989ff78ef0f4e4a537313aee": "sting-wipe.html",
  "6825d22c6a726616db173f3f563aa78ea059547738504b3993241f08e52d4f59": "hud-plate.html",
  "6fd82f315f82131839f78eeca7e77a269595f56f9a38ab672fc6dee4c1287358": "hud-plate.html",
  "7b912f778034187b4d304962a8cc78466ff3121937528f60527b2c2008938e8e": "hud-pips.html",
  "807c9f5b03254dbcf54f2445c1f1c93a44b8ad3c54ecd035fdc8383c3d487020": "hud-plate.html",
+ "81d18ed5ce1525f64dd19757d1bef6e36cab17d3b42e3aabd35a69bf6a2af3bc": "broadcast-card.html",
  "94ef8c97dbc9d0af6bb927ea6389a20536c6e9735114c3800da3621aae05493d": "hud-minimal.html",
  "960bf58e6e4f5b39ede144d9b59041d8534df4ccbb1fabf1a255a83bb1422587": "hud-ticker.html",
  "9f98be911c8212ecb30178a923f03d540f703432c0668fa26b2b68ea66b5cf91": "card-rise.html",

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/data/looks/_starters/broadcast-card.html

@@ -10,7 +10,8 @@
 
   window.splitsmith.data:
     card       { slot ("title_page", "slate", "lower_third", "closing"),
-                 variant, text (the match or the stage name),
+                 variant ("end-screen" lays the closing card out in the
+                 left two fifths), text (the match or the stage name),
                  info (the lines under it), duration_seconds }
     shooters[] { label, accent, club, logo (a file URL or null) }
     brand      { logo, line }  your brand: title page and closing card only
@@ -29,6 +30,11 @@
   #card { position: absolute; display: flex; flex-direction: column; gap: 1.2vh; }
   #card.full { left: 0; right: 0; top: 0; bottom: 0; align-items: center; justify-content: center; text-align: center; }
   #card.band { left: 4vh; bottom: 12vh; padding: 1.6vh 2.6vh; border-radius: 0.8vh; }
+  /* The closing card's end-screen style: everything in the left two fifths,
+     so YouTube's end-screen elements have the right of the frame. */
+  #card.end { left: 6vh; top: 0; bottom: 0; width: 38vw; justify-content: center; align-items: flex-start; text-align: left; }
+  #card.end #shooters { justify-content: flex-start; flex-wrap: wrap; }
+  body.end #credit { left: 6vh; right: auto; text-align: left; }
   #text { font-family: "Splitsmith Display", sans-serif; font-weight: 700; line-height: 1; white-space: nowrap; }
   .info { font-family: "Splitsmith Mono", monospace; font-size: 2.6vh; letter-spacing: 0.06em; white-space: nowrap; }
   #shooters { display: flex; gap: 3vh; justify-content: center; margin-top: 1vh; }
@@ -62,7 +68,10 @@
     return n;
   }
 
-  el.className = lower ? 'band' : 'full';
+  // The closing card's end-screen style (variant "end-screen").
+  var endScreen = card.slot === 'closing' && card.variant === 'end-screen';
+  el.className = lower ? 'band' : endScreen ? 'end' : 'full';
+  if (endScreen) document.body.classList.add('end');
   if (lower) { el.style.background = T.surface; el.style.color = T.ink; }
   if (D.event) {
     var ev = node('img'); ev.id = 'event'; ev.src = D.event.logo; el.appendChild(ev);
@@ -115,7 +124,9 @@
   window.__splitsmithFit = function () {
     var size = parseFloat(title.style.fontSize) * S.size.height / 100;
     title.style.fontSize = size + 'px';
-    var room = S.size.width * (lower ? 0.6 : 0.9);
+    // On an upright video the button column on the right is not room.
+    var safeRight = parseFloat(getComputedStyle(document.documentElement).getPropertyValue('--safe-right')) || 0;
+    var room = (S.size.width - safeRight) * (lower ? 0.6 : endScreen ? 0.38 : 0.9);
     while (title.scrollWidth > room && size > S.engine.min_font_size) {
       size -= 1;
       title.style.fontSize = size + 'px';

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/data/looks/_starters/broadcast-hud.html

@@ -22,7 +22,8 @@
     stage.beep, stage.stage_time, stage.rounds
     stage.shots[]      t (clip seconds), split, cls, label ("Draw", ...),
                        tier ("good" / "normal" / "slow" / null), moving
-    stage.events[]     confirmed regions: kind, start, end (clip seconds)
+    stage.events[]     confirmed regions: kind (draw, movement, reload,
+                       activation), start, end (clip seconds)
     stage.reloads[]    start, end, duration, exposed
     options            speed_colors, class_labels, landing, reload_chip,
                        stage_bar, position (draw nothing a toggle turns off)
@@ -76,6 +77,7 @@
     <div class="box"><span class="cap" id="splitCap">Split</span><span class="val" id="split">-</span></div>
     <div class="box" id="stringCell"><span class="cap">String</span><span class="val" id="string">-</span></div>
     <div class="box" id="hitsCell"><span class="cap">Hits (est.)</span><span class="val hits" id="hits"></span></div>
+    <div class="box" id="nowCell"><span class="cap">Now</span><span class="val" id="now"></span></div>
   </div>
 </div>
 <script>
@@ -97,6 +99,11 @@
   if (!bursts) $('stringCell').style.display = 'none';
   if (!spread) $('hitsCell').style.display = 'none';
 
+  // A region's colour: the theme's own for draw, movement and reload; an
+  // activation in ink_2, the neutral the app draws it in.
+  var REGION_COLOUR = { draw: T.draw, movement: T.movement, reload: T.reload, activation: T.ink_2 };
+  var REGION_LABEL = { draw: 'Draw', movement: 'Moving', reload: 'Reload', activation: 'Activation' };
+
   // The stage bar: regions as bands, shots as ticks (options.stage_bar).
   var track = $('track');
   var span = Math.max(0.1, stage.stage_time);
@@ -107,13 +114,26 @@
       var band = document.createElement('i');
       band.style.left = x(e.start) + '%';
       band.style.width = Math.max(0.5, x(e.end) - x(e.start)) + '%';
-      band.style.background = ({draw: T.draw, movement: T.movement, reload: T.reload})[e.kind] || T.muted;
+      band.style.background = REGION_COLOUR[e.kind] || T.muted;
       band.style.opacity = '0.8';
       track.appendChild(band);
     });
   } else {
     track.style.display = 'none';
   }
+  if (!opt.stage_bar) $('nowCell').style.display = 'none';
+
+  // The region underway at t, with how long it has run: a reload or a draw
+  // over a movement reads "on the move".
+  function regionAt(t) {
+    var on = stage.events.filter(function (e) { return e.start <= t && t <= e.end; });
+    if (!on.length) return null;
+    var order = ['reload', 'draw', 'activation', 'movement'];
+    on.sort(function (a, b) { return order.indexOf(a.kind) - order.indexOf(b.kind); });
+    var first = on[0];
+    var moving = first.kind !== 'movement' && on.some(function (e) { return e.kind === 'movement'; });
+    return { kind: first.kind, label: REGION_LABEL[first.kind] + (moving ? ' on the move' : ''), ran: t - first.start };
+  }
 
   function tierColour(shot) {
     if (!opt.speed_colors || !shot.tier) return T.split;
@@ -171,6 +191,16 @@
       }
     }
 
+    // The region underway (options.stage_bar), in its colour.
+    if (opt.stage_bar) {
+      var region = regionAt(t);
+      $('nowCell').style.display = region ? 'flex' : 'none';
+      if (region) {
+        $('now').textContent = region.label + ' ' + region.ran.toFixed(1);
+        $('now').style.color = REGION_COLOUR[region.kind] || T.ink;
+      }
+    }
+
     // The reload chip (options.reload_chip): up through a confirmed reload.
     var reload = opt.reload_chip ? stage.reloads.filter(function (r) { return r.start <= t && t <= r.end + 0.4; })[0] : null;
     $('chip').style.display = reload ? 'flex' : 'none';

splitsmith-0.78.0/src/splitsmith/data/looks/_starters/broadcast-sting.html

@@ -0,0 +1,90 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>starter: broadcast sting</title>
+<!--
+  The transition between two stages, using every piece of data a sting
+  gets. A panel in the Look's surface sweeps across with an accent edge,
+  holds over the cut carrying the next stage's name, and sweeps away. It
+  is drawn over the boundary's crossfade for the whole transition.
+  window.splitsmith.data:
+    transition { kind ("sting:<name>"), name, duration_seconds,
+                 from, to }   the labels either side of the cut
+    shooters[] { label, accent, club, logo }
+    brand      { logo, line } when the export puts your brand on the wipe
+  duration() must return transition.duration_seconds: the renderer
+  samples exactly that long.
+  Guide: docs/looks/authoring.md#stings
+-->
+<script>
+  document.write('<style>' + window.splitsmith.engine.css + '</style>');
+</script>
+<style>
+  html, body { margin: 0; background: transparent; overflow: hidden; width: 100vw; height: 100vh; }
+  #panel { position: absolute; top: 0; bottom: 0; left: 0; width: 100vw; display: flex; flex-direction: column;
+           justify-content: center; padding: 0 10vh; box-sizing: border-box; gap: 1.4vh; }
+  #edge { position: absolute; top: 0; bottom: 0; width: 1.6vh; }
+  .cap { font-family: "Splitsmith Mono", monospace; font-size: 2.4vh; letter-spacing: 0.14em; text-transform: uppercase; }
+  #to { align-self: flex-start; font-family: "Splitsmith Display", sans-serif; font-weight: 700; font-size: 11vh; line-height: 1; white-space: nowrap; }
+  #mark { position: absolute; right: 8vh; top: 50%; transform: translateY(-50%); height: 18vh; max-width: 30vh; object-fit: scale-down; }
+</style>
+</head>
+<body>
+<div id="panel"><div class="cap" id="next">Next</div><div id="to"></div></div>
+<div id="edge"></div>
+<script>
+  var S = window.splitsmith, D = S.data, T = S.theme, TR = D.transition || {};
+  var LENGTH = TR.duration_seconds || 1;
+  var $ = function (id) { return document.getElementById(id); };
+  var accent = (D.shooters && D.shooters[0] && D.shooters[0].accent) || T.accent;
+
+  $('panel').style.background = T.surface;
+  $('panel').style.color = T.ink;
+  $('next').style.color = T.ink_2;
+  $('edge').style.background = accent;
+  $('to').textContent = TR.to || '';
+  if (!TR.to) $('next').style.display = 'none';
+  // Your brand when the export puts it on the wipe; else a single shooter logo.
+  var mark = D.brand && D.brand.logo ? D.brand.logo : null;
+  if (!mark) {
+    var logos = (D.shooters || []).map(function (s) { return s.logo; }).filter(Boolean);
+    if (logos.length === 1) mark = logos[0];
+  }
+  if (mark) {
+    var img = document.createElement('img');
+    img.id = 'mark';
+    img.src = mark;
+    $('panel').appendChild(img);
+  }
+
+  // In over the first 40 %, hold, out over the last 40 %: the panel covers
+  // the frame across the cut, so the crossfade underneath never shows.
+  function ease(p) { return p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2; }
+  function paint(t) {
+    var p = t / LENGTH, x;
+    if (p < 0.4) x = -100 + 100 * ease(p / 0.4);
+    else if (p > 0.6) x = 100 * ease((p - 0.6) / 0.4);
+    else x = 0;
+    $('panel').style.transform = 'translateX(' + x + 'vw)';
+    // The accent edge leads the panel in and trails it out.
+    $('edge').style.left = p < 0.5 ? 'calc(' + (x + 100) + 'vw - 1.6vh)' : x + 'vw';
+    $('edge').style.display = x <= -100 || x >= 100 ? 'none' : 'block';
+  }
+  var now = LENGTH / 2;
+  window.duration = function () { return LENGTH; };
+  window.poster = function () { return LENGTH / 2; };
+  window.seek = function (t) { now = t; paint(t); };
+  window.__splitsmithFit = function () {
+    var to = $('to'), size = parseFloat(getComputedStyle(to).fontSize);
+    // The name's own width (the element hugs its text: align-self above).
+    while (to.getBoundingClientRect().width > S.size.width * 0.7 && size > S.engine.min_font_size) {
+      size -= 2;
+      to.style.fontSize = size + 'px';
+    }
+    paint(now);
+  };
+  paint(now);
+</script>
+</body>
+</html>

{splitsmith-0.77.0 → splitsmith-0.78.0}/src/splitsmith/data/looks/_starters/broadcast-summary.html

@@ -20,8 +20,8 @@
                static / moving (the same, with confirmed movement),
                reloads {count, avg, exposed}, rounds, min_rounds, dq.
                A figure that was never read is null.
-    stage      the overlay's stage data with the beep at 0: shots[], events[],
-               reloads[], stage_time, rounds
+    stage      the overlay's stage data with the beep at 0: shots[], events[]
+               (draw, movement, reload, activation), reloads[], stage_time, rounds
     scoring, ammo, bursts  as an overlay gets them (asked for above)
     safe_area  on an upright video
   Guide: docs/looks/authoring.md#summaries
@@ -47,6 +47,8 @@
   #timeline { position: relative; height: 3vh; border-radius: 0.6vh; overflow: hidden; margin-bottom: 1.4vh; }
   #timeline i { position: absolute; top: 0; bottom: 0; opacity: 0.85; }
   #timeline b { position: absolute; top: 15%; bottom: 15%; width: 0.3vh; }
+  #legend { display: flex; flex-wrap: wrap; gap: 0.6vh 2.4vh; font-size: 1.9vh; margin-bottom: 1.4vh; }
+  #legend i { display: inline-block; width: 1.4vh; height: 1.4vh; border-radius: 0.3vh; margin-right: 0.7vh; vertical-align: -0.15vh; }
   #notes { font-size: 1.8vh; opacity: 0.85; white-space: normal; }
   body.safe #board { top: 3vh; left: 2vh; transform: none; width: calc(100vw - 4vh - var(--safe-right)); padding: 2vh; }
   body.safe .figs { grid-template-columns: repeat(3, 1fr); gap: 1vh 1.4vh; }
@@ -61,6 +63,7 @@
   <div class="figs" id="grid"></div>
   <div id="counts"></div>
   <div id="timeline"></div>
+  <div id="legend"></div>
   <div id="notes"></div>
 </div>
 <script>
@@ -91,6 +94,7 @@
     ['Static avg', F.static && F.static.avg, two],
     ['Moving avg', F.moving && F.moving.avg, two],
     ['Reloads', F.reloads && F.reloads.count, function (v) { return String(Math.round(v)); }],
+    ['Reload avg', F.reloads && F.reloads.avg, function (v) { return two(v) + 's'; }],
     ['Exposed reload', F.reloads && F.reloads.exposed, function (v) { return two(v) + 's'; }],
     ['Rounds', F.rounds, function (v) { return Math.round(v) + (F.min_rounds ? ' / ' + F.min_rounds : ''); }]
   ].filter(function (c) { return c[1] != null; });
@@ -104,6 +108,10 @@
     return '<span style="color:' + colour[k] + '">' + k + ' ' + F.counts[k] + '</span>';
   }).join('') + (F.dq ? '<span style="color:' + T.accent + '">DQ</span>' : '');
 
+  // A region's colour: the theme's own for draw, movement and reload; an
+  // activation in ink_2, the neutral the app draws it in.
+  var REGION_COLOUR = { draw: T.draw, movement: T.movement, reload: T.reload, activation: T.ink_2 };
+
   // The run itself, from data.stage: regions as bands, shots as ticks.
   var span = Math.max(0.1, stage.stage_time);
   var line = $('timeline');
@@ -113,9 +121,23 @@
     var band = document.createElement('i');
     band.style.left = x(e.start) + '%';
     band.style.width = Math.max(0.5, x(e.end) - x(e.start)) + '%';
-    band.style.background = ({draw: T.draw, movement: T.movement, reload: T.reload})[e.kind] || T.muted;
+    band.style.background = REGION_COLOUR[e.kind] || T.muted;
     line.appendChild(band);
   });
+
+  // The legend: each kind of region the stage has, in its colour, with what
+  // it took. The draw is the Draw figure; the rest are counts and time.
+  var legend = [];
+  ['draw', 'movement', 'reload', 'activation'].forEach(function (kind) {
+    var mine = stage.events.filter(function (e) { return e.kind === kind; });
+    if (!mine.length) return;
+    var total = mine.reduce(function (s, e) { return s + (e.end - e.start); }, 0);
+    var text = kind === 'draw' ? 'Draw ' + two(F.draw != null ? F.draw : total)
+      : ({ movement: 'Moving', reload: 'Reload', activation: 'Activation' })[kind] + ' ' + mine.length + ' x, ' +
+        total.toFixed(1) + 's';
+    legend.push('<span><i style="background:' + REGION_COLOUR[kind] + '"></i>' + text + '</span>');
+  });
+  $('legend').innerHTML = legend.join('');
   stage.shots.forEach(function (shot) {
     var tick = document.createElement('b');
     tick.style.left = x(shot.t) + '%';