From 4445c84adfcbfb51c20deabd376172e2c01e9b20 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 08:59:30 +0000 Subject: [PATCH 1/2] fix(hls): pin EXT-X-TARGETDURATION to the declared duration (#7018) * chore(quest): claim quest/m1/archive/hls-target.md Quest-Claim: 7e99500173ce54df * fix(hls): pin EXT-X-TARGETDURATION to the declared duration Each playlist URI keeps one target for the run: the longest `hls` duration the broadcast's renditions declare, rounded up. A reconfigure keeps the original; a rendition added later with longer segments gets its own larger target. A segment that rounds past the target is listed anyway with a rate-limited warning, documented as a deliberate RFC 8216 4.3.3.1 deviation. * fix(hls): keep a returning rendition's target duration A removed rendition that returns serves the same playlist URI, so its pinned EXT-X-TARGETDURATION must outlive its last reference. * fix(hls): derive each target duration instead of pinning one per name The per-name target map was never pruned, so a publisher churning rendition names grew it without bound. A new rendition's target is now the larger of its own declared duration and the longest the first catalog batch declared, a baseline fixed for the run. A reconfigure keeps its predecessor's target through the handoff, and nothing per name persists. * fix(hls): qualify the target duration's stability to catalog membership A rendition removed and re-added derives its target from its current declaration, so a URI whose reconfigure kept an older target can return with a different one. Say so in the docs and test it directly. * quest: drop the link to the finished HLS target quest Co-authored-by: Claude Opus 5.5 --- doc/bin/hls.md | 1 + quest/m1/archive/README.md | 6 +- quest/m1/archive/hls-target.md | 43 ---------- quest/m1/hls-conformance.md | 7 +- quest/m1/time-addressing/consumers.md | 6 +- rs/moq-hls/src/export/mod.rs | 109 ++++++++++++++++++++------ rs/moq-hls/src/export/rendition.rs | 87 ++++++++++++++++---- rs/moq-hls/src/export/renditions.rs | 86 +++++++++++++------- 8 files changed, 216 insertions(+), 129 deletions(-) delete mode 100644 quest/m1/archive/hls-target.md diff --git a/doc/bin/hls.md b/doc/bin/hls.md index 8e922ef324c..2adb20bbfaf 100644 --- a/doc/bin/hls.md +++ b/doc/bin/hls.md @@ -54,6 +54,7 @@ What that means for you: - **Idle renditions cost nothing**, and a segment is servable for as long as the relay's [cache](/bin/relay/config#cache) retains it. Keep `--window` (the playlist length, default 16 s) within that retention. - **Live joins cost the window.** The exporter reads the record checkpoint and lists at most 256 segments. - **Segments are timed by their records.** A segment is listed once the record after it arrives, and its duration, its DASH `t` and `d`, and its last sample's duration all come from its own record and the next, so a segment's bytes never change with a catalog estimate. A stop record (a break or the end of the content) is listed as a zero-length gap, and what follows it starts a discontinuity. +- **The target duration is declared.** Every media playlist keeps one `EXT-X-TARGETDURATION` while its rendition stays in the catalog, even across a reconfigure: the longest segment duration the broadcast's first renditions declare, rounded up. A rendition added later that declares longer segments gets a larger target of its own, while playlists already served keep theirs. A rendition removed and re-added gets the target its declared duration gives, so keep a rendition's declared duration fixed for the run. A GOP longer than the target, once rounded, is still listed rather than dropped or split, against RFC 8216's rule: hls.js plays it, but Apple's `mediastreamvalidator` flags it, so keep keyframe intervals within the declared duration. - **Disabled renditions are hidden.** A rendition the catalog marks `enabled: false` leaves the multivariant playlist and DASH manifest until it re-enables. Its media playlist keeps serving, so a player already on it is not ended with `EXT-X-ENDLIST`. - **URLs name the publisher instance.** Every URL the multivariant playlist and DASH manifest list sits under `@`, the publisher's epoch, so every edge and every reload derive the same URLs and a CDN in front of export caches them. A restarted publisher gets URLs of its own, whose numbering starts over. The multivariant playlist and manifest switch to it at once, while a player already on the old instance keeps playing until that publisher leaves; the player then has to reload the multivariant playlist. An instance without an epoch (one that reached export over moq-lite-06 or older) gets an id each export mints, so only that export serves its URLs. - **Only a clean finish ends a playlist.** `EXT-X-ENDLIST` and a `static` DASH manifest mean the records finished. A rendition whose records fail instead, such as a publisher dropping its session, answers HTTP 500 with `Cache-Control: no-store`, so a truncated recording never looks complete, and leaves the multivariant playlist and DASH manifest so players switch to a sibling. With none left, the DASH manifest answers the error too. diff --git a/quest/m1/archive/README.md b/quest/m1/archive/README.md index 963a76a4299..00fd8bc4600 100644 --- a/quest/m1/archive/README.md +++ b/quest/m1/archive/README.md @@ -1,4 +1,4 @@ -# Broadcast archives +# [S] Broadcast archives ## Goal @@ -84,10 +84,6 @@ once the children land: what ANNOUNCE and TRACKS discover, the store layout (lin the moq-archive rustdoc that specifies it), and serving a stored broadcast from a host. Each child fixes the stale docs it touches. -## Required - -- [Fixed HLS target duration](/quest/m1/archive/hls-target.md) - one `EXT-X-TARGETDURATION` for the run, from the declared `hls` duration; an overrun is listed with a warning - ## Related - [e2ee](/quest/m2/e2ee/README.md) - protected broadcasts are excluded initially diff --git a/quest/m1/archive/hls-target.md b/quest/m1/archive/hls-target.md deleted file mode 100644 index 1278eb8c1ac..00000000000 --- a/quest/m1/archive/hls-target.md +++ /dev/null @@ -1,43 +0,0 @@ -# [S] Fixed HLS target duration - -## Goal - -Every `moq-hls` media playlist of a broadcast advertises one -`EXT-X-TARGETDURATION` for the whole run, the largest declared duration across -its renditions' opt-in `hls` fields, so every edge, every reload, and every -rendition agree on it (Apple's HLS authoring spec 8.2). Segments stay one-to-one -with `hls` records: the edge never skips, splits, or renumbers one. - -## Plan - -[#4280](https://github.com/moq-dev/moq/pull/4280) derives the target from the -current window's longest segment (`snapshot_from_window` in -`rs/moq-hls/src/export/rendition.rs`), so it rises when a long record arrives -and falls when that record is evicted. Codex flagged it -([r4113921580](https://github.com/moq-dev/moq/pull/4280#discussion_r4113921580)). -The 09-28 audit reversed #4280's decision 4 (the observed maximum), and the -09-29 planning settled the rest: - -- The target is `ceil` of the largest declared `hls` duration across the - broadcast's renditions, from Catalog HLS field (retargeted 2026-10-17 from - the root `archive` map; made broadcast-wide 2026-10-26, since renditions now - cut on their own grids and may declare different durations). Until a - rendition declares, it has no playlist yet. Decide what a rendition added - later with a larger declared duration does to a target already served. -- A segment whose rounded `EXTINF` exceeds the target (a GOP that overran the - publisher's declared value) is listed anyway, with a rate-limited warning. - This deliberately deviates from RFC 8216 4.3.3.1's MUST, because refusing - the segment loses content, and splitting or skipping it at the edge breaks - the stable media sequence numbers of RFC 8216 6.2.2. Document the - deviation. hls.js tolerates it; Apple's mediastreamvalidator flags it. - -Catalog HLS field lists each rendition's own records, so the old -non-reference `EXTINF` rule and the split-record handling are already gone. - -Replace `target_duration_follows_the_observed_segments` with tests that pin -the declared target across a window whose segment durations vary, and that -cover an overrun at the rounding boundary (listed, warned). Hold the target per -playlist URI, not per `Rendition`: `renditions::Producer::sync` replaces the -`Rendition` on a catalog reconfigure, so test that a reconfigure mid-run -keeps the original target. - diff --git a/quest/m1/hls-conformance.md b/quest/m1/hls-conformance.md index de6a1800d06..dd4afbcf664 100644 --- a/quest/m1/hls-conformance.md +++ b/quest/m1/hls-conformance.md @@ -16,8 +16,7 @@ From the 2026-10-24 moq-hls audit, which found no player-level HLS or DASH coverage. Decided with the maintainer on 2026-10-24: - ffprobe conformance lands in m1, so it validates the - Catalog HLS field redesign and the - [fixed target duration](/quest/m1/archive/hls-target.md) before the cut. A + Catalog HLS field redesign and the fixed target duration before the cut. A browser player test follows in m2 ([HLS and DASH browser playback](/quest/m2/hls-player-test.md)). - Cover a sliding window that evicts segments, a GOP that overruns the @@ -30,10 +29,6 @@ coverage. Decided with the maintainer on 2026-10-24: Public API: none. Wire: none. -## Required - -- [Fixed HLS target duration](/quest/m1/archive/hls-target.md) - the run-wide target this asserts - ## Related - [Export sync flags](/quest/m2/intra-refresh/export-sync-flags.md) - the sync flags a refresh rendition should advertise diff --git a/quest/m1/time-addressing/consumers.md b/quest/m1/time-addressing/consumers.md index fa3dcd2d653..9088771f9b8 100644 --- a/quest/m1/time-addressing/consumers.md +++ b/quest/m1/time-addressing/consumers.md @@ -55,9 +55,9 @@ state again). - **A segment with no groups is `EXT-X-GAP`**, so numbering never skips across a pause or an overrun. A group overrunning the interval is listed at its first line, so its `EXTINF` understates the media; document the - deviation beside - [fixed target duration](/quest/m1/archive/hls-target.md)'s overrun rule, - whose target then comes from the interval. + deviation beside the fixed target duration's overrun rule (in + `rs/moq-hls/src/export/rendition.rs`), whose target then comes from the + interval. - **The target duration is the interval** (maintainer, 2026-10-28). A segment can run up to twice the interval even without an overrun, since the group containing a line can start up to one interval before it; diff --git a/rs/moq-hls/src/export/mod.rs b/rs/moq-hls/src/export/mod.rs index 9a71f1afdfe..207de7dc38a 100644 --- a/rs/moq-hls/src/export/mod.rs +++ b/rs/moq-hls/src/export/mod.rs @@ -2336,32 +2336,6 @@ mod tests { drop((audio, catalog, broadcast)); } - // The declared duration is nominal, so the exporter derives EXT-X-TARGETDURATION from the - // segments it has. A playlist whose EXTINF exceeds its target duration is invalid. - #[tokio::test] - async fn target_duration_follows_the_observed_segments() { - let origin = produce_origin(); - let broadcast = origin.create_broadcast("live").expect("publish allowed"); - broadcast.announce(Default::default()).expect("publish allowed"); - settle().await; - let catalog = hls_catalog(&mut broadcast.broadcast().clone()); - // 3s GOPs on the 2s grid: every GOP lands in a later cell, so each is one segment. - let mut media = video(&catalog, &broadcast, "video0", inline_vp8()); - media.write(frame(0, true)).unwrap(); - media.write(frame(3_000_000, true)).unwrap(); - media.write(frame(6_000_000, true)).unwrap(); - - let broadcaster = Broadcaster::new(crate::resolved(&origin, "live").await, Config::default()); - let _ = tokio::time::timeout(Duration::from_secs(5), broadcaster.ready()).await; - let rendition = broadcaster.rendition(Kind::Video, "video0").expect("rendition"); - let _ = tokio::time::timeout(Duration::from_secs(5), rendition.playable()).await; - - let playlist = rendition.snapshot(); - assert_eq!(playlist.segments[0].duration, Duration::from_secs(3)); - assert_eq!(playlist.target_duration, 3, "the target duration covers the 3s segment"); - drop((media, catalog, broadcast)); - } - // Audio and video renditions whose groups start on the same grid lines cut the same // boundaries, with no state shared between them. Video is one group per segment; an audio // segment packs every audio group inside the video segment's span. @@ -3851,6 +3825,89 @@ mod tests { assert_eq!(numbers(&test.listed("video0", 0).await), [0]); } + // EXT-X-TARGETDURATION is the declared duration rounded up, however long the segments in the + // window are. A segment that overruns it once rounded to the nearest second is listed anyway, + // and counted for the warning. + #[tokio::test(start_paused = true)] + async fn the_target_duration_is_the_declared_one() { + let test = Records::with(&["video0"], &[]); + let (_, mut records) = test.publish("video0"); + for (sequence, pts) in (0..).zip([0, 2_499, 4_999, 6_000, 8_000]) { + records.push(&hang::hls::Record::new(sequence, sequence, pts)).unwrap(); + } + let snapshot = test.listed("video0", 3).await; + let durations: Vec<_> = snapshot.segments.iter().map(|s| s.duration.as_millis()).collect(); + assert_eq!(durations, [2_499, 2_500, 1_001, 2_000]); + assert_eq!(snapshot.target_duration, 2); + assert_eq!( + test.rendition("video0").overruns(), + 1, + "only the 2.5s segment rounds past the target" + ); + } + + // Each playlist URI keeps the EXT-X-TARGETDURATION it first got. The first renditions listed + // share the longest duration they declare, which floors every later target; one added later + // that declares longer segments raises only its own, and a reconfigure keeps the original. + #[tokio::test(start_paused = true)] + async fn each_playlist_keeps_its_target_duration() { + let declare = |name: &str, secs: u64| { + Some(hang::catalog::Hls::new( + hang::hls::default_name(name), + Duration::from_secs(secs), + )) + }; + let mut test = Records::with(&[], &[]); + let mut video = video_config(); + video.hls = declare("video0", 2); + test.catalog.video.renditions.insert("video0".into(), video); + let mut audio = opus(); + audio.hls = declare("audio0", 1); + test.catalog.audio.renditions.insert("audio0".into(), audio); + test.sync(); + let target = |name: &str| test.rendition(name).target_duration(); + assert_eq!((target("video0"), target("audio0")), (2, 2)); + + let mut late = video_config(); + late.hls = declare("video1", 4); + test.catalog.video.renditions.insert("video1".into(), late.clone()); + test.sync(); + late.hls = declare("video2", 2); + test.catalog.video.renditions.insert("video2".into(), late); + test.sync(); + let target = |name: &str| test.rendition(name).target_duration(); + assert_eq!( + [target("video0"), target("audio0"), target("video1"), target("video2")], + [2, 2, 4, 2] + ); + + let original = test.rendition("video0"); + test.catalog.video.renditions.get_mut("video0").unwrap().hls = declare("video0", 6); + test.sync(); + let replacement = test.rendition("video0"); + assert!(!Arc::ptr_eq(&original, &replacement), "a new duration reconfigures"); + assert_eq!(replacement.target_duration(), 2); + drop((original, replacement)); + + // A removed rendition that returns serves the same playlist URI. Nothing of it is kept, + // but the target derives from its declared duration and the first batch's, so one that + // returns declaring what it first did comes back the same, even after a longer rendition + // registers in between. One whose reconfigure kept an older target, though, returns with + // the target its current declaration derives: the price of keeping no state per name. + let video0 = test.catalog.video.renditions.remove("video0").unwrap(); + let video1 = test.catalog.video.renditions.remove("video1").unwrap(); + test.sync(); + let mut longer = video_config(); + longer.hls = declare("video3", 8); + test.catalog.video.renditions.insert("video3".into(), longer); + test.sync(); + test.catalog.video.renditions.insert("video0".into(), video0); + test.catalog.video.renditions.insert("video1".into(), video1); + test.sync(); + let target = |name: &str| test.rendition(name).target_duration(); + assert_eq!([target("video1"), target("video3"), target("video0")], [4, 8, 6]); + } + /// The `Push` events a fresh subscriber to `track`'s records reads before it is caught up. async fn fresh_join_reads(test: &Records, track: &str) -> usize { let mut records = moq_mux::hls::Consumer::subscribe(&test.broadcast.consume(), &hls(track)) diff --git a/rs/moq-hls/src/export/rendition.rs b/rs/moq-hls/src/export/rendition.rs index 2584ab89816..86e3fc297fa 100644 --- a/rs/moq-hls/src/export/rendition.rs +++ b/rs/moq-hls/src/export/rendition.rs @@ -1,7 +1,7 @@ //! One rendition: playlists from its own HLS records, and segments fetched on demand. use moq_clock::Wall; -use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{Arc, Mutex, RwLock, Weak}; use std::task::Poll; use std::time::Duration; @@ -259,6 +259,12 @@ fn normalize_audio(config: &AudioConfig) -> AudioConfig { config } +/// `duration` in whole seconds, rounded up, and at least one: the smallest +/// `EXT-X-TARGETDURATION` that segments of that declared duration fit. +fn whole_seconds(duration: Duration) -> u64 { + (duration.as_secs() + u64::from(duration.subsec_nanos() > 0)).max(1) +} + /// The segment [tag](segments::tag) of `track` muxed under the normalized `config`, hashing its /// catalog JSON, which every edge encodes alike. fn tag(track: &str, config: &T) -> Arc { @@ -273,6 +279,8 @@ pub(crate) struct Handoff { track: String, /// The first record it will not list. next: u64, + /// Its `EXT-X-TARGETDURATION`, which a replacement serving the same playlist URI keeps. + target_duration: u64, } /// Which records a rendition lists, shared by its records watcher and [`Rendition::retire`] so a @@ -318,6 +326,12 @@ pub struct Rendition { /// The [tag](segments::tag) of [`hls`](Self::hls)'s record track muxed under this config, in /// every segment URL. tag: Arc, + /// `EXT-X-TARGETDURATION`, in whole seconds: [`hls`](Self::hls)'s duration rounded up, or a + /// predecessor's (see [`after`](Self::after)), until [`pin`](Self::pin) sets the one its + /// playlist URI keeps while it stays in the catalog. + target_duration: u64, + /// Segments listed past the target duration, counted to rate-limit their warning. + overruns: AtomicU64, /// The catalog's root broadcast clock: the wall anchor record times map through. Absent when /// the publisher exposes none. clock: Option, @@ -437,6 +451,8 @@ impl Rendition { codec: config.codec.to_string(), config: Config::Video(config.clone()), tag: tag(&hls.track, &normalize_video(config)), + target_duration: whole_seconds(hls.duration), + overruns: AtomicU64::new(0), hls, clock, live: Arc::new(segments::Producer::new(0)), @@ -475,6 +491,8 @@ impl Rendition { codec: config.codec.to_string(), config: Config::Audio(config.clone()), tag: tag(&hls.track, &normalize_audio(config)), + target_duration: whole_seconds(hls.duration), + overruns: AtomicU64::new(0), hls, clock, live: Arc::new(segments::Producer::new(0)), @@ -502,12 +520,18 @@ impl Rendition { *self.watcher.lock().expect("watcher lock poisoned") = Some(watcher); } - /// Take over from a retired predecessor (see [`retire`](Self::retire)): list only the records - /// it won't. One reading another record track shares no numbering with it, so it lists all. + /// Take over from a retired predecessor (see [`retire`](Self::retire)): keep its target + /// duration and list only the records it won't. One reading another record track shares no + /// numbering with it, so it lists all. pub(crate) fn after(mut self, handoff: Option<&Handoff>) -> Self { - let Some(handoff) = handoff.filter(|handoff| handoff.track == self.hls.track) else { + let Some(handoff) = handoff else { return self; }; + // The playlist URI stays the same, so it keeps its target duration (RFC 8216 6.2.1). + self.target_duration = handoff.target_duration; + if handoff.track != self.hls.track { + return self; + } let start = handoff.next; self.claim = Mutex::new(Claim { start, @@ -534,6 +558,42 @@ impl Rendition { Handoff { track: self.hls.track.clone(), next, + target_duration: self.target_duration, + } + } + + /// Advertise `target_duration` seconds as `EXT-X-TARGETDURATION`: the one this rendition's + /// playlist URI keeps while it stays in the catalog. + pub(crate) fn pin(mut self, target_duration: u64) -> Self { + self.target_duration = target_duration; + self + } + + /// The `EXT-X-TARGETDURATION` of this rendition's media playlist, in whole seconds. + pub(crate) fn target_duration(&self) -> u64 { + self.target_duration + } + + /// How many segments were listed past the target duration. + #[cfg(test)] + pub(crate) fn overruns(&self) -> u64 { + self.overruns.load(Ordering::Relaxed) + } + + /// Warn that segment `segment`, `duration` long, is listed past the target duration. Only on + /// the 1st, 2nd, 4th, 8th... overrun, so a publisher whose every GOP overruns can't flood the + /// log. + fn overrun(&self, segment: u64, duration: Duration) { + let overruns = self.overruns.fetch_add(1, Ordering::Relaxed) + 1; + if overruns.is_power_of_two() { + tracing::warn!( + rendition = %self.name, + segment, + ?duration, + target_duration = self.target_duration, + overruns, + "segment overruns the declared HLS duration; listing it past EXT-X-TARGETDURATION" + ); } } @@ -773,17 +833,6 @@ impl Rendition { } fn snapshot_from_window(&self, window: segments::Window, finished: bool, generation: Option>) -> Snapshot { - // HLS requires EXT-X-TARGETDURATION to be at least every EXTINF, rounded to the nearest - // whole second; it is at least the declared duration, which every segment aims for. - let target_duration = window - .segments - .iter() - .map(|s| s.duration) - .chain([self.hls.duration]) - .map(|duration| duration.as_secs_f64().round() as u64) - .max() - .unwrap_or(0) - .max(1); let mut previous = None; let segments = window .segments @@ -801,7 +850,7 @@ impl Rendition { }) .collect(); Snapshot { - target_duration, + target_duration: self.target_duration, media_sequence: window.sequence, discontinuity_sequence: window.discontinuity, segments, @@ -1312,6 +1361,12 @@ fn row( return None; } let duration = record.duration.unwrap_or(Duration::from(next.pts) - pts); + // RFC 8216 4.3.3.1 requires every EXTINF, rounded to the nearest second, to fit the target + // duration. A GOP that overran the declared duration is listed anyway: refusing it loses + // content, and splitting or skipping it renumbers the segments after it (RFC 8216 6.2.2). + if duration.as_secs_f64().round() as u64 > rendition.target_duration { + rendition.overrun(record.sequence, duration); + } let end = pts + duration; Some(segments::Row { index: record.sequence, diff --git a/rs/moq-hls/src/export/renditions.rs b/rs/moq-hls/src/export/renditions.rs index 6faefc92e49..d276fc51800 100644 --- a/rs/moq-hls/src/export/renditions.rs +++ b/rs/moq-hls/src/export/renditions.rs @@ -85,6 +85,9 @@ struct Feed { targets: Vec>, /// Each rendition's discontinuity count. discontinuities: Discontinuities, + /// The longest duration the first catalog batch declared, in whole seconds rounded up: the + /// floor of every target duration this run (see [`Producer::register`]). + baseline: Option, /// The catalog failed; late-created renditions start failed. failed: Option, /// The estimated wall-clock time of `pts` 0, anchored when the first segment was listed @@ -138,6 +141,7 @@ impl Producer { feed: kio::Producer::new(Feed { targets: Vec::new(), discontinuities: Discontinuities::default(), + baseline: None, failed: None, anchor: None, generation: None, @@ -409,26 +413,51 @@ impl Producer { .await } - /// Enroll a freshly-created rendition with what its siblings share, and start following its - /// own records. - fn register(&self, rendition: &Arc) { + /// Enroll freshly created renditions with what their siblings share, and start following + /// their own records. + /// + /// A playlist URI keeps one `EXT-X-TARGETDURATION` while its rendition stays in the catalog + /// (RFC 8216 6.2.1). The target is derived rather than stored per name, so a publisher + /// churning names can't grow the feed: a new rendition gets the larger of its own declared + /// duration and the [baseline](Feed::baseline), the longest the first batch declared. + /// Renditions listed first all agree. A reconfigured rendition's replacement keeps its + /// predecessor's (see [`Rendition::after`]), which already covers the baseline. One that + /// leaves and returns gets the target its declaration derives: the same unless a reconfigure + /// had kept an older one. + fn register(&self, added: Vec) -> Vec> { + // Most catalog updates only revise estimates; writing the feed would wake every cursor. + if added.is_empty() { + return Vec::new(); + } let mut feed = self .fanout .feed .write() .unwrap_or_else(|_| unreachable!("fanout is open")); - rendition.label(feed.generation.clone()); - if let Some(err) = &feed.failed { - rendition.fail(err.clone()); - rendition.close(); - } else { - rendition.watch(); - } + let feed = &mut *feed; + // Fixed by the first batch, while each target is still its own declared duration. + let baseline = *feed + .baseline + .get_or_insert_with(|| added.iter().map(Rendition::target_duration).max().unwrap_or(1)); + let added: Vec<_> = added + .into_iter() + .map(|rendition| { + let target_duration = rendition.target_duration().max(baseline); + let rendition = Arc::new(rendition.pin(target_duration)); + rendition.label(feed.generation.clone()); + if let Some(err) = &feed.failed { + rendition.fail(err.clone()); + rendition.close(); + } else { + rendition.watch(); + } + feed.targets.push(Arc::downgrade(&rendition)); + rendition + }) + .collect(); // Pruned here, so a catalog that keeps replacing renditions holds only the live ones. A // replacement shares its predecessor's name, so its count survives. - let feed = &mut *feed; feed.targets.retain(|target| target.strong_count() > 0); - feed.targets.push(Arc::downgrade(rendition)); let live: BTreeSet = feed .targets .iter() @@ -436,6 +465,7 @@ impl Producer { .map(|rendition| (rendition.kind, rendition.name.clone())) .collect(); feed.discontinuities.renditions.retain(|key, _| live.contains(key)); + added } /// Reconcile the rendition set with a complete catalog snapshot. Removed or reconfigured @@ -498,6 +528,7 @@ impl Producer { } } + let mut added = Vec::new(); for (name, video) in &catalog.video.renditions { if !master::is_path_segment(name) { tracing::warn!( @@ -517,15 +548,10 @@ impl Producer { let Some(hls) = video.hls.clone() else { continue; }; - let rendition = match Rendition::video(name.clone(), video, source, hls, clock, self.fanout()) { - Ok(rendition) => Arc::new(rendition.after(handoffs.get(&key))), - Err(err) => { - tracing::warn!(rendition = name, %err, "ignoring unservable video rendition"); - continue; - } - }; - self.register(&rendition); - current.renditions.insert(key, rendition); + match Rendition::video(name.clone(), video, source, hls, clock, self.fanout()) { + Ok(rendition) => added.push(rendition.after(handoffs.get(&key))), + Err(err) => tracing::warn!(rendition = name, %err, "ignoring unservable video rendition"), + } } for (name, audio) in &catalog.audio.renditions { if !master::is_path_segment(name) { @@ -543,15 +569,15 @@ impl Producer { let Some(hls) = audio.hls.clone() else { continue; }; - let rendition = match Rendition::audio(name.clone(), audio, source, hls, clock, self.fanout()) { - Ok(rendition) => Arc::new(rendition.after(handoffs.get(&key))), - Err(err) => { - tracing::warn!(rendition = name, %err, "ignoring unservable audio rendition"); - continue; - } - }; - self.register(&rendition); - current.renditions.insert(key, rendition); + match Rendition::audio(name.clone(), audio, source, hls, clock, self.fanout()) { + Ok(rendition) => added.push(rendition.after(handoffs.get(&key))), + Err(err) => tracing::warn!(rendition = name, %err, "ignoring unservable audio rendition"), + } + } + for rendition in self.register(added) { + current + .renditions + .insert((rendition.kind, rendition.name.clone()), rendition); } if current.renditions.is_empty() && (!catalog.video.renditions.is_empty() || !catalog.audio.renditions.is_empty()) From bdc47852ad381e46a9d91ba1372597fa97a34dfd Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 30 Oct 2026 08:59:30 +0000 Subject: [PATCH 2/2] quest: plan follow-ups from the 2026-10-29 /quest-complete merges (#7274) * quest: plan follow-ups from the 2026-10-29 /quest-complete merges Ten quests and two quest edits from the follow-ups the merged and queued PRs raised, each decided with the maintainer, plus a fix to Smoke's docs, which named a pull-request trigger smoke.yml doesn't have. Co-authored-by: Claude Opus 5.5 --- quest/m0/README.md | 1 + quest/m0/backport-security-fixes.md | 24 ++++++++++++++++++++++++ quest/m0/nightly/README.md | 2 ++ quest/m0/nightly/kio-e0433.md | 16 ++++++++++++++++ quest/m0/nightly/tokio-features.md | 14 ++++++++++++++ quest/m0/test-flakes-2/README.md | 1 + quest/m0/test-flakes-2/rtc-dtls.md | 14 ++++++++++++++ quest/m1/README.md | 3 +++ quest/m1/c/README.md | 1 + quest/m1/c/consumer-cancel.md | 18 ++++++++++++++++++ quest/m1/cut-audit/README.md | 1 + quest/m1/cut-audit/accept-budget.md | 15 +++++++++++++++ quest/m1/ietf-dynamic-groups-resume.md | 14 ++++++++++++++ quest/m1/ietf-fill-end-cancel.md | 21 +++++++++++++++++++++ quest/m1/opus-preskip.md | 17 +++++++++++++++++ quest/m1/quic-api/native-web.md | 4 ++++ quest/m1/unbounded-groups/README.md | 5 ++++- test/smoke/AGENTS.md | 2 +- test/smoke/README.md | 2 +- 19 files changed, 172 insertions(+), 3 deletions(-) create mode 100644 quest/m0/backport-security-fixes.md create mode 100644 quest/m0/nightly/kio-e0433.md create mode 100644 quest/m0/nightly/tokio-features.md create mode 100644 quest/m0/test-flakes-2/rtc-dtls.md create mode 100644 quest/m1/c/consumer-cancel.md create mode 100644 quest/m1/cut-audit/accept-budget.md create mode 100644 quest/m1/ietf-dynamic-groups-resume.md create mode 100644 quest/m1/ietf-fill-end-cancel.md create mode 100644 quest/m1/opus-preskip.md diff --git a/quest/m0/README.md b/quest/m0/README.md index 10981fb27c3..d6c4b15d3a4 100644 --- a/quest/m0/README.md +++ b/quest/m0/README.md @@ -26,5 +26,6 @@ edge, which embeds moq-relay; it moved there on 2026-09-28. - [Release shutdown backport](/quest/m0/ffi-shutdown-backport.md) - `release` publishes a non-breaking moq-ffi with an async `drain()` and qmux sessions on the QUIC stream limit - [Backport @moq/flate bounds](/quest/m0/backport-flate-budget.md) - `@moq/flate` on `release` stops inflating past its cap and stops pinning pako scratch - [Backport audio groupDuration](/quest/m0/backport-audio-group-duration.md) - `@moq/publish` 0.5.4 on `release` can pack several Opus frames per group, making Cloudflare's relay drop audio less often +- [Backport the SETUP-path and iroh-key fixes](/quest/m0/backport-security-fixes.md) - `release` refuses a conflicting SETUP Path and keeps persisted iroh keys private, in one patch release - [CI cost and latency](/quest/m0/ci/README.md) - cloud CI runs only in a batched merge gate as one `just ci` pass per batch, expensive checks run nightly and gate `release`, caches move to R2, and runners are chosen last - [More tests under load](/quest/m0/test-flakes-2/README.md) - load-only and queue failures, one quest per flake, fixed at the cause, since each one fails a whole batch diff --git a/quest/m0/backport-security-fixes.md b/quest/m0/backport-security-fixes.md new file mode 100644 index 00000000000..c1503d18701 --- /dev/null +++ b/quest/m0/backport-security-fixes.md @@ -0,0 +1,24 @@ +# [S] Backport the SETUP-path and iroh-key fixes to release + +## Goal + +`release` refuses a moq-transport SETUP Path on WebTransport and WebSocket +bindings, as [moq-dev/moq#7206](https://github.com/moq-dev/moq/pull/7206) +fixed on main, and writes persisted iroh endpoint keys with private file +permissions, as [moq-dev/moq#7213](https://github.com/moq-dev/moq/pull/7213) +did. Both ship in one patch release with the published API unchanged. + +## Plan + +Decided 2026-10-30 (maintainer, `/quest-plan`): one quest and one PR against +`release` for both. They are small security fixes that ship in the same patch +release, so pairing them is simpler than the usual one PR per backport. + +- SETUP path: `release`'s handshake also accepts a SETUP Path that names a + different path or query than the request URI, so Tokio could authorize the + wrong path. Port #7206's refusal onto `release`'s handshake, with its test. +- iroh key: port #7213's private permissions for the persisted key file, with + its test. +- Version bumps are hand-picked, per `CONTRIBUTING.md`. + +Public API: none. Wire: a conflicting SETUP Path is refused, as on main. diff --git a/quest/m0/nightly/README.md b/quest/m0/nightly/README.md index a94e14047d5..9eed52d5682 100644 --- a/quest/m0/nightly/README.md +++ b/quest/m0/nightly/README.md @@ -41,3 +41,5 @@ Public API: none. Wire: none. - [Paired bench regressions bisected](/quest/m0/nightly/bench-regressions.md) - retirement/selection's +21-24% and two 10% rows fixed or shown to be noise - [Firefox's player closes every VideoFrame](/quest/m0/nightly/firefox-videoframe.md) - the Media job's Firefox player stops leaking an unclosed VideoFrame - [Gate stops hanging](/quest/m0/nightly/gate-hang.md) - `just gate` finishes instead of hanging to the timeout, and a hang names its module +- [moq-tokio's isolated feature builds pass](/quest/m0/nightly/tokio-features.md) - `Incoming::refuse` stops failing `tokio-features --all` on dead_code, so the rest of `rs features` runs +- [moq-uring's tests build on macOS and Windows](/quest/m0/nightly/kio-e0433.md) - the platform jobs stop failing with E0433 on `kio` in moq-uring's integration tests diff --git a/quest/m0/nightly/kio-e0433.md b/quest/m0/nightly/kio-e0433.md new file mode 100644 index 00000000000..6e626af2cca --- /dev/null +++ b/quest/m0/nightly/kio-e0433.md @@ -0,0 +1,16 @@ +# [S] moq-uring's tests build on macOS and Windows + +## Goal + +Nightly's `platform / macOS` and `platform / Windows` jobs compile again: the +23 `error[E0433]: cannot find module or crate kio` errors are gone. + +## Plan + +Seen in Nightly run 40885347517 (2026-10-29). moq-uring's integration tests +include `rs/moq-uring/src/transport/adapter.rs` by path +(`tests/integration/../../src/transport/adapter.rs`), and that file names +`kio`, which is not in scope for the test crate on those platforms. moq-uring +is Linux-only, so make its integration tests build to nothing off Linux, or +give the test crate what the included file needs. Prefer the first, so a +non-Linux build never compiles io_uring code. diff --git a/quest/m0/nightly/tokio-features.md b/quest/m0/nightly/tokio-features.md new file mode 100644 index 00000000000..e48afd80efe --- /dev/null +++ b/quest/m0/nightly/tokio-features.md @@ -0,0 +1,14 @@ +# [XS] moq-tokio's isolated feature builds pass + +## Goal + +Nightly's `rs features` job gets past `just rs tokio-features --all`, so +every later step in it runs again, including the rustdoc check. + +## Plan + +`moq_tokio`'s `Incoming::refuse` is called only from tests, so one isolated +feature build fails on `dead_code` and stops the job. Either a non-test caller +should use it, or it should be compiled only where it is used. Pick whichever +keeps the API honest: drop it from the public surface if nothing outside tests +needs it. diff --git a/quest/m0/test-flakes-2/README.md b/quest/m0/test-flakes-2/README.md index 018411102cd..680bcd05bfc 100644 --- a/quest/m0/test-flakes-2/README.md +++ b/quest/m0/test-flakes-2/README.md @@ -54,3 +54,4 @@ Public API: none. Wire: none. - [IETF22 fallback](/quest/m0/test-flakes-2/ietf22-fallback.md) - an IETF22 browser viewer follows a fallback within the media lane's bound, keeping its session and its audio - [Tests own their temp directories](/quest/m0/test-flakes-2/temp-paths.md) - concurrent test processes stop overwriting each other's fixed temp files +- [moq-rtc's session-end test survives load](/quest/m0/test-flakes-2/rtc-dtls.md) - its DTLS handshake stops timing out on a busy host diff --git a/quest/m0/test-flakes-2/rtc-dtls.md b/quest/m0/test-flakes-2/rtc-dtls.md new file mode 100644 index 00000000000..c2a1cbfcd6a --- /dev/null +++ b/quest/m0/test-flakes-2/rtc-dtls.md @@ -0,0 +1,14 @@ +# [S] moq-rtc's session-end test survives load + +## Goal + +`a_session_ending_without_a_delete_ends_its_tracks` in moq-rtc stops failing +with a DTLS handshake timeout when the host is busy, fixed at its cause. + +## Plan + +Seen during [moq-dev/moq#6987](https://github.com/moq-dev/moq/pull/6987)'s +local `just check`: it failed once under load, then passed alone and on the +full rerun. Find what bounds the handshake by wall clock (a real timer in the +test or in the DTLS path) and drive it on the simulated clock, or measure it +from progress rather than elapsed time. diff --git a/quest/m1/README.md b/quest/m1/README.md index cf6465ce776..fe863117b99 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -153,11 +153,14 @@ removed). - [moq-quic's API improves on quinn's](/quest/m1/quic-api/README.md) - moq-quic and both QUIC drivers ship one mirrored API: `send::`/`recv::` namespaces, one error per direction, consuming terminal operations, plain configs, no quinn baggage - [On-demand JavaScript FETCH](/quest/m1/js-fetch-on-demand.md) - browser publishers answer IETF FETCH for evicted or uncached groups through the JS ranges request surface - [Rust FETCH parity](/quest/m1/ietf-fetch-parity.md) - Rust finishes an answered joining FETCH's head, refuses a lost head with DOES_NOT_EXIST, and sends no timestamps without TIMESCALE, as the JS publisher does +- [Rust cancels an unclaimed fill head when a subscription ends](/quest/m1/ietf-fill-end-cancel.md) - SUBSCRIPTION_ENDED cancels, not finishes, a fill no group was sent for, as in JS - [SUBSCRIBE honors the properties opt-out](/quest/m1/subscribe-timestamps.md) - the Rust publisher sends untimed objects to a SUBSCRIBE that declines Track Properties, and the Rust subscriber asks for them when it needs timestamps +- [A resumed untimed copy keeps DYNAMIC_GROUPS](/quest/m1/ietf-dynamic-groups-resume.md) - opting out of properties on a draft-22 resume no longer forgets DYNAMIC_GROUPS - [Rust marks a lost listed group unknown](/quest/m1/ietf-publisher-unknown-range.md) - the Rust IETF publisher sends End of Unknown Range for a listed group it can't serve, after the publisher's open quests land - [Native rung disable](/quest/m1/simulcast-rung-disable.md) - OBS stops sending the top renditions its grant cannot fund, as the Rust/FFI publishers do, and a shaped uplink through moq-ffi proves the resume - [Audio jitter target](/quest/m1/audio-jitter-target/README.md) - the playout target is default in both languages; a manual browser proof and a native trace replay remain - [A/V clock](/quest/m1/av-clock.md) - the audio playhead drives Sync.reference while audio plays, through per-track sync handles +- [Decoding from a track's first packet keeps its start](/quest/m1/opus-preskip.md) - moq-audio drops only OpusHead's pre-skip from a track's first packet, keeping the 80 ms warmup for mid-stream joins - [Container reads drop backfill](/quest/m1/read-backfill.md) - the JS container consumer drops groups below its read cursor like Rust - [Buffered playback subscribes in ascending order](/quest/m1/buffered-ascending.md) - a buffered `` asks for the oldest group first, so a voice reply's opening arrives first, and audio's head hold shrinks to the floor - [The publish controls stay visible without a preview](/quest/m1/publish-controls.md) - ``'s controls no longer collapse with a live camera and no preview diff --git a/quest/m1/c/README.md b/quest/m1/c/README.md index 3043818c8de..8c65a7e221e 100644 --- a/quest/m1/c/README.md +++ b/quest/m1/c/README.md @@ -30,3 +30,4 @@ Public API: moq-c gains each m1 binding feature. Wire: none. ## Required - [API gaps](/quest/m1/c/api-gaps.md) - one malformed-epoch error code, an audio enabled query, and a relay hops test +- [Every consumer cancels while pending](/quest/m1/c/consumer-cancel.md) - catalog, raw, datagram, and media consumers end cleanly on cancel before their subscription is accepted diff --git a/quest/m1/c/consumer-cancel.md b/quest/m1/c/consumer-cancel.md new file mode 100644 index 00000000000..f49e10e4731 --- /dev/null +++ b/quest/m1/c/consumer-cancel.md @@ -0,0 +1,18 @@ +# [S] Every moq-c consumer cancels while its subscription is pending + +## Goal + +Cancelling a hand-written moq-c catalog, raw track, datagram, or media +consumer ends it with a clean final callback even while it waits for its +subscription to be accepted, as the JSON consumers do since +[moq-dev/moq#7082](https://github.com/moq-dev/moq/pull/7082). + +## Plan + +Decided 2026-10-30 (maintainer, `/quest-plan`): the hand-written crate ships +at the cut and the [generated C line](/quest/m2/c/README.md) follows it, so +fix this bug for the release, but skip converting the consumer loops to kio +polling and changing the producers: the generated binding replaces both. + +Reuse #7082's `Consume::json_subscribe` pattern for the other consumers, with +a test per consumer that cancels an unanswered subscription. diff --git a/quest/m1/cut-audit/README.md b/quest/m1/cut-audit/README.md index f8d2ab30db7..b1682a48e53 100644 --- a/quest/m1/cut-audit/README.md +++ b/quest/m1/cut-audit/README.md @@ -58,6 +58,7 @@ leaving JS-only redesigns of `js/net` to [rs2ts](/quest/m2/rs2ts/README.md). - [A reserved group survives a route returning](/quest/m1/cut-audit/reserved-route-return.md) - a route flip A to B to A no longer panics a peeked reader - [A description-less AAC rendition means one thing](/quest/m1/cut-audit/aac-description-less.md) - every player and exporter agrees on the frame format - [The export clock keeps only the rules admission still needs](/quest/m1/cut-audit/jitter-admission.md) - the clock rules the time and byte admission bound made redundant are measured and removed +- [Stream-accept loops yield on a per-poll budget](/quest/m1/cut-audit/accept-budget.md) - a peer opening many streams cannot monopolize a session driver - [Rust and JS accept the same catalogs](/quest/m1/cut-audit/catalog-parity.md) - one strictness, per rendition, with a shared fixture corpus - [Every relay runtime honors or refuses each listen setting](/quest/m1/cut-audit/uring-listen-config.md) - io_uring stops ignoring preferred addresses diff --git a/quest/m1/cut-audit/accept-budget.md b/quest/m1/cut-audit/accept-budget.md new file mode 100644 index 00000000000..18271f66ebc --- /dev/null +++ b/quest/m1/cut-audit/accept-budget.md @@ -0,0 +1,15 @@ +# [S] Stream-accept loops yield on a per-poll budget + +## Goal + +A peer that opens many streams at once cannot keep a session's driver busy: +every peer-driven stream-accept loop in moq-net yields after a fixed budget per +poll, as the receive loops do since +[moq-dev/moq#7034](https://github.com/moq-dev/moq/pull/7034). + +## Plan + +Today accept loops are bounded only by MAX_STREAMS credit, so one poll can +accept up to the 10,000-stream default. Charge the same `kio::coop::Budget` +per accepted stream, in lite and moq-transport, Rust and JS. Add a flood test +like #7034's that shows a sibling still makes progress. diff --git a/quest/m1/ietf-dynamic-groups-resume.md b/quest/m1/ietf-dynamic-groups-resume.md new file mode 100644 index 00000000000..e534c2a5ccb --- /dev/null +++ b/quest/m1/ietf-dynamic-groups-resume.md @@ -0,0 +1,14 @@ +# [XS] A resumed untimed copy keeps DYNAMIC_GROUPS + +## Goal + +On moq-transport draft 22, a resumed copy of an untimed track that opts out of +Track Properties still knows the track's DYNAMIC_GROUPS, as its first +subscription did. + +## Plan + +Found in [moq-dev/moq#7085](https://github.com/moq-dev/moq/pull/7085): opting +out of properties on resume drops DYNAMIC_GROUPS along with TIMESCALE. Carry +it from the first subscription, or keep asking for it when the track has it. +Add a resume test on draft 22. diff --git a/quest/m1/ietf-fill-end-cancel.md b/quest/m1/ietf-fill-end-cancel.md new file mode 100644 index 00000000000..9f4be21be03 --- /dev/null +++ b/quest/m1/ietf-fill-end-cancel.md @@ -0,0 +1,21 @@ +# [S] Rust cancels an unclaimed fill head when a subscription ends + +## Goal + +When SUBSCRIPTION_ENDED arrives while a fill head is still unclaimed, Rust's +moq-transport subscriber cancels that fill instead of finishing it, as the JS +subscriber does since [moq-dev/moq#7089](https://github.com/moq-dev/moq/pull/7089), +so a reader never sees a clean end for a group it was never sent. + +## Plan + +Planned 2026-10-30 (maintainer, `/quest-plan`). The finish is `Fill::end` in +`rs/moq-net/src/ietf/subscriber.rs`. Add a test that ends a subscription with +an unclaimed fill head and expects the cancel, in both languages' terms. + +[IETF fill refill](/quest/m2/ietf-fill-refill.md) would later remove this +fill handoff entirely; this fix is for the release cut, not a reason to wait. + +## Related + +- [IETF fill refill](/quest/m2/ietf-fill-refill.md) - replaces the fill claim and handoff this touches diff --git a/quest/m1/opus-preskip.md b/quest/m1/opus-preskip.md new file mode 100644 index 00000000000..55fe1a2316b --- /dev/null +++ b/quest/m1/opus-preskip.md @@ -0,0 +1,17 @@ +# [S] Decoding from a track's first packet keeps its start + +## Goal + +moq-audio decoding an Opus track from its first packet outputs everything but +the codec's pre-skip, so recordings keep their first 80 ms and a track shorter +than that decodes to something, in every binding. + +## Plan + +Decided 2026-10-30 (maintainer, `/quest-plan`): from the track's first packet, +drop only the OpusHead pre-skip, as the codec defines. A decoder that joins +mid-stream keeps today's 80 ms warmup, since it has no history to warm up +from. Found in [moq-dev/moq#7033](https://github.com/moq-dev/moq/pull/7033). + +Test both cases: a short finished track decodes to its length minus +pre-skip, and a mid-stream join still drops its warmup. diff --git a/quest/m1/quic-api/native-web.md b/quest/m1/quic-api/native-web.md index be24ee2efef..202a731bfb9 100644 --- a/quest/m1/quic-api/native-web.md +++ b/quest/m1/quic-api/native-web.md @@ -50,6 +50,10 @@ Align the two stacks while each gets its impl: uring to the same shape. Test with pending × ready headers and fragmented arrival, preserving FIN handling, the held control streams, and stream credit (2026-10-27 audit, maintainer). +- A cleanly finished stream ends `closed()`: today moq-tokio's adapter waits + only for a reset, so a peer's clean FIN never returns it + ([moq-dev/moq#6950](https://github.com/moq-dev/moq/pull/6950) fixed the same + bug in moq-uring). Test a FIN on both stacks (maintainer, 2026-10-30). - `transport::poll_op` and `OpSlot` move to `moq_tokio::iroh`, their last user, when moq-tokio's adapter goes. - moq-relay's io_uring server and its tests call the uring session through diff --git a/quest/m1/unbounded-groups/README.md b/quest/m1/unbounded-groups/README.md index dd28c95df7d..0e7f9279e34 100644 --- a/quest/m1/unbounded-groups/README.md +++ b/quest/m1/unbounded-groups/README.md @@ -142,7 +142,10 @@ origin can regenerate data from disk or an archive. This epic owns the end-to-end test: a relay chain carries one live group well past the old caps. A late joiner gets its head through a flight and hands over to the live copy, and a live reader keeps the tail, over lite and -moq-transport, with memory held near 32 MB per copy. +moq-transport, with memory held near 32 MB per copy. It also carries a long +compressed group through a small cache pool with a plain reader on a legacy +wire, which [moq-dev/moq#6993](https://github.com/moq-dev/moq/pull/6993) +covered only at the model layer (maintainer, 2026-10-30). ## Required diff --git a/test/smoke/AGENTS.md b/test/smoke/AGENTS.md index 029e926bdcb..5cb7d4c5d9c 100644 --- a/test/smoke/AGENTS.md +++ b/test/smoke/AGENTS.md @@ -12,7 +12,7 @@ Cross-language interop smoke for the published MoQ packages. - Hang media (`smoke.sh`), Cloudflare, and moxygen stay on separate lanes. - In `relays.sh`, only `--required` relays fail the run. The default required relay is moq-dev's own. - In `runner.py`, only moq-dev's clients against this checkout's relay fail the run. Every other upstream Docker pair is reported only. -- Wire new lanes into `.github/workflows/smoke.yml`. It runs on pull requests that touch `test/smoke/`, and nightly. +- Wire new lanes into `.github/workflows/smoke.yml`. It runs nightly, on pushes to `main` that touch `test/smoke/`, and on dispatch; dispatch it on your branch to try a change before merging. - New dependencies use the newest stable version, except the pins `freshness.sh` enforces. # Development diff --git a/test/smoke/README.md b/test/smoke/README.md index 7e9986713bb..74b6a6df9d2 100644 --- a/test/smoke/README.md +++ b/test/smoke/README.md @@ -19,7 +19,7 @@ This suite installs the published moq packages and checks that they exchange med Hang media, Cloudflare, and moxygen each have their own lane. -CI runs the matrix nightly and on pull requests that touch `test/smoke/`: [`.github/workflows/smoke.yml`](../../.github/workflows/smoke.yml). +CI runs the matrix nightly, on pushes to `main` that touch `test/smoke/`, and on dispatch: [`.github/workflows/smoke.yml`](../../.github/workflows/smoke.yml). ## Clients