From 85248eed3e07eecd782c57a100b36622225790b4 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 10:12:29 -0800
Subject: [PATCH 01/10] chore(quest): claim quest/m2/compose/layout.md

Quest-Claim: e97694e335dd9933

From 5f85208d562a77f232e11ede73a5d513deca2a6d Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 10:32:09 -0800
Subject: [PATCH 02/10] wip: the studio publishes a composition

---
 rs/moq-scene/Cargo.toml         |   2 +-
 rs/moq-scene/src/collection.rs  |  62 ++--
 rs/moq-scene/src/composition.rs | 610 ++++++++++++++++++++++++++++++++
 rs/moq-scene/src/compositor.rs  |  16 +-
 rs/moq-scene/src/layout.rs      | 454 ------------------------
 rs/moq-scene/src/lib.rs         |   9 +-
 rs/moq-scene/src/publish.rs     | 231 +++++++-----
 rs/moq-scene/src/source.rs      | 357 ++++++++++++++-----
 rs/moq-studio/src/engine.rs     | 241 +++++++++----
 rs/moq-studio/src/main.rs       |  17 +-
 rs/moq-studio/src/ui.rs         |  27 +-
 rs/moq-studio/src/watch.rs      | 531 +++++++++++++++++----------
 12 files changed, 1593 insertions(+), 964 deletions(-)
 create mode 100644 rs/moq-scene/src/composition.rs
 delete mode 100644 rs/moq-scene/src/layout.rs

diff --git a/rs/moq-scene/Cargo.toml b/rs/moq-scene/Cargo.toml
index 999c472..9091494 100644
--- a/rs/moq-scene/Cargo.toml
+++ b/rs/moq-scene/Cargo.toml
@@ -99,7 +99,7 @@ x11rb = { version = "0.13", features = ["dri3"] }
 wayland-client = "0.31"
 
 [dev-dependencies]
-# Reads the layer layout track back as a player would.
+# Reads the composition track back as a player would.
 moq-json = { workspace = true, features = ["async"] }
 # An encoder on every machine, for the source track and replay tests.
 moq-video = { workspace = true, features = ["openh264"] }
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index 56784c7..0775098 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -40,13 +40,14 @@ pub struct Collection {
 	/// wherever the source is placed. A source without an entry is unfiltered.
 	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
 	pub video: BTreeMap<String, Video>,
-	/// The sources published independently, by name: each one's own track
-	/// goes to the relay beside the program, and the
-	/// [layer layout](crate::layout) says where viewers show it over the
+	/// The sources published independently, by name: each reaches viewers
+	/// as a broadcast of its own, a local source's track in one the studio
+	/// publishes and a broadcast source as its publisher's, and the
+	/// [composition](crate::composition) says where viewers show it over the
 	/// program and how they play its sound. The program and every audio
-	/// scene's mix leave it out. Only a source with a track of its own can
-	/// be, and not one with its background removed, since its track would
-	/// show the background. Wherever it is placed, it takes only what every
+	/// scene's mix leave it out. Only a broadcast or a source with a track of
+	/// its own can be, and not one with its background removed, since its
+	/// track would show the background. Wherever it is placed, it takes only what every
 	/// player can reproduce, and no scene that another scene draws holds it.
 	#[serde(default, skip_serializing_if = "BTreeSet::is_empty")]
 	pub published: BTreeSet<String>,
@@ -469,11 +470,11 @@ impl Collection {
 					"`{name}` draws scene `{scene}`, which is not a scene"
 				)));
 			}
-			if let Source::Layer { broadcast, .. } = source
-				&& !matches!(self.sources.get(broadcast), Some(Source::Broadcast { .. }))
+			if let Source::Layer { clock, .. } = source
+				&& !matches!(self.sources.get(clock), Some(Source::Broadcast { .. }))
 			{
 				return Err(Error::Invalid(format!(
-					"`{name}` plays on `{broadcast}`, which is not a broadcast source"
+					"`{name}` plays on `{clock}`, which is not a broadcast source"
 				)));
 			}
 			let Source::Clone { source } = source else { continue };
@@ -518,10 +519,17 @@ impl Collection {
 					"`{name}` is published, but there is no such source"
 				)));
 			};
-			if !source.publishes() {
+			if !source.independent() {
 				return Err(Error::Invalid(format!(
-					"`{name}` cannot be published independently: only a camera, display, window, microphone, \
-					 system audio, color, image, media, or replay source has a track of its own"
+					"`{name}` cannot be published independently: only a broadcast, or a camera, display, window, \
+					 microphone, system audio, color, image, media, or replay source with a track of its own, can be"
+				)));
+			}
+			let segment = !name.contains('/') && moq_net::Path::new(name).is_ok() && name != "." && name != "..";
+			if source.publishes() && !segment {
+				return Err(Error::Invalid(format!(
+					"`{name}` is published independently, so its name is one segment of its broadcast's path: no \
+					 `/`, not `.` or `..`, and a `\\` only before another"
 				)));
 			}
 			if self
@@ -638,9 +646,9 @@ impl Collection {
 	}
 
 	/// Refuse an item showing a source published independently that the
-	/// layer layout cannot carry: one blended or filtered past opacity, which
+	/// composition cannot carry: one blended or filtered past opacity, which
 	/// not every player can reproduce, or one in a scene another scene draws,
-	/// which the layout cannot place.
+	/// which the composition cannot place.
 	fn validate_published(&self) -> Result<(), Error> {
 		let nested: BTreeSet<&str> = self
 			.sources
@@ -1254,7 +1262,7 @@ fn is_true(value: &bool) -> bool {
 /// What a source or item is drawn through, in order.
 ///
 /// Every filter is a pure function of the picture, so every host that composes
-/// a scene with moq-scene draws it the same way, and it travels in a layout as
+/// a scene with moq-scene draws it the same way, and it travels in a composition as
 /// its name and settings. The CSS ones mean what the CSS Filter Effects
 /// function of the same name does, in the gamma-encoded sRGB the canvas holds,
 /// with lengths in canvas pixels. A filter naming another source uses that
@@ -1855,18 +1863,22 @@ pub enum Source {
 	/// same frame. A scene drawing it cannot go on program, and the top layer
 	/// cannot draw it, since either would draw the program into itself.
 	Program,
-	/// A source a studio broadcast publishes independently, played from the
-	/// broadcast the [`Source::Broadcast`] called `broadcast` plays, on that
-	/// source's playout clock, so it lands with the program as the
-	/// [layer layout](crate::layout) places it. Never in a scene file: only
-	/// a player of the layout makes one.
+	/// A broadcast a [composition](crate::composition) lists, played on the
+	/// playout clock of the [`Source::Broadcast`] called `clock`, its
+	/// timestamps moved `offset` onto that clock's, so it lands with the
+	/// program as the composition places it. Never in a scene file: only a
+	/// player of the composition makes one.
 	#[serde(skip)]
 	Layer {
-		/// The broadcast source whose broadcast and clock it plays on.
-		broadcast: String,
-		/// Its entry under the broadcast catalog's
-		/// [`SECTION`](crate::publish::SECTION) `sources`.
-		source: String,
+		/// The broadcast source whose clock it plays on: the program.
+		clock: String,
+		/// Its broadcast's path.
+		path: String,
+		/// The stream it must be, or `None` for whichever serves the path.
+		instance: Option<moq_net::Instance>,
+		/// Microseconds added to its timestamps to put them on `clock`'s
+		/// timeline. A change plays on without opening the broadcast again.
+		offset: i64,
 	},
 }
 
diff --git a/rs/moq-scene/src/composition.rs b/rs/moq-scene/src/composition.rs
new file mode 100644
index 0000000..1f8acf8
--- /dev/null
+++ b/rs/moq-scene/src/composition.rs
@@ -0,0 +1,610 @@
+//! The composition: a broadcast of the studio's own whose catalog lists other
+//! broadcasts, the program and each source published independently, local or
+//! a guest's, with where and when each shows and how its sound mixes, so a
+//! player places each as the studio would have.
+//!
+//! The program leaves a published source out, so a player draws each
+//! [picture](Composition::pictures) over the program, back to front, and mixes
+//! each [sound](Child::sound) with the program's audio. A composition carries
+//! only what every player can reproduce: a picture's place, crop, opacity,
+//! visibility, and keyframes, and a sound's gain, mute, pan, and delay.
+//! [`Collection::validate`] refuses a published source placed with anything
+//! more, such as a blur or a blend mode.
+//!
+//! Each listed broadcast keeps its own timeline. The composition's media clock
+//! is the program's, and each [`Child`] carries the offset that puts its
+//! broadcast's timestamps on it: zero for a local source, which the studio
+//! stamps on the program's clock, and for a guest, how far its stamps sat from
+//! the program's when the studio played them.
+//!
+//! It travels as JSON on [`TRACK`] in snapshot mode, in a broadcast of its own
+//! [beneath the program's](PATH), so a viewer joining late reads the
+//! composition in force. The format is the studio's own, provisional until
+//! hang specifies a composition.
+
+use std::collections::BTreeMap;
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+use serde_with::{DisplayFromStr, DurationMicroSeconds, serde_as};
+
+use crate::Error;
+use crate::collection::{Audio, Collection, Item, Layer, Size};
+
+/// The composition broadcast's track carrying the composition, listed in its
+/// catalog's `json` section.
+pub const TRACK: &str = "live.kixel.studio.composition";
+
+/// Where the composition's broadcast is, beneath the program's.
+pub const PATH: &str = "composition";
+
+/// Where each local source published independently has a broadcast of its
+/// own, beneath the program's, under its name: `<program>/source/<name>`.
+pub const SOURCES: &str = "source";
+
+/// How far a child's offset may wander before a new composition carries it.
+///
+/// The offset is measured from a playout clock that re-anchors on every write
+/// of a guest's sound, so it jitters by a millisecond or so while the guest
+/// plays steadily. Well under the 45 ms of sound leading the picture a viewer
+/// can detect (ITU-R BT.1359), it keeps a viewer's guest in step with the
+/// studio's without a group per frame.
+pub const DRIFT: Duration = Duration::from_millis(10);
+
+/// Where and when each broadcast the composition lists shows or plays.
+#[serde_as]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Composition {
+	/// The format's version, first so a reader of another one fails on it.
+	pub version: Version,
+	/// The program's canvas, which pictures are placed on in pixels.
+	pub canvas: Size,
+	/// When the scene on program went on, on the composition's media clock:
+	/// the moment its pictures' keyframes play from. In microseconds on the
+	/// wire.
+	#[serde_as(as = "DurationMicroSeconds<u64>")]
+	pub start: Duration,
+	/// The program, whose clock the composition's is.
+	pub program: Program,
+	/// Each source published independently that a picture shows or the
+	/// program's audio plays, by source name.
+	#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+	pub sources: BTreeMap<String, Child>,
+	/// Each picture over the program, back to front: the scene on program's,
+	/// then the top layer's. Each is a scene file item whose `source` names a
+	/// key of [`sources`](Self::sources), whose filters are only opacity, and
+	/// whose keyframes play from [`start`](Self::start).
+	#[serde(default, skip_serializing_if = "Vec::is_empty")]
+	pub pictures: Vec<Item>,
+}
+
+impl Composition {
+	/// The composition of `collection` with the scene called `scene` on
+	/// program since `start` on the media clock, or no scene for `None`,
+	/// drawn over `program`. Each source published independently is listed
+	/// as `children` locates it, its sound filled in; one `children` leaves
+	/// out, such as a guest offline, is left out with its pictures, as the
+	/// studio shows nothing of it either.
+	pub fn new(
+		collection: &Collection,
+		scene: Option<&str>,
+		start: Duration,
+		program: Program,
+		mut children: BTreeMap<String, Child>,
+	) -> Self {
+		let pictures: Vec<Item> = pictures(collection, scene, true)
+			.into_iter()
+			.filter(|item| children.contains_key(&item.source))
+			.collect();
+		let heard = collection.program_audio().map(|audio| collection.heard(audio));
+		for source in heard.into_iter().flatten() {
+			if let Some(child) = children.get_mut(source) {
+				child.sound = Some(collection.audio.get(source).cloned().unwrap_or_default());
+			}
+		}
+		children.retain(|name, child| child.sound.is_some() || pictures.iter().any(|item| item.source == *name));
+		Self {
+			version: Version,
+			canvas: Size {
+				width: collection.canvas.width,
+				height: collection.canvas.height,
+			},
+			start,
+			program,
+			sources: children,
+			pictures,
+		}
+	}
+}
+
+/// Each item of the scene called `scene`, then of the top layer if `top`,
+/// showing a source published independently, back to front, shown or hidden:
+/// its `source` names the published source, and its crop and filters fold in
+/// its source's, as the compositor draws them.
+pub(crate) fn pictures(collection: &Collection, scene: Option<&str>, top: bool) -> Vec<Item> {
+	let scene = scene.filter(|scene| collection.scene(scene).is_some());
+	let places = scene.map(Layer::scene).into_iter().chain(top.then(Layer::top));
+	let mut pictures = Vec::new();
+	for place in places {
+		for item in collection.items(&place).unwrap_or_default() {
+			let source = collection.capture(&item.source);
+			if !collection.published.contains(source) {
+				continue;
+			}
+			pictures.push(Item {
+				source: source.to_string(),
+				crop: collection.crop(item),
+				filters: collection.filters(item).cloned().collect(),
+				..item.clone()
+			});
+		}
+	}
+	pictures
+}
+
+/// The format's version: deserializing refuses any but
+/// [`Version::CURRENT`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(into = "u32", try_from = "u32")]
+pub struct Version;
+
+impl Version {
+	/// The version this build reads and writes. Version 1 was the layer
+	/// layout, which named tracks of the program's broadcast.
+	pub const CURRENT: u32 = 2;
+}
+
+impl From<Version> for u32 {
+	fn from(_: Version) -> Self {
+		Version::CURRENT
+	}
+}
+
+impl TryFrom<u32> for Version {
+	type Error = String;
+
+	fn try_from(found: u32) -> Result<Self, Self::Error> {
+		match found {
+			Self::CURRENT => Ok(Self),
+			found => Err(format!(
+				"composition version {found} is not supported; this build reads version {}",
+				Self::CURRENT
+			)),
+		}
+	}
+}
+
+/// The program's broadcast.
+#[serde_as]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Program {
+	/// Its path, relative to the composition's, as hang's references are.
+	pub broadcast: moq_net::path::Relative,
+	/// The stream whose timeline the composition's clock is, so a player
+	/// waits for it rather than placing anything on another's.
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	#[serde_as(as = "Option<DisplayFromStr>")]
+	pub instance: Option<moq_net::Instance>,
+}
+
+/// One broadcast the composition places over the program or mixes with it.
+#[serde_as]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Child {
+	/// Its path, relative to the composition's, as hang's references are.
+	pub broadcast: moq_net::path::Relative,
+	/// The stream [`offset`](Self::offset) holds for, or `None` for whichever
+	/// serves the path, as for a source the studio stamps on the program's
+	/// clock. A relay-minted instance is never named, since it cannot match
+	/// another relay's.
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	#[serde_as(as = "Option<DisplayFromStr>")]
+	pub instance: Option<moq_net::Instance>,
+	/// Microseconds added to its timestamps to put them on the composition's
+	/// clock, negative for a broadcast stamped ahead of it.
+	#[serde(default, skip_serializing_if = "is_zero")]
+	pub offset: i64,
+	/// Its gain, mute, pan, and delay in the program's audio, or `None` when
+	/// the program's audio does not play it.
+	#[serde(default, skip_serializing_if = "Option::is_none")]
+	pub sound: Option<Audio>,
+	/// The subscription priority a viewer fetches its tracks at, as moq-lite
+	/// orders them.
+	#[serde(default, skip_serializing_if = "is_zero")]
+	pub priority: i8,
+	/// Whether a viewer may switch it off.
+	#[serde(default, skip_serializing_if = "std::ops::Not::not")]
+	pub toggle: bool,
+}
+
+impl Child {
+	/// A broadcast at `broadcast` relative to the composition's, of the
+	/// stream `instance` if named, `offset` microseconds from the
+	/// composition's clock, not yet heard.
+	pub fn new(broadcast: moq_net::path::Relative, instance: Option<moq_net::Instance>, offset: i64) -> Self {
+		Self {
+			broadcast,
+			instance: instance.filter(|instance| !instance.is_minted()),
+			offset,
+			sound: None,
+			priority: 0,
+			toggle: false,
+		}
+	}
+}
+
+fn is_zero<T: Default + PartialEq>(value: &T) -> bool {
+	*value == T::default()
+}
+
+/// Publishes the composition on [`TRACK`] in a broadcast of its own, listed
+/// in its catalog on the program's clock.
+pub struct Publisher {
+	catalog: moq_mux::catalog::Producer,
+	broadcast: moq_net::broadcast::Producer,
+	/// The track, and the composition last written to it, once there is one.
+	track: Option<(moq_mux::json::Snapshot<Composition>, Option<Composition>)>,
+}
+
+impl Publisher {
+	/// Publish in `broadcast`, whose catalog advertises `clock`, the
+	/// program's, from the first [`update`](Self::update).
+	pub fn new(broadcast: &mut moq_net::broadcast::Producer, clock: moq_mux::Clock) -> Result<Self, Error> {
+		let config = moq_mux::catalog::Config::default().with_clock(clock);
+		let catalog = moq_mux::catalog::Producer::new(broadcast, config)?;
+		Ok(Self {
+			catalog,
+			broadcast: broadcast.clone(),
+			track: None,
+		})
+	}
+
+	/// Publish `composition`, stamped `at` on the media clock, when it took
+	/// effect, unless it is the one published already, starting the track and
+	/// its listing if there is none. A child's offset within [`DRIFT`] of the
+	/// one published for the same stream keeps the published one.
+	pub fn update(&mut self, mut composition: Composition, at: moq_net::Timestamp) -> Result<(), Error> {
+		let (snapshot, published) = match &mut self.track {
+			Some(track) => track,
+			None => {
+				let info = moq_net::track::Info::default()
+					.with_timescale(moq_mux::Clock::TIMESCALE)
+					.with_priority(hang::catalog::PRIORITY.catalog)
+					.with_compress(true);
+				let created = self.broadcast.create_track(TRACK, info)?;
+				// Each composition whole in a group of its own, so a joiner needs
+				// no refresh to read it.
+				let options = moq_mux::json::Options::default().with_deltas(false);
+				let config = moq_mux::json::Config::default();
+				let snapshot = self.catalog.json_snapshot(created, config, options)?;
+				self.track.insert((snapshot, None))
+			}
+		};
+		if let Some(published) = published.as_ref() {
+			steady(&mut composition, published);
+			if *published == composition {
+				return Ok(());
+			}
+		}
+		snapshot.update(&composition, at)?;
+		*published = Some(composition);
+		Ok(())
+	}
+
+	/// End the track and the catalog, so a reader reaches their end.
+	pub fn finish(&mut self) -> Result<(), Error> {
+		if let Some((snapshot, _)) = self.track.take() {
+			snapshot.finish()?;
+		}
+		Ok(self.catalog.finish()?)
+	}
+}
+
+/// Keep each child's offset `published` carries for the same stream while the
+/// new one is within [`DRIFT`] of it.
+fn steady(composition: &mut Composition, published: &Composition) {
+	let drift = DRIFT.as_micros() as i64;
+	for (name, child) in &mut composition.sources {
+		let Some(before) = published.sources.get(name) else { continue };
+		if before.broadcast == child.broadcast
+			&& before.instance == child.instance
+			&& before.offset.abs_diff(child.offset) <= drift.unsigned_abs()
+		{
+			child.offset = before.offset;
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::collection::{Blend, Filter, Keyframe, Rect, Rgba, Scene, Source};
+	use moq_mux::catalog::Stream;
+
+	fn rect(x: f32) -> Rect {
+		Rect {
+			x,
+			y: 0.0,
+			width: 4.0,
+			height: 4.0,
+		}
+	}
+
+	fn relative(path: &str) -> moq_net::path::Relative {
+		moq_net::path::Relative::new(path).unwrap()
+	}
+
+	/// A camera, a microphone, and a guest published, the camera placed over
+	/// a color in scene `live`, behind a clone of itself in the top layer, the
+	/// guest in scene `live`, and the microphone and the guest in the
+	/// program's audio scene.
+	fn collection() -> Collection {
+		let mut collection = Collection::new();
+		collection.sources.insert(
+			"bg".into(),
+			Source::Color {
+				color: Rgba([0, 0, 0, 255]),
+			},
+		);
+		collection.sources.insert("cam".into(), Source::Camera { id: None });
+		collection
+			.sources
+			.insert("pip".into(), Source::Clone { source: "cam".into() });
+		collection.sources.insert("mic".into(), Source::Microphone { id: None });
+		collection.sources.insert(
+			"alice".into(),
+			Source::Broadcast {
+				path: "guests/alice/camera.hang".into(),
+			},
+		);
+		collection
+			.published
+			.extend(["cam".into(), "mic".into(), "alice".into()]);
+		let mut cam = Item::new("cam", rect(0.0));
+		cam.filters = vec![Filter::Opacity { amount: 0.5 }];
+		cam.keyframes = vec![Keyframe {
+			x: 10.0,
+			..Keyframe::new(Duration::from_secs(1))
+		}];
+		collection.scenes = vec![Scene {
+			items: vec![
+				Item::new("bg", Rect::fill(&collection.canvas)),
+				cam,
+				Item::new("alice", rect(20.0)),
+			],
+			..Scene::new("live")
+		}];
+		collection.top = vec![Item::new("pip", rect(8.0))];
+		collection.audio_scenes[0].sounds.extend(["mic".into(), "alice".into()]);
+		collection.audio.insert(
+			"mic".into(),
+			Audio {
+				gain: 0.5,
+				delay: Duration::from_millis(80),
+				..Default::default()
+			},
+		);
+		collection.validate().unwrap();
+		collection
+	}
+
+	fn program() -> Program {
+		Program {
+			broadcast: relative("."),
+			instance: None,
+		}
+	}
+
+	/// The studio's broadcasts as they are located: each local source at
+	/// offset zero, and the guest at its own offset.
+	fn children() -> BTreeMap<String, Child> {
+		BTreeMap::from([
+			("cam".into(), Child::new(relative("source/cam"), None, 0)),
+			("mic".into(), Child::new(relative("source/mic"), None, 0)),
+			(
+				"alice".into(),
+				Child::new(relative("../guests/alice/camera.hang"), Some("abc".parse().unwrap()), -1_500),
+			),
+		])
+	}
+
+	/// The composition places each published picture of the scene on
+	/// program, then the top layer's, naming the source a clone shows, and
+	/// plays each published sound the program's audio holds; the rest stay in
+	/// the program.
+	#[test]
+	fn composes_the_published_sources_on_program() {
+		let collection = collection();
+		let start = Duration::from_secs(12);
+		let composition = Composition::new(&collection, Some("live"), start, program(), children());
+		assert_eq!(composition.start, start);
+		assert_eq!(composition.canvas.width, collection.canvas.width);
+		let items = &composition.pictures;
+		assert_eq!(items.len(), 3, "{items:?}");
+		assert_eq!(items[0], collection.scenes[0].items[1]);
+		assert_eq!(items[1].source, "alice");
+		assert_eq!((items[2].source.as_str(), items[2].rect), ("cam", rect(8.0)));
+		let sounds: Vec<(&str, Option<&Audio>)> = composition
+			.sources
+			.iter()
+			.map(|(name, child)| (name.as_str(), child.sound.as_ref()))
+			.collect();
+		assert_eq!(
+			sounds,
+			[
+				("alice", Some(&Audio::default())),
+				("cam", None),
+				("mic", Some(&collection.audio["mic"]))
+			]
+		);
+		assert_eq!(composition.sources["alice"].offset, -1_500);
+
+		let top = Composition::new(&collection, None, start, program(), children());
+		assert_eq!(top.pictures.len(), 1, "only the top layer's");
+	}
+
+	/// A source left unlocated, such as a guest offline, is left out with its
+	/// pictures and sound, and a relay-minted instance is never named.
+	#[test]
+	fn leaves_out_what_is_not_located() {
+		let collection = collection();
+		let mut children = children();
+		children.remove("alice");
+		let minted = Child::new(relative("source/mic"), Some("~minted".parse().unwrap()), 0);
+		assert_eq!(minted.instance, None);
+		let composition = Composition::new(&collection, Some("live"), Duration::ZERO, program(), children);
+		assert!(!composition.sources.contains_key("alice"));
+		assert!(composition.pictures.iter().all(|item| item.source != "alice"));
+	}
+
+	/// Each source's own crop and filters fold into its picture, a clone's
+	/// its own rather than the source's it shows.
+	#[test]
+	fn folds_in_the_sources_crop_and_filters() {
+		let mut collection = collection();
+		let video = |amount| crate::collection::Video {
+			crop: crate::collection::Crop {
+				left: 0.25,
+				..Default::default()
+			},
+			filters: vec![Filter::Opacity { amount }],
+			..Default::default()
+		};
+		collection.video.insert("cam".into(), video(0.8));
+		collection.video.insert("pip".into(), video(0.4));
+		collection.validate().unwrap();
+		let composition = Composition::new(&collection, Some("live"), Duration::ZERO, program(), children());
+		let cams = composition.pictures.iter().filter(|item| item.source == "cam");
+		let filters: Vec<&[Filter]> = cams.clone().map(|item| item.filters.as_slice()).collect();
+		assert_eq!(
+			filters,
+			[
+				&[Filter::Opacity { amount: 0.8 }, Filter::Opacity { amount: 0.5 }][..],
+				&[Filter::Opacity { amount: 0.4 }][..],
+			]
+		);
+		assert!(cams.into_iter().all(|item| item.crop.left == 0.25));
+	}
+
+	/// A published source placed with what a player cannot reproduce is
+	/// refused, as is one in a scene another scene draws, which the
+	/// composition cannot place.
+	#[test]
+	fn refuses_what_a_picture_cannot_carry() {
+		let refused = |edit: &dyn Fn(&mut Collection)| {
+			let mut collection = collection();
+			edit(&mut collection);
+			assert!(matches!(collection.validate(), Err(Error::Invalid(_))));
+		};
+		refused(&|collection| collection.scenes[0].items[1].blend = Blend::Screen);
+		refused(&|collection| collection.scenes[0].items[1].filters = vec![Filter::Blur { radius: 2.0 }]);
+		refused(&|collection| collection.scenes[0].items[2].blend = Blend::Screen);
+		refused(&|collection| {
+			collection.scenes[0].items[1].keyframes[0].filters = vec![Filter::Grayscale { amount: 1.0 }];
+		});
+		refused(&|collection| {
+			collection.video.insert(
+				"pip".into(),
+				crate::collection::Video {
+					filters: vec![Filter::Invert { amount: 1.0 }],
+					..Default::default()
+				},
+			);
+		});
+		refused(&|collection| {
+			collection
+				.sources
+				.insert("nest".into(), Source::Scene { scene: "live".into() });
+			collection.scenes.push(Scene {
+				items: vec![Item::new("nest", rect(0.0))],
+				..Scene::new("outer")
+			});
+		});
+
+		// Unpublished, the same camera takes them.
+		let mut collection = collection();
+		collection.published.remove("cam");
+		collection.scenes[0].items[1].blend = Blend::Screen;
+		collection.validate().unwrap();
+	}
+
+	/// A composition reads back as written, and one of another version is
+	/// refused, naming it.
+	#[test]
+	fn refuses_another_version() {
+		let composition = Composition::new(
+			&collection(),
+			Some("live"),
+			Duration::from_micros(1_500),
+			program(),
+			children(),
+		);
+		let text = toml::to_string(&composition).unwrap();
+		assert!(text.starts_with("version = 2\n"), "{text}");
+		assert!(text.contains("start = 1500\n"), "{text}");
+		let alice = "[sources.alice]\nbroadcast = \"../guests/alice/camera.hang\"\ninstance = \"abc\"\noffset = -1500\n";
+		assert!(text.contains(alice), "{text}");
+		assert_eq!(toml::from_str::<Composition>(&text).unwrap(), composition);
+
+		let other = text.replacen("version = 2", "version = 1", 1);
+		let err = toml::from_str::<Composition>(&other).unwrap_err().to_string();
+		assert!(err.contains("composition version 1 is not supported"), "{err}");
+	}
+
+	/// The track carries each new composition at the media time it took
+	/// effect, listed in the catalog on the program's clock; an offset that
+	/// only jitters writes nothing, one that moves past the drift or a new
+	/// instance does, and finishing ends the track and the catalog.
+	#[tokio::test]
+	async fn publishes_each_new_composition() {
+		let mut broadcast = moq_net::broadcast::Info::new().produce();
+		let clock = moq_mux::Clock::default();
+		let mut publisher = Publisher::new(&mut broadcast, clock.clone()).unwrap();
+		let collection = collection();
+		let compose = |offset: i64, instance: &str| {
+			let mut children = children();
+			children.insert(
+				"alice".into(),
+				Child::new(relative("../guests/alice/camera.hang"), Some(instance.parse().unwrap()), offset),
+			);
+			Composition::new(&collection, Some("live"), Duration::ZERO, program(), children)
+		};
+		let stamp = |secs| moq_net::Timestamp::try_from(Duration::from_secs(secs)).unwrap();
+		publisher.update(compose(0, "a"), stamp(1)).unwrap();
+
+		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast.consume(), Default::default())
+			.await
+			.unwrap();
+		let catalog = catalogs.next().await.unwrap().expect("a catalog");
+		assert!(catalog.json.tracks.contains_key(TRACK));
+		assert_eq!(catalog.media.clock, clock.wall(), "the program's clock");
+
+		let track = broadcast.consume().track(TRACK).unwrap();
+		let mut reader = moq_json::snapshot::Consumer::<Composition>::new(track, Default::default());
+		let next = async |reader: &mut moq_json::snapshot::Consumer<Composition>| {
+			let read = reader.next().await.unwrap().expect("a composition");
+			(read.value.sources["alice"].clone(), read.at.map(Duration::from))
+		};
+		let (alice, at) = next(&mut reader).await;
+		assert_eq!((alice.offset, at), (0, Some(Duration::from_secs(1))));
+
+		let drift = DRIFT.as_micros() as i64;
+		publisher.update(compose(drift, "a"), stamp(2)).unwrap();
+		publisher.update(compose(-drift, "a"), stamp(3)).unwrap();
+		publisher.update(compose(drift + 1, "a"), stamp(4)).unwrap();
+		let (alice, at) = next(&mut reader).await;
+		assert_eq!((alice.offset, at), (drift + 1, Some(Duration::from_secs(4))));
+		publisher.update(compose(drift + 2, "b"), stamp(5)).unwrap();
+		let (alice, at) = next(&mut reader).await;
+		assert_eq!(alice.instance, Some("b".parse().unwrap()));
+		assert_eq!((alice.offset, at), (drift + 2, Some(Duration::from_secs(5))));
+
+		publisher.finish().unwrap();
+		assert!(reader.next().await.unwrap().is_none(), "the track ends");
+		// The track leaves the catalog, then the catalog ends.
+		while catalogs.next().await.unwrap().is_some() {}
+	}
+}
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 83b0940..3b3dc8c 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -54,7 +54,7 @@ pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
 /// anything showing it.
 ///
 /// A source published independently is left out of every texture, and drawn
-/// only as its [layer layout](crate::layout) places it: over the program, in
+/// only as its [composition](crate::composition) places it: over the program, in
 /// [`layered`](Self::layered), and over the scene in preview, so each shows
 /// what viewers see.
 ///
@@ -432,7 +432,7 @@ impl Compositor {
 
 	/// The scene in preview, at its own size, as of the last
 	/// [`render`](Self::render), under the top layer when it is the program's
-	/// size, with the pictures of their [layer layout](crate::layout) over
+	/// size, with the pictures of their [composition](crate::composition) over
 	/// both.
 	pub fn preview(&self) -> &wgpu::Texture {
 		&self.preview.texture
@@ -463,7 +463,7 @@ impl Compositor {
 	}
 
 	/// The program as viewers see it, as of the last [`render`](Self::render):
-	/// with each picture of its [layer layout](crate::layout) over it, or the
+	/// with each picture of its [composition](crate::composition) over it, or the
 	/// [`program`](Self::program) itself while it has none showing. Created
 	/// as the program is.
 	pub fn layered(&self) -> &wgpu::Texture {
@@ -475,7 +475,7 @@ impl Compositor {
 
 	/// How long the program scene had been on program as of the last
 	/// [`render`](Self::render): the moment of its items' keyframes the
-	/// program shows, and the layer layout's pictures play from.
+	/// program shows, and the composition's pictures play from.
 	pub fn program_since(&self) -> Duration {
 		self.program_shown
 	}
@@ -867,8 +867,8 @@ impl Compositor {
 
 		// The pictures viewers draw over the program, which the preview draws
 		// over its scene too, so both show what viewers would see.
-		let program_layers = crate::layout::pictures(collection, program.0, true);
-		let preview_layers = crate::layout::pictures(collection, preview.0, preview_top);
+		let program_layers = crate::composition::pictures(collection, program.0, true);
+		let preview_layers = crate::composition::pictures(collection, preview.0, preview_top);
 		self.layered = program_layers.iter().any(|item| item.visible);
 		if self.layered && self.program.layered.is_none() {
 			let target = Target::new(&self.device, &self.effects, program_canvas, "moq-scene layered");
@@ -1842,10 +1842,10 @@ impl Draw<'_> {
 		}
 	}
 
-	/// Draw `layers`, pictures of the layer layout, onto `target`, back to
+	/// Draw `layers`, pictures of the composition, onto `target`, back to
 	/// front, each posed `since` its scene went on. Each names the source it
 	/// shows and carries its source's crop and filters already, so it draws as
-	/// a player reading the layout would.
+	/// a player reading the composition would.
 	fn layers(&mut self, target: &Target, layers: &[Item], since: Duration) {
 		for item in layers.iter().filter(|item| item.visible) {
 			let item = item.posed(since);
diff --git a/rs/moq-scene/src/layout.rs b/rs/moq-scene/src/layout.rs
deleted file mode 100644
index 01093ed..0000000
--- a/rs/moq-scene/src/layout.rs
+++ /dev/null
@@ -1,454 +0,0 @@
-//! The layer layout: where and when each source published independently
-//! shows over the program, and how its sound plays, so a player places the
-//! source's own track as the studio would have.
-//!
-//! The program leaves a published source out, so a player draws each
-//! [`Picture`] over the program, back to front, and mixes each [`Sound`] with
-//! the program's audio. A layout carries only what every player can
-//! reproduce: a picture's place, crop, opacity, visibility, and keyframes, and
-//! a sound's gain, mute, pan, and delay. [`Collection::validate`] refuses a
-//! published source placed with anything more, such as a blur or a blend mode.
-//!
-//! It travels as JSON on the program broadcast's [`TRACK`] in snapshot mode,
-//! so a viewer joining late reads the layout in force. The format is the
-//! studio's own, provisional until hang specifies a layer layout.
-
-use std::time::Duration;
-
-use serde::{Deserialize, Serialize};
-use serde_with::{DurationMicroSeconds, serde_as};
-
-use crate::Error;
-use crate::collection::{Audio, Collection, Item, Layer, Size};
-use crate::publish::Catalog;
-
-/// The program broadcast's track carrying the layout, listed in its catalog's
-/// `json` section.
-pub const TRACK: &str = "live.kixel.studio.layers";
-
-/// Each source published independently that the program shows or plays, and
-/// how.
-#[serde_as]
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Layout {
-	/// The format's version, first so a reader of another one fails on it.
-	pub version: Version,
-	/// The program's canvas, which pictures are placed on in pixels.
-	pub canvas: Size,
-	/// When the scene on program went on, on the broadcast's media clock: the
-	/// moment its pictures' keyframes play from. In microseconds on the wire.
-	#[serde_as(as = "DurationMicroSeconds<u64>")]
-	pub start: Duration,
-	/// Each picture over the program, back to front: the scene on program's,
-	/// then the top layer's.
-	#[serde(default, skip_serializing_if = "Vec::is_empty")]
-	pub pictures: Vec<Picture>,
-	/// Each sound the program's audio plays, by source name.
-	#[serde(default, skip_serializing_if = "Vec::is_empty")]
-	pub sounds: Vec<Sound>,
-}
-
-impl Layout {
-	/// The layout of `collection` with the scene called `scene` on program
-	/// since `start` on the media clock, or no scene for `None`.
-	pub fn new(collection: &Collection, scene: Option<&str>, start: Duration) -> Self {
-		let pictures = pictures(collection, scene, true)
-			.into_iter()
-			.map(Picture::new)
-			.collect();
-		let heard = collection.program_audio().map(|audio| collection.heard(audio));
-		let sounds = heard.into_iter().flatten();
-		let sounds = sounds.filter(|source| collection.published.contains(*source));
-		let sounds = sounds
-			.map(|source| Sound {
-				source: source.to_string(),
-				audio: collection.audio.get(source).cloned().unwrap_or_default(),
-				priority: 0,
-				toggle: false,
-			})
-			.collect();
-		Self {
-			version: Version,
-			canvas: Size {
-				width: collection.canvas.width,
-				height: collection.canvas.height,
-			},
-			start,
-			pictures,
-			sounds,
-		}
-	}
-}
-
-/// Each item of the scene called `scene`, then of the top layer if `top`,
-/// showing a source published independently, back to front, shown or hidden:
-/// its `source` names the published source, and its crop and filters fold in
-/// its source's, as the compositor draws them.
-pub(crate) fn pictures(collection: &Collection, scene: Option<&str>, top: bool) -> Vec<Item> {
-	let scene = scene.filter(|scene| collection.scene(scene).is_some());
-	let places = scene.map(Layer::scene).into_iter().chain(top.then(Layer::top));
-	let mut pictures = Vec::new();
-	for place in places {
-		for item in collection.items(&place).unwrap_or_default() {
-			let source = collection.capture(&item.source);
-			if !collection.published.contains(source) {
-				continue;
-			}
-			pictures.push(Item {
-				source: source.to_string(),
-				crop: collection.crop(item),
-				filters: collection.filters(item).cloned().collect(),
-				..item.clone()
-			});
-		}
-	}
-	pictures
-}
-
-/// The layout format's version: deserializing refuses any but
-/// [`Version::CURRENT`].
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(into = "u32", try_from = "u32")]
-pub struct Version;
-
-impl Version {
-	/// The version this build reads and writes.
-	pub const CURRENT: u32 = 1;
-}
-
-impl From<Version> for u32 {
-	fn from(_: Version) -> Self {
-		Version::CURRENT
-	}
-}
-
-impl TryFrom<u32> for Version {
-	type Error = String;
-
-	fn try_from(found: u32) -> Result<Self, Self::Error> {
-		match found {
-			Self::CURRENT => Ok(Self),
-			found => Err(format!(
-				"layer layout version {found} is not supported; this build reads version {}",
-				Self::CURRENT
-			)),
-		}
-	}
-}
-
-/// A published source's picture over the program.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Picture {
-	/// Where and how it shows: its `source` names the source's entry under the
-	/// catalog's `live.kixel.studio` `sources`, its filters are only opacity, and
-	/// its keyframes play from the layout's `start`.
-	pub item: Item,
-	/// The subscription priority a viewer fetches its track at, as moq-lite
-	/// orders them.
-	#[serde(default, skip_serializing_if = "is_zero")]
-	pub priority: i8,
-	/// Whether a viewer may switch it off.
-	#[serde(default, skip_serializing_if = "std::ops::Not::not")]
-	pub toggle: bool,
-}
-
-impl Picture {
-	fn new(item: Item) -> Self {
-		Self {
-			item,
-			priority: 0,
-			toggle: false,
-		}
-	}
-}
-
-/// A published source's sound in the program's audio.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Sound {
-	/// The source's entry under the catalog's `live.kixel.studio` `sources`.
-	pub source: String,
-	/// Its gain, mute, pan, and delay, applied to its track's sound.
-	pub audio: Audio,
-	/// The subscription priority a viewer fetches its track at, as moq-lite
-	/// orders them.
-	#[serde(default, skip_serializing_if = "is_zero")]
-	pub priority: i8,
-	/// Whether a viewer may switch it off.
-	#[serde(default, skip_serializing_if = "std::ops::Not::not")]
-	pub toggle: bool,
-}
-
-fn is_zero(priority: &i8) -> bool {
-	*priority == 0
-}
-
-/// Publishes the layout on [`TRACK`] in a broadcast, listed in its catalog,
-/// while there is one.
-pub struct Publisher {
-	broadcast: moq_net::broadcast::Producer,
-	catalog: Catalog,
-	/// The track, and the layout last written to it, while there is one.
-	track: Option<(moq_mux::json::Snapshot<Layout>, Option<Layout>)>,
-}
-
-impl Publisher {
-	/// Publish in `broadcast`, listed in `catalog`, from the first
-	/// [`update`](Self::update).
-	pub fn new(broadcast: moq_net::broadcast::Producer, catalog: Catalog) -> Self {
-		Self {
-			broadcast,
-			catalog,
-			track: None,
-		}
-	}
-
-	/// Publish `layout`, stamped `at` on the media clock, when it took
-	/// effect, unless it is the one published already, starting the track and
-	/// its listing if there is none.
-	pub fn update(&mut self, layout: Layout, at: moq_net::Timestamp) -> Result<(), Error> {
-		let (snapshot, published) = match &mut self.track {
-			Some(track) => track,
-			None => {
-				let info = moq_net::track::Info::default()
-					.with_timescale(moq_mux::Clock::TIMESCALE)
-					.with_priority(hang::catalog::PRIORITY.catalog)
-					.with_compress(true);
-				let created = self.broadcast.create_track(TRACK, info)?;
-				// Each layout whole in a group of its own, so a joiner needs no
-				// refresh to read it.
-				let options = moq_mux::json::Options::default().with_deltas(false);
-				let config = moq_mux::json::Config::default();
-				let snapshot = self.catalog.json_snapshot(created, config, options)?;
-				self.track.insert((snapshot, None))
-			}
-		};
-		if published.as_ref() == Some(&layout) {
-			return Ok(());
-		}
-		snapshot.update(&layout, at)?;
-		*published = Some(layout);
-		Ok(())
-	}
-
-	/// End the track, so a reader reaches its end, and take it out of the
-	/// catalog, until the next [`update`](Self::update).
-	pub fn finish(&mut self) -> Result<(), Error> {
-		match self.track.take() {
-			Some((snapshot, _)) => Ok(snapshot.finish()?),
-			None => Ok(()),
-		}
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::*;
-	use crate::collection::{Blend, Filter, Keyframe, Rect, Rgba, Scene, Source};
-
-	fn rect(x: f32) -> Rect {
-		Rect {
-			x,
-			y: 0.0,
-			width: 4.0,
-			height: 4.0,
-		}
-	}
-
-	/// A camera and a microphone published, the camera placed over a color in
-	/// scene `live`, behind a clone of itself in the top layer, and the
-	/// microphone in the program's audio scene.
-	fn collection() -> Collection {
-		let mut collection = Collection::new();
-		collection.sources.insert(
-			"bg".into(),
-			Source::Color {
-				color: Rgba([0, 0, 0, 255]),
-			},
-		);
-		collection.sources.insert("cam".into(), Source::Camera { id: None });
-		collection
-			.sources
-			.insert("pip".into(), Source::Clone { source: "cam".into() });
-		collection.sources.insert("mic".into(), Source::Microphone { id: None });
-		collection.published.extend(["cam".into(), "mic".into()]);
-		let mut cam = Item::new("cam", rect(0.0));
-		cam.filters = vec![Filter::Opacity { amount: 0.5 }];
-		cam.keyframes = vec![Keyframe {
-			x: 10.0,
-			..Keyframe::new(Duration::from_secs(1))
-		}];
-		collection.scenes = vec![Scene {
-			items: vec![Item::new("bg", Rect::fill(&collection.canvas)), cam],
-			..Scene::new("live")
-		}];
-		collection.top = vec![Item::new("pip", rect(8.0))];
-		collection.audio_scenes[0].sounds.insert("mic".into());
-		collection.audio.insert(
-			"mic".into(),
-			Audio {
-				gain: 0.5,
-				delay: Duration::from_millis(80),
-				..Default::default()
-			},
-		);
-		collection.validate().unwrap();
-		collection
-	}
-
-	/// The layout places each published picture of the scene on program, then
-	/// the top layer's, naming the source a clone shows, and plays each
-	/// published sound the program's audio holds; the rest stay in the
-	/// program.
-	#[test]
-	fn lays_out_the_published_sources_on_program() {
-		let collection = collection();
-		let start = Duration::from_secs(12);
-		let layout = Layout::new(&collection, Some("live"), start);
-		assert_eq!(layout.start, start);
-		assert_eq!(layout.canvas.width, collection.canvas.width);
-		let items: Vec<&Item> = layout.pictures.iter().map(|picture| &picture.item).collect();
-		assert_eq!(items.len(), 2, "{items:?}");
-		assert_eq!(items[0], &collection.scenes[0].items[1]);
-		assert_eq!((items[1].source.as_str(), items[1].rect), ("cam", rect(8.0)));
-		let sounds: Vec<(&str, &Audio)> = layout
-			.sounds
-			.iter()
-			.map(|sound| (sound.source.as_str(), &sound.audio))
-			.collect();
-		assert_eq!(sounds, [("mic", &collection.audio["mic"])]);
-
-		let top = Layout::new(&collection, None, start);
-		assert_eq!(top.pictures.len(), 1, "only the top layer's");
-	}
-
-	/// Each source's own crop and filters fold into its picture, a clone's
-	/// its own rather than the source's it shows.
-	#[test]
-	fn folds_in_the_sources_crop_and_filters() {
-		let mut collection = collection();
-		let video = |amount| crate::collection::Video {
-			crop: crate::collection::Crop {
-				left: 0.25,
-				..Default::default()
-			},
-			filters: vec![Filter::Opacity { amount }],
-			..Default::default()
-		};
-		collection.video.insert("cam".into(), video(0.8));
-		collection.video.insert("pip".into(), video(0.4));
-		collection.validate().unwrap();
-		let layout = Layout::new(&collection, Some("live"), Duration::ZERO);
-		let filters: Vec<&[Filter]> = layout
-			.pictures
-			.iter()
-			.map(|picture| picture.item.filters.as_slice())
-			.collect();
-		assert_eq!(
-			filters,
-			[
-				&[Filter::Opacity { amount: 0.8 }, Filter::Opacity { amount: 0.5 }][..],
-				&[Filter::Opacity { amount: 0.4 }][..],
-			]
-		);
-		assert!(layout.pictures.iter().all(|picture| picture.item.crop.left == 0.25));
-	}
-
-	/// A published source placed with what a player cannot reproduce is
-	/// refused, as is one in a scene another scene draws, which the layout
-	/// cannot place.
-	#[test]
-	fn refuses_what_a_layer_cannot_carry() {
-		let refused = |edit: &dyn Fn(&mut Collection)| {
-			let mut collection = collection();
-			edit(&mut collection);
-			assert!(matches!(collection.validate(), Err(Error::Invalid(_))));
-		};
-		refused(&|collection| collection.scenes[0].items[1].blend = Blend::Screen);
-		refused(&|collection| collection.scenes[0].items[1].filters = vec![Filter::Blur { radius: 2.0 }]);
-		refused(&|collection| {
-			collection.scenes[0].items[1].keyframes[0].filters = vec![Filter::Grayscale { amount: 1.0 }];
-		});
-		refused(&|collection| {
-			collection.video.insert(
-				"pip".into(),
-				crate::collection::Video {
-					filters: vec![Filter::Invert { amount: 1.0 }],
-					..Default::default()
-				},
-			);
-		});
-		refused(&|collection| {
-			collection
-				.sources
-				.insert("nest".into(), Source::Scene { scene: "live".into() });
-			collection.scenes.push(Scene {
-				items: vec![Item::new("nest", rect(0.0))],
-				..Scene::new("outer")
-			});
-		});
-
-		// Unpublished, the same camera takes them.
-		let mut collection = collection();
-		collection.published.remove("cam");
-		collection.scenes[0].items[1].blend = Blend::Screen;
-		collection.validate().unwrap();
-	}
-
-	/// A layout reads back as written, and one of another version is refused,
-	/// naming it.
-	#[test]
-	fn refuses_another_version() {
-		let layout = Layout::new(&collection(), Some("live"), Duration::from_micros(1_500));
-		let text = toml::to_string(&layout).unwrap();
-		assert!(text.starts_with("version = 1\n"), "{text}");
-		assert!(text.contains("start = 1500\n"), "{text}");
-		assert_eq!(toml::from_str::<Layout>(&text).unwrap(), layout);
-
-		let other = text.replacen("version = 1", "version = 2", 1);
-		let err = toml::from_str::<Layout>(&other).unwrap_err().to_string();
-		assert!(err.contains("layer layout version 2 is not supported"), "{err}");
-	}
-
-	/// The layout track carries each new layout at the media time it took
-	/// effect, listed in the catalog while there is one; finishing ends it
-	/// for a reader and takes it out of the catalog.
-	#[tokio::test]
-	async fn publishes_each_new_layout() {
-		let mut broadcast = moq_net::broadcast::Info::new().produce();
-		let config = moq_mux::catalog::Config::default().with_catalog(Default::default());
-		let catalog = Catalog::new(&mut broadcast, config).unwrap();
-		let collection = collection();
-		let first = Layout::new(&collection, None, Duration::ZERO);
-		let second = Layout::new(&collection, Some("live"), Duration::from_secs(1));
-		let stamp = |secs| moq_net::Timestamp::try_from(Duration::from_secs(secs)).unwrap();
-		let mut publisher = Publisher::new(broadcast.clone(), catalog.clone());
-		publisher.update(first.clone(), stamp(1)).unwrap();
-		let listed = |catalog: &hang::Catalog<crate::publish::Ext>| catalog.json.tracks.contains_key(TRACK);
-		assert!(listed(&catalog.snapshot()));
-
-		let track = broadcast.consume().track(TRACK).unwrap();
-		let mut reader = moq_json::snapshot::Consumer::<Layout>::new(track, Default::default());
-		let read = reader.next().await.unwrap().expect("a layout");
-		assert_eq!(
-			(read.value, read.at.map(Duration::from)),
-			(first, Some(Duration::from_secs(1)))
-		);
-		publisher.update(second.clone(), stamp(2)).unwrap();
-		publisher.update(second.clone(), stamp(3)).unwrap();
-		let read = reader.next().await.unwrap().expect("a layout");
-		assert_eq!(
-			(read.value, read.at.map(Duration::from)),
-			(second, Some(Duration::from_secs(2)))
-		);
-
-		publisher.finish().unwrap();
-		assert!(
-			reader.next().await.unwrap().is_none(),
-			"the unchanged layout wrote nothing"
-		);
-		assert!(!listed(&catalog.snapshot()));
-	}
-}
diff --git a/rs/moq-scene/src/lib.rs b/rs/moq-scene/src/lib.rs
index 6e8f19f..db053bc 100644
--- a/rs/moq-scene/src/lib.rs
+++ b/rs/moq-scene/src/lib.rs
@@ -31,9 +31,10 @@
 //!   [`Scaler`] draws it smaller for a smaller rendition.
 //! - [`publish`] gives each local source its own track, in a broadcast the
 //!   studio keeps to itself, to replay or record the source on its own.
-//! - [`layout`] says where and when each source published independently
-//!   shows over the program, and how its sound plays, for viewers to place
-//!   its track themselves.
+//! - [`composition`] lists the program and each source published
+//!   independently as a broadcast of its own, and says where and when each
+//!   shows over the program and how its sound plays, for viewers to place
+//!   them themselves.
 //!
 //! Every picture is drawn on the program clock the caller ticks
 //! [`Compositor::render`] with, from whatever each source delivered last: a
@@ -43,10 +44,10 @@
 pub mod browser;
 pub mod clip;
 mod collection;
+pub mod composition;
 mod compositor;
 mod edit;
 mod effect;
-pub mod layout;
 mod lut;
 mod matte;
 mod media;
diff --git a/rs/moq-scene/src/publish.rs b/rs/moq-scene/src/publish.rs
index 1404acf..a792c49 100644
--- a/rs/moq-scene/src/publish.rs
+++ b/rs/moq-scene/src/publish.rs
@@ -1,10 +1,11 @@
 //! Each local source's own track, kept in a broadcast of the studio's own.
 //!
 //! A source's track is for the studio's own use, such as replaying the source
-//! or recording it on its own, and is never announced to a relay: the program
-//! is the only video the studio publishes, which keeps it within the encode
-//! sessions a GPU allows. Its renditions are listed in a hang catalog of its
-//! own, nested by source name under the local catalog's [`SECTION`] section.
+//! or recording it on its own, and is never announced to a relay unless the
+//! source is published independently ([`Publish::forward`]), which keeps the
+//! studio within the encode sessions a GPU allows. Its renditions are listed in
+//! a hang catalog of its own, nested by source name under the local catalog's
+//! [`SECTION`] section.
 //!
 //! A track encodes only while it is used: while it is on program
 //! ([`Publish::set_on_program`]), a picture shown in a scene on air or a sound
@@ -171,24 +172,24 @@ impl Publish {
 		});
 	}
 
-	/// Publish each source `published` names in `broadcast`, the program's,
-	/// as long as it stays named, until `published` closes: its tracks are
-	/// copied in under [`FORWARDED`] and its catalog listed under `catalog`'s
-	/// [`SECTION`] section, renamed to match. Reading its tracks keeps each
-	/// source encoding while it is published. Each copied audio or video
-	/// track claims its bitrate from `bandwidth` while subscribed, as the
-	/// program's tracks do.
+	/// Publish each source `published` names as a broadcast of its own at
+	/// `<base>/<name>` on `origin`, as long as it stays named, until
+	/// `published` closes: its tracks are copied in, and its catalog published
+	/// there on the program's clock, so a [composition](crate::composition)
+	/// lists it at offset zero. Reading its tracks keeps each source encoding
+	/// while it is published. Each copied audio or video track claims its
+	/// bitrate from `bandwidth` while subscribed, as the program's tracks do.
 	pub async fn forward(
 		&self,
 		mut published: tokio::sync::watch::Receiver<BTreeSet<String>>,
-		broadcast: moq_net::broadcast::Producer,
-		mut catalog: Catalog,
+		origin: moq_net::origin::Producer,
+		base: moq_net::Path,
 		bandwidth: moq_net::bandwidth::Allocator,
 	) -> Result<(), Error> {
 		let mut updates = self.catalog.consume()?;
 		let mut local = self.catalog.snapshot();
-		// Each copied track's copy, by its local name, aborted once dropped.
-		let mut copies: BTreeMap<String, tokio::task::JoinHandle<()>> = BTreeMap::new();
+		// Each source's broadcast, by name, finished once dropped.
+		let mut broadcasts: BTreeMap<String, Independent> = BTreeMap::new();
 		loop {
 			let listed: BTreeMap<String, hang::Catalog> = {
 				let published = published.borrow_and_update();
@@ -196,40 +197,25 @@ impl Publish {
 				let sources = sources.filter(|(name, _)| published.contains(*name));
 				sources.map(|(name, source)| (name.clone(), source.clone())).collect()
 			};
-			let tracks: BTreeMap<String, (String, Option<(moq_net::bandwidth::Rate, bool)>)> = listed
-				.iter()
-				.flat_map(|(source, catalog)| tracks(catalog).map(move |(name, rate)| (name, (source.clone(), rate))))
-				.collect();
-			copies.retain(|name, copy| {
-				let keep = tracks.contains_key(name);
-				if !keep {
-					copy.abort();
-				}
-				keep
-			});
-			for (name, (source, rate)) in tracks {
-				if copies.contains_key(&name) {
-					continue;
+			broadcasts.retain(|name, _| listed.contains_key(name));
+			for (name, source) in listed {
+				let independent = match broadcasts.entry(name.clone()) {
+					std::collections::btree_map::Entry::Occupied(entry) => entry.into_mut(),
+					std::collections::btree_map::Entry::Vacant(entry) => {
+						match Independent::new(&origin, &base, &name, self.catalog.clock()) {
+							Ok(independent) => entry.insert(independent),
+							Err(err) => {
+								tracing::warn!(source = %name, %err, "cannot publish a source independently");
+								continue;
+							}
+						}
+					}
+				};
+				if let Err(err) = independent.sync(&name, &source, self, &bandwidth) {
+					tracing::warn!(source = %name, %err, "cannot publish a source independently");
+					broadcasts.remove(&name);
 				}
-				let bandwidth = rate.map(|(rate, video)| Grant {
-					bandwidth: bandwidth.clone(),
-					rate,
-					video,
-					grants: self.grants.clone(),
-					source,
-				});
-				let copy = copy(self.consume(), broadcast.clone(), name.clone(), bandwidth);
-				copies.insert(name, tokio::spawn(copy));
 			}
-			let listed: BTreeMap<String, hang::Catalog> = listed
-				.into_iter()
-				.map(|(name, source)| (name, renamed(source)))
-				.collect();
-			catalog.mutate(|root| {
-				if root.ext.studio.sources != listed {
-					root.ext.studio.sources = listed;
-				}
-			})?;
 
 			tokio::select! {
 				next = updates.next() => match next? {
@@ -239,10 +225,6 @@ impl Publish {
 				changed = published.changed() => if changed.is_err() { break },
 			}
 		}
-		for copy in copies.into_values() {
-			copy.abort();
-		}
-		catalog.mutate(|root| root.ext.studio.sources.clear())?;
 		Ok(())
 	}
 
@@ -272,9 +254,86 @@ impl Publish {
 	}
 }
 
-/// The prefix of each source track's name in the program's broadcast, ahead
-/// of its name in the local one, so it never meets one of the program's own.
-pub const FORWARDED: &str = "source/";
+/// A source published independently: its broadcast, announced once its
+/// catalog lists what it carries, and the copy of each of its tracks, by
+/// name, aborted once dropped.
+struct Independent {
+	route: moq_net::origin::Route,
+	catalog: moq_mux::catalog::Producer,
+	copies: BTreeMap<String, tokio::task::JoinHandle<()>>,
+	announced: bool,
+}
+
+impl Independent {
+	/// A broadcast at `<base>/<name>` on `origin`, its catalog on `clock`.
+	fn new(origin: &moq_net::origin::Producer, base: &moq_net::Path, name: &str, clock: moq_mux::Clock) -> Result<Self, Error> {
+		let path = moq_net::Path::new(name).and_then(|name| base.join(&name)).map_err(moq_net::Error::from)?;
+		let route = origin.route(path, moq_net::origin::RouteOptions::hidden())?;
+		let mut broadcast = route.broadcast().clone();
+		let config = moq_mux::catalog::Config::default().with_clock(clock);
+		let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config)?;
+		Ok(Self {
+			route,
+			catalog,
+			copies: BTreeMap::new(),
+			announced: false,
+		})
+	}
+
+	/// Carry what `source`, the local catalog's entry for the source called
+	/// `name`, lists: copy each track it names from `publish`'s local
+	/// broadcast, stop copying each it no longer does, and list them.
+	fn sync(
+		&mut self,
+		name: &str,
+		source: &hang::Catalog,
+		publish: &Publish,
+		bandwidth: &moq_net::bandwidth::Allocator,
+	) -> Result<(), Error> {
+		let tracks: BTreeMap<String, Option<(moq_net::bandwidth::Rate, bool)>> = tracks(source).collect();
+		self.copies.retain(|track, copy| {
+			let keep = tracks.contains_key(track);
+			if !keep {
+				copy.abort();
+			}
+			keep
+		});
+		for (track, rate) in tracks {
+			if self.copies.contains_key(&track) {
+				continue;
+			}
+			let grant = rate.map(|(rate, video)| Grant {
+				bandwidth: bandwidth.clone(),
+				rate,
+				video,
+				grants: publish.grants.clone(),
+				source: name.to_string(),
+			});
+			let copy = copy(publish.consume(), self.route.broadcast().clone(), track.clone(), grant);
+			self.copies.insert(track, tokio::spawn(copy));
+		}
+		self.catalog.mutate(|root| {
+			root.video = source.video.clone();
+			root.audio = source.audio.clone();
+			root.binary = source.binary.clone();
+		})?;
+		if !self.announced {
+			self.route.announce()?;
+			self.announced = true;
+		}
+		Ok(())
+	}
+}
+
+impl Drop for Independent {
+	fn drop(&mut self) {
+		for copy in self.copies.values() {
+			copy.abort();
+		}
+		// Fails only once the catalog failed, which ended its tracks already.
+		let _ = self.catalog.finish();
+	}
+}
 
 /// What a source's video claims of the connection when its catalog names
 /// no bitrate.
@@ -297,22 +356,6 @@ fn tracks(source: &hang::Catalog) -> impl Iterator<Item = (String, Option<(moq_n
 	video.chain(audio).chain(binary)
 }
 
-/// `source`'s catalog with each track named as the program's broadcast has it.
-fn renamed(mut source: hang::Catalog) -> hang::Catalog {
-	fn rename<T>(map: &mut BTreeMap<String, T>) {
-		*map = std::mem::take(map)
-			.into_iter()
-			.map(|(name, config)| (format!("{FORWARDED}{name}"), config))
-			.collect();
-	}
-	rename(&mut source.video.renditions);
-	rename(&mut source.audio.renditions);
-	rename(&mut source.binary.tracks);
-	source
-}
-
-/// Copy the local track `name` into `broadcast` under [`FORWARDED`], group by
-/// group, until it ends. A failure ends the copy, failed, with the reason.
 /// How a copied track claims its bitrate of the connection, and where its
 /// source's video finds what it was granted.
 struct Grant {
@@ -343,6 +386,8 @@ impl Drop for Granted {
 	}
 }
 
+/// Copy the local track `name` into `broadcast`, under the same name, group
+/// by group, until it ends. A failure ends the copy, failed, with the reason.
 async fn copy(
 	local: moq_net::broadcast::Consumer,
 	broadcast: moq_net::broadcast::Producer,
@@ -351,8 +396,7 @@ async fn copy(
 ) {
 	let copied = async {
 		let mut track = local.track(&name)?.subscribe(None).await?;
-		let out = broadcast.create_track(format!("{FORWARDED}{name}"), track.info().clone())?;
-		// Held for as long as the copy runs.
+		let out = broadcast.create_track(name.clone(), track.info().clone())?;
 		// Held for as long as the copy runs. A video's grant is what its source
 		// encodes at, so the source follows the connection as the program does.
 		let _grant = grant.map(|grant| {
@@ -1154,15 +1198,16 @@ mod tests {
 		.await;
 	}
 
-	/// A source published independently is listed in the program's catalog,
-	/// its track readable from the program's broadcast under [`FORWARDED`],
-	/// for as long as it is published; another stays in the studio.
+	/// A source published independently is a broadcast of its own beneath
+	/// the given path, announced with its catalog on the program's clock and
+	/// its tracks readable there, for as long as it is published; another
+	/// stays in the studio.
 	#[tokio::test]
-	async fn a_published_source_is_forwarded_to_the_program() {
+	async fn a_published_source_is_a_broadcast_of_its_own() {
 		local(async {
 			let dir = tempfile::tempdir().unwrap();
 			let (publish, _, _) = studio();
-			let (mut context, _origin) = context(dir.path());
+			let (mut context, origin) = context(dir.path());
 			context.publish = Some(publish.clone());
 			let mut collection = Collection::new();
 			for (name, color) in [("red", [255, 0, 0, 255]), ("blue", [0, 0, 255, 255])] {
@@ -1176,33 +1221,37 @@ mod tests {
 			let drivers = sources.sync(&collection);
 			start(&sources, drivers).await;
 
-			let mut program = moq_net::broadcast::Info::new().produce();
-			let config = moq_mux::catalog::Config::default().with_catalog(Default::default());
-			let catalog = Catalog::new(&mut program, config).unwrap();
 			let (published, follow) = tokio::sync::watch::channel(collection.published.clone());
 			let forward = publish.clone();
-			let (broadcast, listing) = (program.clone(), catalog.clone());
+			let base = moq_net::Path::new("show/source").unwrap();
+			let publishing = origin.clone();
 			tokio::spawn(async move {
 				forward
-					.forward(follow, broadcast, listing, moq_net::bandwidth::Allocator::unlimited())
+					.forward(follow, publishing, base, moq_net::bandwidth::Allocator::unlimited())
 					.await
 					.unwrap()
 			});
 
-			let snapshot = listed(&catalog, |sources| sources.contains_key("red")).await;
-			let red = &snapshot.ext.studio.sources["red"];
-			assert!(
-				!snapshot.ext.studio.sources.contains_key("blue"),
-				"only what is published"
-			);
-			assert!(red.binary.tracks.keys().all(|name| name.starts_with(FORWARDED)));
-			let (payload, mime) = still(&program.consume(), red).await;
+			let consumer = origin.consume();
+			let mut announced = consumer.announced();
+			let Some(moq_net::announce::Event::Present(first)) = announced.next().await else {
+				panic!("nothing announced");
+			};
+			assert_eq!(first.prefix.as_str(), "show/source/red", "only what is published");
+			let mut following = consumer.follow("show/source/red", None).unwrap();
+			let broadcast = following.available().await.unwrap().expect("the broadcast");
+			let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default())
+				.await
+				.unwrap();
+			let red = catalogs.next().await.unwrap().expect("a catalog");
+			assert_eq!(red.media.clock, publish.catalog.clock().wall(), "the program's clock");
+			let (payload, mime) = still(&broadcast, &red).await;
 			assert_eq!(mime, "image/png");
 			let red = image::load_from_memory(&payload).unwrap().into_rgba8();
 			assert_eq!(red.into_raw(), [255, 0, 0, 255]);
 
 			published.send(BTreeSet::new()).unwrap();
-			listed(&catalog, |sources| sources.is_empty()).await;
+			assert!(catalogs.next().await.unwrap().is_none(), "unpublished, its catalog ends");
 		})
 		.await;
 	}
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index b101060..f04dc21 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -15,7 +15,7 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque};
 use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -365,7 +365,29 @@ impl Sources {
 	pub fn sync(&mut self, collection: &Collection) -> Vec<Driver> {
 		let mixes = &self.mixes;
 		self.feeds.retain(|name, feed| {
-			let keep = collection.sources.get(name) == Some(&feed.source);
+			let keep = match (collection.sources.get(name), &mut feed.source) {
+				// A layer moved onto its clock anew plays on, so a guest's offset
+				// changing never opens their broadcast again.
+				(
+					Some(Source::Layer {
+						clock,
+						path,
+						instance,
+						offset,
+					}),
+					Source::Layer {
+						clock: playing,
+						path: played,
+						instance: serving,
+						offset: was,
+					},
+				) if clock == playing && path == played && instance == serving => {
+					*was = *offset;
+					feed.offset.store(*offset, Ordering::Relaxed);
+					true
+				}
+				(source, playing) => source == Some(&*playing),
+			};
 			if !keep {
 				leave(mixes, feed);
 			}
@@ -377,7 +399,7 @@ impl Sources {
 			.feeds
 			.iter()
 			.filter(
-				|(_, feed)| matches!(&feed.source, Source::Layer { broadcast, .. } if !self.feeds.contains_key(broadcast)),
+				|(_, feed)| matches!(&feed.source, Source::Layer { clock, .. } if !self.feeds.contains_key(clock)),
 			)
 			.map(|(name, _)| name.clone())
 			.collect();
@@ -411,12 +433,7 @@ impl Sources {
 			if !self.feeds.contains_key(name) {
 				let held = collection.transition.stinger() == Some(name.as_str());
 				let follows = match source {
-					Source::Layer { broadcast, .. } => match collection.sources.get(broadcast) {
-						Some(Source::Broadcast { path }) => {
-							self.feeds[broadcast].clock.clone().map(|clock| (path.clone(), clock))
-						}
-						_ => None,
-					},
+					Source::Layer { clock, .. } => self.feeds[clock].clock.clone(),
 					_ => None,
 				};
 				let (feed, driver) = open(name, source, &self.context, held, follows);
@@ -530,6 +547,9 @@ pub struct Feed {
 	silent: Arc<AtomicBool>,
 	/// A broadcast source's playout clock, or the one a layer plays on.
 	clock: Option<timeline::Consumer>,
+	/// A layer's offset onto its clock, in microseconds, which its driver
+	/// reads as it plays.
+	offset: Arc<AtomicI64>,
 }
 
 impl Feed {
@@ -718,6 +738,38 @@ impl Feed {
 		self.clock.as_ref()
 	}
 
+	/// The stream of the broadcast a broadcast source plays now, or `None`
+	/// while none is online, and for any other source.
+	pub fn instance(&self) -> Option<moq_net::Instance> {
+		let played = self.played.lock().unwrap();
+		played.broadcast.as_ref()?.info().instance.clone()
+	}
+
+	/// Microseconds to add to a broadcast source's timestamps to put them on
+	/// a timeline that reads `at` at `now`: where what it plays lands on that
+	/// timeline. `None` until its clock is anchored, and for any other source.
+	pub fn offset(&self, at: Duration, now: Instant) -> Option<i64> {
+		if !matches!(self.source, Source::Broadcast { .. }) || self.status() != Status::Live {
+			return None;
+		}
+		let clock = self.clock.as_ref()?;
+		// Any stamp maps through the one anchor: the newest picture shown, or
+		// without one, the sound playing now.
+		let newest = self.played.lock().unwrap().newest;
+		let reference = match newest {
+			Some(newest) => newest,
+			None => moq_net::Timestamp::try_from(clock.playhead(now)?).ok()?,
+		};
+		let due = clock.due(reference)?;
+		let micros = |duration: Duration| i64::try_from(duration.as_micros()).ok();
+		// When the reference plays, on the timeline.
+		let lands = match due.checked_duration_since(now) {
+			Some(ahead) => micros(at)?.checked_add(micros(ahead)?)?,
+			None => micros(at)?.checked_sub(micros(now.duration_since(due))?)?,
+		};
+		lands.checked_sub(micros(Duration::from(reference))?)
+	}
+
 	/// The source's gain, mute, delay, and meter in every mix, if it has sound.
 	/// A media file without any has none once it opens.
 	pub fn strip(&self) -> Option<&Strip> {
@@ -764,9 +816,10 @@ pub struct Driver {
 	runs: Runs,
 	silent: Arc<AtomicBool>,
 	clock: Option<timeline::Producer>,
-	/// A layer's broadcast path, and the clock of the broadcast source it
-	/// plays on.
-	follows: Option<(String, timeline::Consumer)>,
+	/// The clock of the broadcast source a layer plays on.
+	follows: Option<timeline::Consumer>,
+	/// A layer's offset onto that clock, in microseconds.
+	offset: Arc<AtomicI64>,
 }
 
 /// Where a source's own track goes, its claim on the local catalog's listing
@@ -884,7 +937,7 @@ impl Driver {
 				self.media(&self.context.dir.join(path), *looping, cues, listing).await
 			}
 			Source::Broadcast { path } => self.broadcast(path).await,
-			Source::Layer { source, .. } => self.layer(source).await,
+			Source::Layer { path, instance, .. } => self.layer(path, instance.as_ref()).await,
 			Source::Browser { url, width, height } => self.browser(url, *width, *height).await,
 			Source::Replay => {
 				let plays = self.plays.clone().expect("a replay source has plays");
@@ -1127,18 +1180,28 @@ impl Driver {
 		.await
 	}
 
-	/// Play the source called `source` that the broadcast this layer follows
-	/// publishes independently, from each instance of it, on the clock of the
-	/// broadcast source playing it.
-	async fn layer(&self, source: &str) -> Result<(), Error> {
-		let Some((path, schedule)) = &self.follows else {
+	/// Play the broadcast at `path` on the clock of the broadcast source this
+	/// layer plays on, from each instance of it, showing nothing of one
+	/// other than the stream `instance` names, whose timeline its offset is
+	/// not for. An instance a relay minted can neither match nor contradict
+	/// it, so it plays.
+	async fn layer(&self, path: &str, instance: Option<&moq_net::Instance>) -> Result<(), Error> {
+		let Some(schedule) = &self.follows else {
 			return Err(Error::Invalid(format!(
-				"layer `{}` follows no broadcast source",
+				"layer `{}` plays on no broadcast source",
 				self.name
 			)));
 		};
 		self.follow(path, |broadcast| {
-			Box::pin(self.play_layer(broadcast, path, source, schedule))
+			let serving = broadcast.info().instance.as_ref();
+			let other = instance
+				.zip(serving)
+				.is_some_and(|(named, serving)| !serving.is_minted() && named != serving);
+			if other {
+				self.picture.lock().unwrap().clear();
+				return Box::pin(std::future::pending());
+			}
+			Box::pin(self.play_layer(broadcast, path, schedule))
 		})
 		.await
 	}
@@ -1179,20 +1242,18 @@ impl Driver {
 		}
 	}
 
-	/// Decode one instance of a studio broadcast's source called `source`:
-	/// the first video and audio renditions its entry under the catalog's
-	/// [`SECTION`](crate::publish::SECTION) `sources` offers, switching as
-	/// the catalog changes them, until the catalog ends. Both play on
-	/// `schedule`, the program's clock, without moving it.
+	/// Decode one instance of a broadcast a composition lists: the first
+	/// video and audio renditions its catalog offers, or a still when it has
+	/// no video, switching as the catalog changes them, until the catalog
+	/// ends. Both play on `schedule`, the program's clock, without moving it.
 	async fn play_layer(
 		&self,
 		broadcast: moq_net::broadcast::Consumer,
 		path: &str,
-		source: &str,
 		schedule: &timeline::Consumer,
 	) -> Result<(), Error> {
 		let format = moq_mux::catalog::CatalogFormat::detect(path).unwrap_or_default();
-		let mut catalogs = moq_mux::catalog::Consumer::<crate::publish::Ext>::new(&broadcast, format).await?;
+		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, format).await?;
 		let mut video: Option<String> = None;
 		let mut audio: Option<String> = None;
 		let mut video_playing: Playing<'_> = Box::pin(std::future::pending());
@@ -1203,15 +1264,15 @@ impl Driver {
 					let Some(catalog) = catalog? else {
 						return Ok(());
 					};
-					let listed = catalog.ext.studio.sources.get(source);
-					let next_video = listed.map(|listed| pick(listed.video.enabled())).transpose()?.flatten();
-					let next_audio = listed.map(|listed| pick(listed.audio.enabled())).transpose()?.flatten();
+					let next_video = pick(catalog.video.enabled())?;
+					let next_audio = pick(catalog.audio.enabled())?;
 					// A source without video, such as an image or a color, is a still.
-					let still = listed.and_then(|listed| {
-						let mut stills = listed.binary.tracks.iter();
-						let (id, config) = stills.find(|(_, config)| config.broadcast.is_none() && config.mime.as_deref().is_some_and(|mime| mime.starts_with("image/")))?;
-						Some(Reference::track(config, id).to_string())
-					});
+					let still = {
+						let mut stills = catalog.binary.tracks.iter();
+						stills
+							.find(|(_, config)| config.broadcast.is_none() && config.mime.as_deref().is_some_and(|mime| mime.starts_with("image/")))
+							.map(|(id, config)| Reference::track(config, id).to_string())
+					};
 					let track = match &next_video {
 						Some((id, config)) => Some(Reference::track(config, id).to_string()),
 						None => still.clone(),
@@ -1283,12 +1344,18 @@ impl Driver {
 		let mut ended = false;
 		loop {
 			let now = kio::clock::now();
+			let offset = self.offset.load(Ordering::Relaxed);
+			// A picture moved off the clock's timeline never plays.
+			while queue.front().is_some_and(|frame| shift(frame.timestamp, offset).is_none()) {
+				queue.pop_front();
+			}
+			let on = |frame: &moq_video::Frame| shift(frame.timestamp, offset);
 			// Counted first: `present` holds the clock's lock while it iterates.
 			let heard_count = queue
 				.iter()
-				.take_while(|frame| heard(schedule, frame.timestamp, now))
+				.take_while(|frame| on(frame).is_some_and(|at| heard(schedule, at, now)))
 				.count();
-			let ready = queue.iter().take(heard_count).map(|frame| frame.timestamp);
+			let ready = queue.iter().take(heard_count).filter_map(on);
 			if let Some(index) = schedule.present(ready, now) {
 				let frame = queue.drain(..=index).next_back().expect("an index into the queue");
 				self.show(Picture::Frame(frame));
@@ -1297,9 +1364,9 @@ impl Driver {
 				return Ok(());
 			}
 			// Its moment, or once due, soon to see whether its sound has played.
-			let wake = queue.front().and_then(|frame| match schedule.due(frame.timestamp) {
+			let wake = queue.front().and_then(on).and_then(|at| match schedule.due(at) {
 				Some(due) if due > now => Some(due),
-				_ if !heard(schedule, frame.timestamp, now) => Some(now + crate::playout::RECHECK),
+				_ if !heard(schedule, at, now) => Some(now + crate::playout::RECHECK),
 				_ => None,
 			});
 			tokio::select! {
@@ -1345,9 +1412,15 @@ impl Driver {
 		let mut ended = false;
 		loop {
 			let now = kio::clock::now();
+			let offset = self.offset.load(Ordering::Relaxed);
 			let mut write = None;
 			while let Some(frame) = queue.front() {
-				match follow(schedule, frame.timestamp, now) {
+				// A sound moved off the clock's timeline never plays.
+				let Some(at) = shift(frame.timestamp, offset) else {
+					queue.pop_front();
+					continue;
+				};
+				match follow(schedule, at, now) {
 					Follow::Write(sounds) => {
 						let frame = queue.pop_front().expect("peeked");
 						writer.write(sounds, &frame.data).await?;
@@ -1370,7 +1443,8 @@ impl Driver {
 						// One due past the longest target would hold whatever a
 						// peer stamps.
 						let now = kio::clock::now();
-						let placed = schedule.due(frame.timestamp).is_some_and(|sounds| {
+						let at = shift(frame.timestamp, self.offset.load(Ordering::Relaxed));
+						let placed = at.and_then(|at| schedule.due(at)).is_some_and(|sounds| {
 							sounds >= now && sounds <= now + MAX_DELAY + WRITE_LEAD
 						});
 						if placed {
@@ -2306,14 +2380,14 @@ pub(crate) fn pick<'a, C: Reference + Clone + 'a>(
 }
 
 /// Start the feed for `source`, and the driver that fills it, `held` from
-/// playing a media file until the first [`Feed::play`]. A layer `follows` its
-/// broadcast's path and the clock of the broadcast source playing it.
+/// playing a media file until the first [`Feed::play`]. A layer `follows`
+/// the clock of the broadcast source it plays on.
 fn open(
 	name: &str,
 	source: &Source,
 	context: &Context,
 	held: bool,
-	follows: Option<(String, timeline::Consumer)>,
+	follows: Option<timeline::Consumer>,
 ) -> (Feed, Driver) {
 	let picture = Mailbox::default();
 	let delivered = Delivered::default();
@@ -2349,6 +2423,10 @@ fn open(
 		_ => (None, None),
 	};
 	let silent = Arc::<AtomicBool>::default();
+	let offset = Arc::new(AtomicI64::new(match source {
+		Source::Layer { offset, .. } => *offset,
+		_ => 0,
+	}));
 	let runs = Runs::new(Mutex::new(Latest {
 		run: Run::default(),
 		stopped: held,
@@ -2368,9 +2446,10 @@ fn open(
 		runs: runs.clone(),
 		silent: silent.clone(),
 		clock: match &follows {
-			Some((_, schedule)) => Some(schedule.clone()),
+			Some(schedule) => Some(schedule.clone()),
 			None => clock.as_ref().map(timeline::Producer::consume),
 		},
+		offset: offset.clone(),
 	};
 	let driver = Driver {
 		name: name.to_string(),
@@ -2389,6 +2468,7 @@ fn open(
 		silent,
 		clock,
 		follows,
+		offset,
 	};
 	(feed, driver)
 }
@@ -2401,7 +2481,7 @@ impl Source {
 	///
 	/// A broadcast, or a layer of one, is already published by its own
 	/// publisher, and a clone shows its source's track, its filters carried by
-	/// the layout rather than encoded again. Web pages and overlays are seen
+	/// the composition rather than encoded again. Web pages and overlays are seen
 	/// only in the program, since H.264 would encode their transparency over
 	/// black, a LUT is looked up, never shown, and a scene is drawn from other
 	/// sources.
@@ -2426,6 +2506,28 @@ impl Source {
 			| Source::Program => false,
 		}
 	}
+
+	/// Whether the source can be published independently, reaching viewers
+	/// as a broadcast of its own: one with a track of its own, which the
+	/// studio publishes, or a broadcast, already its publisher's.
+	pub fn independent(&self) -> bool {
+		self.publishes() || matches!(self, Source::Broadcast { .. })
+	}
+}
+
+/// `timestamp` moved `offset` microseconds, or `None` off a timestamp's range.
+fn shift(timestamp: moq_net::Timestamp, offset: i64) -> Option<moq_net::Timestamp> {
+	// Unmoved, it keeps its own timescale.
+	if offset == 0 {
+		return Some(timestamp);
+	}
+	let at = Duration::from(timestamp);
+	let by = Duration::from_micros(offset.unsigned_abs());
+	let moved = match offset > 0 {
+		true => at.checked_add(by)?,
+		false => at.checked_sub(by)?,
+	};
+	moq_net::Timestamp::try_from(moved).ok()
 }
 
 /// The frame rate a capture is encoded at when the device reports none.
@@ -3070,93 +3172,107 @@ mod tests {
 		.await;
 	}
 
-	/// A layer shows each picture when its broadcast source's clock says, as
-	/// the program's picture stamped alike shows, not its own delay after it
-	/// arrives.
+	/// A layer, a broadcast of its own, shows each picture when its broadcast
+	/// source's clock says the picture its offset puts it beside does, as the
+	/// program's picture stamped alike shows, not its own delay after it
+	/// arrives; a new offset moves the next picture without opening the
+	/// broadcast again.
 	#[tokio::test(start_paused = true)]
 	async fn a_layer_plays_on_its_broadcasts_clock() {
 		local(async {
 			let dir = tempfile::tempdir().unwrap();
 			let (context, origin) = context(dir.path());
-			let publication = origin
-				.route("room/guest", moq_net::origin::RouteOptions::hidden())
-				.unwrap();
+			let mut live = live(&origin, false).await;
+			// The camera's own broadcast, on a timeline 250 ms behind the
+			// program's.
+			let publication = origin.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap();
 			let mut broadcast = publication.broadcast().clone();
-			let config = moq_mux::catalog::Config::default().with_catalog(Default::default());
-			let mut catalog = crate::publish::Catalog::new(&mut broadcast, config).unwrap();
-			let (mut program, mut encoder) = rendition(&broadcast, catalog.timebase()).await;
-			// The camera's track is in the program's broadcast, listed under its
-			// name in the catalog's own section rather than as the program's.
-			let mut local = moq_net::broadcast::Info::new().produce();
-			let listing = moq_mux::catalog::Producer::new(&mut local, Default::default()).unwrap();
-			let (mut cam, mut cam_encoder) = rendition(&broadcast, listing.timebase()).await;
+			let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
+			let (mut cam, mut cam_encoder) = rendition(&broadcast, catalog.timebase()).await;
 			publication.announce().unwrap();
 
 			let mut collection = collection();
-			collection.sources.insert(
-				"cam".into(),
-				Source::Layer {
-					broadcast: "guest".into(),
-					source: "cam".into(),
-				},
-			);
+			let layer = |offset| Source::Layer {
+				clock: "guest".into(),
+				path: "room/cam".into(),
+				instance: None,
+				offset,
+			};
+			collection.sources.insert("cam".into(), layer(250_000));
 			collection.validate().unwrap();
 			let mut sources = Sources::new(context);
 			let drivers = sources.sync(&collection);
 			start(&sources, drivers).await;
-			let layer = sources.get("cam").unwrap();
 			let clock = sources.get("guest").unwrap().clock.clone().unwrap();
 
 			until_time(kio::clock::now()).await;
 			let arrived = kio::clock::now();
-			picture(&mut program, &mut encoder, 1_000);
+			picture(&mut live.video, &mut live.encoder, 1_000);
 			let stamp = moq_net::Timestamp::from_millis(1_000).unwrap();
 			let due = until(|| clock.due(stamp)).await;
 			assert_eq!(due, arrived + VIDEO_DELAY);
 
 			// Half the delay later, so on a clock of its own it would show late.
 			until_time(arrived + VIDEO_DELAY / 2).await;
-			picture(&mut cam, &mut cam_encoder, 1_000);
-			let listed = until(|| Some(listing.snapshot()).filter(|listed| !listed.video.renditions.is_empty())).await;
-			catalog
-				.mutate(|root| {
-					root.ext.studio.sources.insert("cam".into(), listed);
-				})
-				.unwrap();
+			picture(&mut cam, &mut cam_encoder, 750);
+			let layer_feed = sources.get("cam").unwrap();
 			until_time(due - Duration::from_millis(1)).await;
-			assert!(layer.next_picture().is_none(), "shown before its moment");
+			assert!(layer_feed.next_picture().is_none(), "shown before its moment");
 			until_time(due).await;
-			assert_eq!(shown(layer).await, Duration::from(stamp));
-			assert_eq!(layer.delay(), Some(VIDEO_DELAY), "the program's");
+			assert_eq!(shown(layer_feed).await, Duration::from_millis(750));
+			assert_eq!(layer_feed.delay(), Some(VIDEO_DELAY), "the program's");
+
+			// Moved 100 ms later onto the clock, it plays on.
+			collection.sources.insert("cam".into(), layer(350_000));
+			assert!(sources.sync(&collection).is_empty(), "opened again");
+			let layer_feed = sources.get("cam").unwrap();
+			picture(&mut live.video, &mut live.encoder, 1_200);
+			picture(&mut cam, &mut cam_encoder, 850);
+			let later = moq_net::Timestamp::from_millis(1_200).unwrap();
+			let due = until(|| clock.due(later)).await;
+			until_time(due - Duration::from_millis(1)).await;
+			assert!(layer_feed.next_picture().is_none(), "shown on its old offset");
+			until_time(due).await;
+			assert_eq!(shown(layer_feed).await, Duration::from_millis(850));
 		})
 		.await;
 	}
 
-	/// A layer whose source is a still, an image file on a binary track,
+	/// A timestamp moves by an offset either way, keeping its own timescale
+	/// unmoved, and one moved off a timestamp's range has no place.
+	#[test]
+	fn a_timestamp_shifts() {
+		let stamp = moq_net::Timestamp::from_millis(1_000).unwrap();
+		assert_eq!(shift(stamp, 0), Some(stamp));
+		assert_eq!(shift(stamp, 1_500).map(Duration::from), Some(Duration::from_micros(1_001_500)));
+		assert_eq!(shift(stamp, -1_000_000).map(Duration::from), Some(Duration::ZERO));
+		assert_eq!(shift(stamp, -1_000_001), None);
+		assert_eq!(shift(stamp, i64::MIN), None);
+	}
+
+	/// A layer whose broadcast is a still, an image file on a binary track,
 	/// shows it as it arrives.
 	#[tokio::test]
 	async fn a_layer_shows_a_still() {
 		local(async {
 			let dir = tempfile::tempdir().unwrap();
 			let (context, origin) = context(dir.path());
+			let _live = live(&origin, false).await;
 			let publication = origin
-				.route("room/guest", moq_net::origin::RouteOptions::hidden())
+				.route("room/logo", moq_net::origin::RouteOptions::hidden())
 				.unwrap();
 			let mut broadcast = publication.broadcast().clone();
-			let config = moq_mux::catalog::Config::default().with_catalog(Default::default());
-			let mut catalog = crate::publish::Catalog::new(&mut broadcast, config).unwrap();
-			let mut track = broadcast.create_track("source/logo.png", None).unwrap();
+			let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
+			let mut track = broadcast.create_track("logo.png", None).unwrap();
 			let pixel = image::RgbaImage::from_raw(1, 1, vec![255, 0, 0, 255]).unwrap();
 			let mut png = std::io::Cursor::new(Vec::new());
 			pixel.write_to(&mut png, image::ImageFormat::Png).unwrap();
 			track.write_frame(None, bytes::Bytes::from(png.into_inner())).unwrap();
 			let mut still = hang::catalog::BinaryConfig::new(hang::catalog::Mode::Snapshot);
 			still.mime = Some("image/png".into());
-			let mut logo = hang::Catalog::default();
-			logo.binary.tracks.insert("source/logo.png".into(), still);
 			catalog
 				.mutate(|root| {
-					root.ext.studio.sources.insert("logo".into(), logo);
+					root.binary.tracks.insert("logo.png".into(), still);
 				})
 				.unwrap();
 			publication.announce().unwrap();
@@ -3165,8 +3281,10 @@ mod tests {
 			collection.sources.insert(
 				"logo".into(),
 				Source::Layer {
-					broadcast: "guest".into(),
-					source: "logo".into(),
+					clock: "guest".into(),
+					path: "room/logo".into(),
+					instance: None,
+					offset: 0,
 				},
 			);
 			let mut sources = Sources::new(context);
@@ -3184,20 +3302,20 @@ mod tests {
 	}
 
 	/// A layer stops with its broadcast source, and starts again on its
-	/// replacement's clock.
+	/// replacement's clock, and opens again for another broadcast or stream.
 	#[tokio::test]
 	async fn a_layer_follows_its_broadcast_sources_replacement() {
 		local(async {
 			let dir = tempfile::tempdir().unwrap();
 			let (context, _origin) = context(dir.path());
 			let mut collection = collection();
-			collection.sources.insert(
-				"cam".into(),
-				Source::Layer {
-					broadcast: "guest".into(),
-					source: "cam".into(),
-				},
-			);
+			let layer = |path: &str, instance: Option<&str>| Source::Layer {
+				clock: "guest".into(),
+				path: path.into(),
+				instance: instance.map(|instance| instance.parse().unwrap()),
+				offset: 0,
+			};
+			collection.sources.insert("cam".into(), layer("room/cam", None));
 			let mut sources = Sources::new(context);
 			let drivers = sources.sync(&collection);
 			assert_eq!(drivers.len(), 3);
@@ -3215,6 +3333,16 @@ mod tests {
 				.collect();
 			names.sort();
 			assert_eq!(names, ["cam", "guest"]);
+
+			for edited in [layer("room/cam", Some("abc")), layer("room/screen", Some("abc"))] {
+				collection.sources.insert("cam".into(), edited);
+				let names: Vec<String> = sources
+					.sync(&collection)
+					.iter()
+					.map(|driver| driver.name().to_string())
+					.collect();
+				assert_eq!(names, ["cam"]);
+			}
 		})
 		.await;
 	}
@@ -3273,6 +3401,41 @@ mod tests {
 		.await;
 	}
 
+	/// A broadcast source's offset onto a timeline puts the picture it shows
+	/// where that timeline reads when it shows it, signed either way, and
+	/// there is none before its clock anchors.
+	#[tokio::test(start_paused = true)]
+	async fn a_broadcast_lands_on_a_timeline() {
+		local(async {
+			let dir = tempfile::tempdir().unwrap();
+			let (context, origin) = context(dir.path());
+			let mut live = live(&origin, false).await;
+			let mut sources = Sources::new(context);
+			let drivers = sources.sync(&collection());
+			start(&sources, drivers).await;
+			let feed = sources.get("guest").unwrap();
+			let clock = feed.clock.clone().unwrap();
+			assert_eq!(feed.offset(Duration::from_secs(5), kio::clock::now()), None, "unanchored");
+			assert_eq!(sources.get("red").unwrap().offset(Duration::ZERO, kio::clock::now()), None);
+
+			until_time(kio::clock::now()).await;
+			picture(&mut live.video, &mut live.encoder, 1_000);
+			let stamp = moq_net::Timestamp::from_millis(1_000).unwrap();
+			let due = until(|| clock.due(stamp)).await;
+			until_time(due).await;
+			assert_eq!(shown(feed).await, Duration::from(stamp));
+			assert!(feed.instance().is_some(), "an origin names the stream");
+			let now = kio::clock::now();
+			// Shown now, as the timeline reads 5 s: 4 s after its own stamp.
+			assert_eq!(feed.offset(Duration::from_secs(5), now), Some(4_000_000));
+			assert_eq!(feed.offset(Duration::from_millis(400), now), Some(-600_000));
+			// Read 10 ms later, it was shown 10 ms before then.
+			let later = now + Duration::from_millis(10);
+			assert_eq!(feed.offset(Duration::from_secs(5), later), Some(3_990_000));
+		})
+		.await;
+	}
+
 	/// A picture waits for the sound stamped with it, which plays the jitter
 	/// estimate after it arrives, rather than showing on its own delay.
 	#[tokio::test(start_paused = true)]
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 541a880..d65f483 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -41,7 +41,7 @@ use kio::clock::Instant;
 use moq_net::bandwidth;
 use moq_scene::publish::{Encoding, Sessions};
 use moq_scene::source::{self, Driver, Sources, Status};
-use moq_scene::{Canvas, Collection, Compositor, Draft, Edit, History, Scaler, wgpu};
+use moq_scene::{Canvas, Collection, Compositor, Draft, Edit, History, Scaler, Source, wgpu};
 use moq_video::render::export::{Exporter, Pending, Route};
 use tokio::sync::oneshot::error::TryRecvError;
 
@@ -654,12 +654,12 @@ pub struct Program {
 	clock: moq_mux::Clock,
 	/// Where the local sources keep their own tracks, on the same clock.
 	sources: moq_scene::publish::Publish,
-	/// The sources published independently, whose tracks the broadcast
-	/// carries beside the program's.
+	/// The sources published independently, each a broadcast of its own
+	/// beside the program's when it is local.
 	published: tokio::sync::watch::Sender<BTreeSet<String>>,
-	/// Where and when the broadcast's viewers show those sources, while any
-	/// is published.
-	layout: Mutex<moq_scene::layout::Publisher>,
+	/// The composition: where and when viewers show those sources over the
+	/// program.
+	composition: Mutex<Composed>,
 	/// What a recording reads the program from, on the same clock.
 	recording: moq_net::origin::Route,
 	/// The recording broadcast's catalog, held for as long as the engine runs,
@@ -673,19 +673,65 @@ pub struct Program {
 	_audio: bandwidth::Reservation,
 }
 
+/// The composition's broadcast, and where it finds what it lists.
+struct Composed {
+	/// The composition's broadcast, announced beside the program's.
+	route: moq_net::origin::Route,
+	publisher: moq_scene::composition::Publisher,
+	/// The composition's path, which each child's is relative to.
+	path: moq_net::Path,
+	/// The program's path.
+	program: moq_net::Path,
+	/// Where each local source published independently has its broadcast.
+	sources: moq_net::Path,
+}
+
+impl Composed {
+	/// Announce the composition beneath the program's broadcast at `program`
+	/// on `origin`, its catalog on the program's `clock`.
+	fn new(origin: &moq_net::origin::Producer, program: &moq_net::Path, clock: moq_mux::Clock) -> anyhow::Result<Self> {
+		let below = |name: &'static str| program.join(&moq_net::Path::from_static(name));
+		let path = below(moq_scene::composition::PATH)?;
+		let route = origin
+			.route(&path, moq_net::origin::RouteOptions::hidden())
+			.context("cannot create the composition's broadcast")?;
+		let publisher = moq_scene::composition::Publisher::new(&mut route.broadcast().clone(), clock)?;
+		route.announce().context("cannot announce the composition")?;
+		Ok(Self {
+			route,
+			publisher,
+			path,
+			program: program.clone(),
+			sources: below(moq_scene::composition::SOURCES)?,
+		})
+	}
+
+	/// Where the source called `name` is, relative to the composition: the
+	/// broadcast it plays at `path` for a broadcast source, else the local
+	/// one it is published to. `None` for a path no reference can name.
+	fn child(&self, name: &str, path: Option<&str>) -> Option<moq_net::path::Relative> {
+		let path = match path {
+			Some(path) => moq_net::Path::new(path).ok()?,
+			None => self.sources.join(&moq_net::Path::new(name).ok()?).ok()?,
+		};
+		path.relative(&self.path)
+	}
+}
+
 impl Drop for Program {
 	fn drop(&mut self) {
 		self.publication.broadcast().close();
+		self.composition.lock().unwrap().route.broadcast().close();
 	}
 }
 
 impl Program {
-	/// End the layer layout, then finish the program's catalog and the
+	/// End the composition, then finish the program's catalog and the
 	/// recording's, once every track they list has ended, so a viewer or a
 	/// recording reading either reaches its end rather than a cut.
 	fn finish(&self) {
-		if let Err(err) = self.layout.lock().unwrap().finish() {
-			tracing::warn!(%err, "cannot finish the layer layout");
+		if let Err(err) = self.composition.lock().unwrap().publisher.finish() {
+			tracing::warn!(%err, "cannot finish the composition");
 		}
 		for catalog in [&self.catalog, &self.recorded] {
 			// Fails only once the catalog failed, which ended its tracks already.
@@ -771,28 +817,47 @@ impl Program {
 			.set_on_program(moq_scene::publish::OnProgram { shown, heard });
 	}
 
-	/// Publish the layer layout of what `state` drew on program at `at` on
-	/// the media clock, while any source is published independently.
-	fn lay_out(&self, state: &State, at: Duration) {
+	/// Publish the composition of what `state` drew on program at `at` on
+	/// the media clock, at `now`: the program, and each source published
+	/// independently that is online, a broadcast source where what it showed
+	/// then lands on the program's clock.
+	fn compose(&self, state: &State, at: Duration, now: Instant) {
 		// Past what a timestamp holds, the frame goes unstamped too.
 		let Ok(stamp) = moq_net::Timestamp::try_from(at) else {
 			return;
 		};
 		let collection = &state.collection;
-		let mut publisher = self.layout.lock().unwrap();
-		let published = match collection.published.is_empty() {
-			true => publisher.finish(),
-			false => {
-				// To the whole microsecond as the frame's stamp is, rather than
-				// rounded as the wire would, so a cut's layout starts on its frame.
-				let start = at.saturating_sub(state.compositor.program_since()).as_micros();
-				let start = Duration::from_micros(start as u64);
-				let layout = moq_scene::layout::Layout::new(collection, state.compositor.program_scene(), start);
-				publisher.update(layout, stamp)
-			}
+		let mut composed = self.composition.lock().unwrap();
+		let mut children = BTreeMap::new();
+		for name in &collection.published {
+			let child = match collection.sources.get(name) {
+				Some(Source::Broadcast { path }) => {
+					// Offline, or not yet playing, it shows nothing here either.
+					let Some(feed) = state.sources.get(name) else { continue };
+					let Some(offset) = feed.offset(at, now) else { continue };
+					let Some(broadcast) = composed.child(name, Some(path)) else { continue };
+					moq_scene::composition::Child::new(broadcast, feed.instance(), offset)
+				}
+				Some(_) => match composed.child(name, None) {
+					Some(broadcast) => moq_scene::composition::Child::new(broadcast, None, 0),
+					None => continue,
+				},
+				None => continue,
+			};
+			children.insert(name.clone(), child);
+		}
+		let program = moq_scene::composition::Program {
+			broadcast: composed.program.relative(&composed.path).expect("the program is above it"),
+			instance: Some(self.publication.instance()),
 		};
-		if let Err(err) = published {
-			tracing::warn!(%err, "cannot publish the layer layout");
+		// To the whole microsecond as the frame's stamp is, rather than
+		// rounded as the wire would, so a cut's composition starts on its frame.
+		let start = at.saturating_sub(state.compositor.program_since()).as_micros();
+		let start = Duration::from_micros(start as u64);
+		let scene = state.compositor.program_scene();
+		let composition = moq_scene::composition::Composition::new(collection, scene, start, program, children);
+		if let Err(err) = composed.publisher.update(composition, stamp) {
+			tracing::warn!(%err, "cannot publish the composition");
 		}
 	}
 }
@@ -1546,7 +1611,7 @@ impl Engine {
 					continue;
 				}
 				self.program.on_program(state, shown);
-				self.program.lay_out(state, at);
+				self.program.compose(state, at, tick);
 				let compositor = &state.compositor;
 				for (scene, camera) in &mut state.cameras {
 					match scene {
@@ -1881,15 +1946,15 @@ async fn publish(
 	let epoch = Duration::ZERO;
 	publication.announce().context("cannot announce the broadcast")?;
 
+	let composition = Composed::new(&origin, path, clock.clone())?;
 	let (published, follow) = tokio::sync::watch::channel(BTreeSet::new());
-	let forward = (sources.clone(), broadcast.clone(), listed.clone(), bandwidth.clone());
+	let forward = (sources.clone(), origin.clone(), composition.sources.clone(), bandwidth.clone());
 	tokio::spawn(async move {
-		let (sources, broadcast, catalog, bandwidth) = forward;
-		if let Err(err) = sources.forward(follow, broadcast, catalog, bandwidth).await {
+		let (sources, origin, base, bandwidth) = forward;
+		if let Err(err) = sources.forward(follow, origin, base, bandwidth).await {
 			tracing::warn!(%err, "stopped publishing sources independently");
 		}
 	});
-	let layout = Mutex::new(moq_scene::layout::Publisher::new(broadcast.clone(), listed.clone()));
 
 	let health = match live {
 		Some(live) => {
@@ -1915,7 +1980,7 @@ async fn publish(
 			clock: clock.clone(),
 			sources: sources.clone(),
 			published,
-			layout,
+			composition: Mutex::new(composition),
 			recording,
 			recorded,
 			local,
@@ -2534,6 +2599,10 @@ impl Extras {
 				"scene `{name}` would publish where viewers report back; rename it to publish it"
 			);
 		}
+		anyhow::ensure!(
+			name != moq_scene::composition::PATH,
+			"scene `{name}` would publish where the composition is; rename it to publish it"
+		);
 		let publication = self
 			.origin
 			.route(&path, moq_net::origin::RouteOptions::hidden())
@@ -3204,15 +3273,18 @@ mod tests {
 			.collect()
 	}
 
-	/// A source published independently goes on the program broadcast's
-	/// layer layout, from when its scene went on program: a cut's layout
-	/// takes effect on the frame its scene starts. Once nothing is published,
-	/// the layout ends and the catalog stops listing it, and quitting ends a
-	/// layout published again.
+	/// The studio publishes a composition beside the program, on its clock:
+	/// the program, and each source published independently as a broadcast
+	/// of its own beneath it at offset zero, from when its scene went on
+	/// program, so a cut's composition takes effect on the frame its scene
+	/// starts. Once nothing is published, the composition lists the program
+	/// alone and the source's broadcast ends, and quitting ends the
+	/// composition.
 	#[tokio::test(flavor = "multi_thread")]
 	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
-	async fn the_program_carries_a_layer_layout() {
-		use moq_scene::layout::{Layout, TRACK};
+	async fn the_studio_publishes_a_composition() {
+		use moq_mux::catalog::Stream;
+		use moq_scene::composition::{Composition, TRACK};
 
 		let dir = tempfile::tempdir().unwrap();
 		let gpu = Gpu::new().await.expect("a GPU");
@@ -3226,68 +3298,81 @@ mod tests {
 			.await
 			.expect("the studio starts");
 
-		let broadcast = engine.program.publication.broadcast().consume();
-		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default())
+		let composed = engine.program.composition.lock().unwrap().route.broadcast().consume();
+		assert_eq!(composed.info().path.as_str(), "studio/composition");
+		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&composed, Default::default())
 			.await
-			.expect("the program's catalog");
-		let listed = |catalog: &hang::Catalog| catalog.json.tracks.contains_key(TRACK);
-		kio::clock::timeout(TIMEOUT, async {
-			while !catalogs.next().await.unwrap().is_some_and(|catalog| listed(&catalog)) {}
+			.expect("the composition's catalog");
+		let catalog = kio::clock::timeout(TIMEOUT, async {
+			loop {
+				let catalog = catalogs.next().await.unwrap().expect("a catalog");
+				if catalog.json.tracks.contains_key(TRACK) {
+					return catalog;
+				}
+			}
 		})
 		.await
-		.expect("the catalog lists the layout");
-		let read = || moq_json::snapshot::Consumer::<Layout>::new(broadcast.track(TRACK).unwrap(), Default::default());
-		let next = async |layouts: &mut moq_json::snapshot::Consumer<Layout>| {
-			kio::clock::timeout(TIMEOUT, layouts.next())
+		.expect("the catalog lists the composition");
+		assert_eq!(catalog.media.clock, engine.program.clock.wall(), "the program's clock");
+
+		let mut compositions = moq_json::snapshot::Consumer::<Composition>::new(
+			composed.track(TRACK).unwrap(),
+			Default::default(),
+		);
+		let next = async |compositions: &mut moq_json::snapshot::Consumer<Composition>| {
+			kio::clock::timeout(TIMEOUT, compositions.next())
 				.await
-				.expect("a layout or its end")
+				.expect("a composition or its end")
 				.unwrap()
 		};
-		let mut layouts = read();
-		let first = next(&mut layouts).await.expect("a layout");
-		let sources: Vec<&str> = first
-			.value
-			.pictures
-			.iter()
-			.map(|picture| picture.item.source.as_str())
-			.collect();
+		let first = next(&mut compositions).await.expect("a composition");
+		assert_eq!(first.value.program.broadcast.as_str(), ".");
+		assert_eq!(first.value.program.instance, Some(engine.program.publication.instance()));
+		let sources: Vec<&str> = first.value.pictures.iter().map(|item| item.source.as_str()).collect();
 		assert_eq!(sources, ["red"]);
+		let red = &first.value.sources["red"];
+		assert_eq!((red.broadcast.as_str(), red.offset, &red.instance), ("source/red", 0, &None));
+
+		// Its own broadcast, on the program's clock.
+		let origin = engine.program._origin.consume();
+		let mut following = origin.follow("studio/source/red", None).unwrap();
+		let broadcast = kio::clock::timeout(TIMEOUT, following.available())
+			.await
+			.expect("the source's broadcast")
+			.unwrap()
+			.expect("online");
+		let mut own = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default())
+			.await
+			.expect("the source's catalog");
+		let listed = own.next().await.unwrap().expect("a catalog");
+		assert_eq!(listed.media.clock, engine.program.clock.wall(), "the program's clock");
+		assert!(!listed.binary.tracks.is_empty(), "the color's still");
 
 		{
 			let mut state = engine.state.lock().unwrap();
 			state.compositor.set_preview(Some("Two".into()));
 			state.cut().unwrap();
 		}
-		let cut = next(&mut layouts).await.expect("a layout");
+		let cut = next(&mut compositions).await.expect("a composition");
 		let at = Duration::from(cut.at.expect("stamped"));
 		assert_eq!(cut.value.start, at, "on from the frame the cut drew");
 		assert!(cut.value.start > first.value.start);
 
-		let publish = |published: bool| {
+		{
 			let mut state = engine.state.lock().unwrap();
-			let mut draft = state.collection().draft("Publish `red`");
-			draft.set_published("red", published).unwrap();
+			let mut draft = state.collection().draft("Stop publishing `red`");
+			draft.set_published("red", false).unwrap();
 			state.commit(draft, None).unwrap();
-		};
-		publish(false);
-		assert!(next(&mut layouts).await.is_none(), "the layout ends");
-		kio::clock::timeout(TIMEOUT, async {
-			while catalogs.next().await.unwrap().is_some_and(|catalog| listed(&catalog)) {}
-		})
-		.await
-		.expect("the catalog stops listing the layout");
+		}
+		let alone = next(&mut compositions).await.expect("a composition");
+		assert!(alone.value.sources.is_empty() && alone.value.pictures.is_empty(), "the program alone");
+		kio::clock::timeout(TIMEOUT, async { while own.next().await.unwrap().is_some() {} })
+			.await
+			.expect("the source's broadcast ends");
 
-		publish(true);
-		kio::clock::timeout(TIMEOUT, async {
-			while !catalogs.next().await.unwrap().is_some_and(|catalog| listed(&catalog)) {}
-		})
-		.await
-		.expect("the catalog lists the layout again");
-		let mut layouts = read();
-		next(&mut layouts).await.expect("a layout");
 		let stopping = engine.clone();
 		tokio::task::spawn_blocking(move || stopping.stop()).await.unwrap();
-		assert!(next(&mut layouts).await.is_none(), "quitting ends the layout");
+		assert!(next(&mut compositions).await.is_none(), "quitting ends the composition");
 		kio::clock::timeout(TIMEOUT, engine.close())
 			.await
 			.expect("the studio closes");
diff --git a/rs/moq-studio/src/main.rs b/rs/moq-studio/src/main.rs
index 0c90571..8e46a71 100644
--- a/rs/moq-studio/src/main.rs
+++ b/rs/moq-studio/src/main.rs
@@ -44,15 +44,16 @@ pub struct Config {
 	#[usage(value_hint = usage_rs::ValueHint::FilePath, extensions("toml"))]
 	pub scenes: Option<PathBuf>,
 
-	/// Play a studio broadcast instead, as a viewer sees it: the program with
-	/// each source published independently over it. The URL's path names the
-	/// broadcast, as `moq play`'s does, such as
-	/// `https://relay.example/anon/studio`. A prototype, until `moq play` plays
-	/// the layer layout.
+	/// Play a studio broadcast instead, as a viewer sees it: its composition,
+	/// the program with each source published independently over it. The URL
+	/// names the relay, as `--connect` does, and `--broadcast` the studio's
+	/// broadcast under it, such as `https://relay.example/anon` and `studio`.
+	/// A prototype, until `moq play` plays compositions.
 	#[usage(long)]
 	pub watch: Option<url::Url>,
 
-	/// The broadcast path the program is published at.
+	/// The broadcast path the program is published at, or with `--watch`, is
+	/// played from.
 	#[usage(long, default = "studio")]
 	pub broadcast: String,
 
@@ -184,7 +185,7 @@ fn main() -> anyhow::Result<ExitCode> {
 	moq_tokio::cli::check_env(&[Config::spec()], &[])?;
 	let Some(scenes) = config.scenes()? else {
 		let url = config.watch.clone().expect("checked by scenes");
-		watch::run(config.client.clone(), config.quic.clone(), url)?;
+		watch::run(config.client.clone(), config.quic.clone(), url, &config.broadcast)?;
 		return Ok(ExitCode::SUCCESS);
 	};
 	let scenes = scenes.to_path_buf();
@@ -526,7 +527,7 @@ mod tests {
 			let args: Vec<_> = args.iter().map(std::ffi::OsStr::new).collect();
 			Config::parse_from(&args).unwrap()
 		};
-		let watch = parse(&["--watch", "https://relay.example/anon/studio"]);
+		let watch = parse(&["--watch", "https://relay.example/anon", "--broadcast", "studio"]);
 		assert_eq!(watch.scenes().unwrap(), None);
 		for refused in [
 			&["show.toml", "--watch", "https://a/b"][..],
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index c4228f8..2b9b3b3 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -2031,17 +2031,26 @@ impl Panels {
 						{
 							reload = Some(name.clone());
 						}
-						if source.publishes() {
+						if source.independent() {
 							let mut published = collection.published.contains(name);
+							let hover = match source {
+								Source::Broadcast { .. } => {
+									"Leave this broadcast out of the program and list it in the composition, for \
+									 viewers to play from its publisher and place over the program as the studio \
+									 does. Every player must reproduce how it is placed, so it takes no filter but \
+									 opacity and no blend mode, and not its background removed."
+								}
+								_ => {
+									"Publish this source's own track to the relay as a broadcast of its own, for \
+									 viewers to place over the program as the composition says, and leave it out \
+									 of the program. It encodes for as long as it is published. Every player must \
+									 reproduce how it is placed, so it takes no filter but opacity and no blend \
+									 mode, and not its background removed, since its track keeps the background."
+								}
+							};
 							if ui
 								.checkbox(&mut published, "Published independently")
-								.on_hover_text(
-									"Publish this source's own track to the relay beside the program, for viewers to \
-									 place over it as the layer layout says, and leave it out of the program. It \
-									 encodes for as long as it is published. Every player must reproduce how it is \
-									 placed, so it takes no filter but opacity and no blend mode, and not its \
-									 background removed, since its track keeps the background.",
-								)
+								.on_hover_text(hover)
 								.changed()
 							{
 								publish = Some((name.clone(), published));
@@ -4508,7 +4517,7 @@ fn describe(source: &Source) -> String {
 		Source::Replay => "replay".into(),
 		Source::Lut { path } => format!("LUT: {}", path.display()),
 		Source::Scene { scene } => format!("scene: {scene}"),
-		Source::Layer { broadcast, source } => format!("{source}, published in {broadcast}"),
+		Source::Layer { path, .. } => format!("composed: {path}"),
 		Source::Program => "program".into(),
 	}
 }
diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs
index 1f7c916..93219e4 100644
--- a/rs/moq-studio/src/watch.rs
+++ b/rs/moq-studio/src/watch.rs
@@ -1,15 +1,17 @@
-//! `--watch`: play a studio broadcast as a viewer would, the program with each
-//! source the [layer layout](moq_scene::layout) names composited over it and
-//! mixed with it, on the program's media clock.
+//! `--watch`: play a studio's [composition](moq_scene::composition) as a
+//! viewer would: the program, with each broadcast the composition lists
+//! composited over it and mixed with it, on the program's media clock.
 //!
-//! A prototype for settling the layout's format before hang specifies one,
-//! built on moq-scene: a collection the layout drives, rather than a scene
-//! file, whose one scene draws the program, a [`Source::Broadcast`], under
-//! each picture's [`Source::Layer`]. Each layer plays its own tracks on the
-//! program's playout clock, each layout takes effect when the program reaches
-//! the media time it is stamped with, and its pictures' keyframes play from
-//! its `start` on that clock. A layout of another version is refused loudly,
-//! and the program plays alone.
+//! A prototype for settling the composition's format before hang specifies
+//! one, built on moq-scene: a collection the composition drives, rather than a
+//! scene file, whose one scene draws the program, a [`Source::Broadcast`],
+//! under each picture's [`Source::Layer`]. Each layer plays its own
+//! broadcast on the program's playout clock, its timestamps moved by the
+//! offset the composition gives it, each composition takes effect when the
+//! program reaches the media time it is stamped with, and its pictures'
+//! keyframes play from its `start` on that clock. A composition of another
+//! version, or one this player cannot place, is refused loudly, and the
+//! program plays alone.
 
 use std::collections::{BTreeSet, VecDeque};
 use std::time::Duration;
@@ -17,8 +19,7 @@ use std::time::Duration;
 use anyhow::Context;
 use kio::clock::Instant;
 use moq_mux::timeline;
-use moq_scene::layout::{self, Layout};
-use moq_scene::publish::Ext;
+use moq_scene::composition::{self, Composition};
 use moq_scene::source::{self, MAX_DELAY, Sources, Status};
 use moq_scene::{AudioScene, Canvas, Collection, Compositor, Item, Rect, Scene, Source};
 
@@ -37,21 +38,28 @@ const LAYER: &str = "layer/";
 /// The scene on program.
 const SCENE: &str = "watch";
 
-/// The canvas until the program's catalog or a layout gives its size.
+/// The canvas until the program's catalog or a composition gives its size.
 const CANVAS: Canvas = Canvas {
 	width: 1280,
 	height: 720,
 	framerate: 30,
 };
 
-/// Play the broadcast at `url` until the window closes. Its path names the
-/// broadcast, as `moq play`'s does, and `client` dials it.
-pub fn run(client: moq_tokio::connect::Config, quic: moq_tokio::quic::Config, url: url::Url) -> anyhow::Result<()> {
+/// Play the composition of the studio broadcast at `broadcast` on the relay
+/// `client` dials at `url`, until the window closes.
+pub fn run(
+	client: moq_tokio::connect::Config,
+	quic: moq_tokio::quic::Config,
+	url: url::Url,
+	broadcast: &str,
+) -> anyhow::Result<()> {
+	let program = moq_net::Path::new(broadcast).context("invalid --broadcast")?;
+	let at = program.join(&moq_net::Path::from_static(composition::PATH))?;
 	let runtime = tokio::runtime::Runtime::new()?;
 	let _runtime = runtime.enter();
 	let client = client.init(quic)?;
 	let origin = moq_tokio::origin::spawn();
-	tracing::info!(url = %moq_tokio::RedactedUrl::new(&url), "watching");
+	tracing::info!(url = %moq_tokio::RedactedUrl::new(&url), composition = %at, "watching");
 	let connection = client.with_subscriber(origin.clone()).connect(url.clone());
 
 	let gpu = pollster::block_on(Gpu::new())?;
@@ -77,21 +85,25 @@ pub fn run(client: moq_tokio::connect::Config, quic: moq_tokio::quic::Config, ur
 		publish: None,
 		browser: None,
 	});
-	let collection = collection(None, CANVAS)?;
+	let paths = Paths { program, at };
+	let collection = collection(None, CANVAS, &paths)?;
 	let mut compositor = Compositor::new(&gpu.device, &gpu.queue, collection.canvas)?;
 	compositor.set_previewing(false);
 	compositor.set_preview(Some(SCENE.into()));
 	compositor.cut(&collection, &sources)?;
 
 	let (read, _) = watch::channel(Read::default());
-	runtime.spawn(follow(origin.consume(), read.clone()));
+	runtime.spawn(follow(origin.consume(), paths.at.clone(), read.clone()));
+	runtime.spawn(size(origin.consume(), paths.program.clone(), read.clone()));
 
 	let watch = Watch {
-		url: moq_tokio::RedactedUrl::new(&url).to_string(),
+		url: format!("{} at {}", moq_tokio::RedactedUrl::new(&url), paths.program),
 		read,
+		paths,
 		collection,
 		synced: false,
-		layout: None,
+		composition: None,
+		applied: false,
 		size: None,
 		sources,
 		compositor,
@@ -149,34 +161,42 @@ async fn advance(start: Instant, config: moq_audio::bus::Config, mut mixer: sour
 	}
 }
 
-/// What the broadcast's catalog and layout track say, for the window to apply.
+/// Where the watched broadcasts are, from the connection's root.
+struct Paths {
+	/// The program's.
+	program: moq_net::Path,
+	/// The composition's, which its references are relative to.
+	at: moq_net::Path,
+}
+
+/// What the program's catalog and the composition track say, for the window
+/// to apply.
 #[derive(Default)]
 struct Read {
 	/// The program's picture size, from its catalog.
 	size: Option<(u32, u32)>,
-	/// Each layout read, or `None` for the program alone, and the media time
-	/// it takes effect at, or `None` for at once, oldest first.
-	pending: VecDeque<(Option<Layout>, Option<moq_net::Timestamp>)>,
-	/// Why the layout was refused, so the program plays alone.
+	/// Each composition read, or `None` for the program alone, and the media
+	/// time it takes effect at, or `None` for at once, oldest first.
+	pending: VecDeque<(Option<Composition>, Option<moq_net::Timestamp>)>,
+	/// Why the composition was refused, so the program plays alone.
 	refused: Option<String>,
 }
 
 impl Read {
-	/// Forget what an instance of the broadcast said, as another replaces it
-	/// or it goes offline: its stamps are not the next one's.
+	/// Forget what an instance of the composition said, as another replaces
+	/// it or it goes offline: its stamps are not the next one's.
 	fn reset(&mut self) {
-		self.size = None;
 		self.refused = None;
 		self.pending.clear();
 		self.pending.push_back((None, None));
 	}
 
-	/// Queue `layout` to take effect at `at`, or at once for `None`, which
-	/// supersedes every layout still waiting so a stalled program cannot hold
-	/// them up. The program plays at most [`MAX_DELAY`] behind what arrives,
-	/// so of the layouts stamped that far before it, all due by now, only the
-	/// newest is kept.
-	fn push(&mut self, layout: Option<Layout>, at: Option<moq_net::Timestamp>) {
+	/// Queue `composition` to take effect at `at`, or at once for `None`,
+	/// which supersedes every composition still waiting so a stalled program
+	/// cannot hold them up. The program plays at most [`MAX_DELAY`] behind
+	/// what arrives, so of the compositions stamped that far before it, all
+	/// due by now, only the newest is kept.
+	fn push(&mut self, composition: Option<Composition>, at: Option<moq_net::Timestamp>) {
 		match at {
 			None => self.pending.clear(),
 			Some(at) => {
@@ -186,13 +206,14 @@ impl Read {
 				self.pending.drain(..passed.count().saturating_sub(1));
 			}
 		}
-		self.pending.push_back((layout, at));
+		self.pending.push_back((composition, at));
 	}
 
-	/// Take the newest layout due at `now`: each takes effect once the program
-	/// plays the frame it is stamped with on `schedule`, and its sound has
-	/// played. `None` while none is due; `Some(None)` for the program alone.
-	fn take_due(&mut self, schedule: Option<&timeline::Consumer>, now: Instant) -> Option<Option<Layout>> {
+	/// Take the newest composition due at `now`: each takes effect once the
+	/// program plays the frame it is stamped with on `schedule`, and its sound
+	/// has played. `None` while none is due; `Some(None)` for the program
+	/// alone.
+	fn take_due(&mut self, schedule: Option<&timeline::Consumer>, now: Instant) -> Option<Option<Composition>> {
 		let mut taken = None;
 		while let Some((_, at)) = self.pending.front() {
 			let due = match at {
@@ -204,20 +225,64 @@ impl Read {
 			if !due {
 				break;
 			}
-			taken = self.pending.pop_front().map(|(layout, _)| layout);
+			taken = self.pending.pop_front().map(|(composition, _)| composition);
 		}
 		taken
 	}
 }
 
-/// Read each instance of the root broadcast as it comes online: the program's
-/// size from its catalog, and each layout from the layout track while the
-/// catalog lists it.
-async fn follow(origin: moq_net::origin::Consumer, read: watch::Sender<Read>) {
-	let mut instances = match origin.follow("", None) {
+/// Read the program's size from each catalog of each instance of the
+/// broadcast at `path` as it comes online.
+async fn size(origin: moq_net::origin::Consumer, path: moq_net::Path, read: watch::Sender<Read>) {
+	let mut instances = match origin.follow(path, None) {
 		Ok(instances) => instances,
 		Err(err) => {
-			tracing::error!(%err, "cannot follow the broadcast");
+			tracing::error!(%err, "cannot follow the program");
+			return;
+		}
+	};
+	let set = |size| read.send_if_modified(|read| std::mem::replace(&mut read.size, size) != size);
+	let mut playing = None;
+	loop {
+		tokio::select! {
+			event = instances.available() => match event {
+				Ok(Some(broadcast)) => playing = Some(Box::pin(catalogs(broadcast, set))),
+				Ok(None) => {
+					set(None);
+					playing = None;
+				}
+				Err(err) => {
+					tracing::error!(%err, "the program's announcements failed");
+					return;
+				}
+			},
+			result = async { playing.as_mut().expect("guarded").await }, if playing.is_some() => {
+				playing = None;
+				if let Err(err) = result {
+					tracing::warn!(error = format!("{err:#}"), "cannot read the program's catalog");
+				}
+			}
+		}
+	}
+}
+
+/// Hand `set` the picture size of each catalog of `broadcast`.
+async fn catalogs(broadcast: moq_net::broadcast::Consumer, set: impl Fn(Option<(u32, u32)>) -> bool) -> anyhow::Result<()> {
+	let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default()).await?;
+	while let Some(catalog) = moq_mux::catalog::Stream::next(&mut catalogs).await? {
+		let size = catalog.video.renditions.values().find_map(|config| config.coded_width.zip(config.coded_height));
+		set(size);
+	}
+	Ok(())
+}
+
+/// Read each instance of the composition broadcast at `path` as it comes
+/// online.
+async fn follow(origin: moq_net::origin::Consumer, path: moq_net::Path, read: watch::Sender<Read>) {
+	let mut instances = match origin.follow(path, None) {
+		Ok(instances) => instances,
+		Err(err) => {
+			tracing::error!(%err, "cannot follow the composition");
 			return;
 		}
 	};
@@ -234,26 +299,26 @@ async fn follow(origin: moq_net::origin::Consumer, read: watch::Sender<Read>) {
 					playing = None;
 				}
 				Err(err) => {
-					tracing::error!(%err, "the broadcast's announcements failed");
+					tracing::error!(%err, "the composition's announcements failed");
 					return;
 				}
 			},
 			result = async { playing.as_mut().expect("guarded").await }, if playing.is_some() => {
 				playing = None;
 				if let Err(err) = result {
-					tracing::warn!(error = format!("{err:#}"), "cannot read the broadcast's layout");
+					tracing::warn!(error = format!("{err:#}"), "cannot read the composition");
 				}
 			}
 		}
 	}
 }
 
-/// Read one instance of the broadcast until its catalog ends.
+/// Read one instance of the composition broadcast until its catalog ends:
+/// each composition while the catalog lists its track.
 async fn instance(broadcast: moq_net::broadcast::Consumer, read: watch::Sender<Read>) -> anyhow::Result<()> {
-	let mut catalogs =
-		moq_mux::catalog::Consumer::<Ext>::new(&broadcast, moq_mux::catalog::CatalogFormat::default()).await?;
-	let mut layouts: Option<moq_json::snapshot::Consumer<Layout>> = None;
-	// A refused layout stays refused for this instance.
+	let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default()).await?;
+	let mut compositions: Option<moq_json::snapshot::Consumer<Composition>> = None;
+	// A refused composition stays refused for this instance.
 	let mut refused = false;
 	let alone = || read.send_modify(|read| read.push(None, None));
 	loop {
@@ -263,25 +328,23 @@ async fn instance(broadcast: moq_net::broadcast::Consumer, read: watch::Sender<R
 					alone();
 					return Ok(());
 				};
-				let size = catalog.video.renditions.values().find_map(|config| config.coded_width.zip(config.coded_height));
-				read.send_if_modified(|read| std::mem::replace(&mut read.size, size) != size);
-				let listed = catalog.json.tracks.contains_key(layout::TRACK);
-				if listed && layouts.is_none() && !refused {
-					let track = broadcast.track(layout::TRACK)?;
-					layouts = Some(moq_json::snapshot::Consumer::new(track, Default::default()));
-				} else if !listed && layouts.take().is_some() {
+				let listed = catalog.json.tracks.contains_key(composition::TRACK);
+				if listed && compositions.is_none() && !refused {
+					let track = broadcast.track(composition::TRACK)?;
+					compositions = Some(moq_json::snapshot::Consumer::new(track, Default::default()));
+				} else if !listed && compositions.take().is_some() {
 					alone();
 				}
 			}
-			next = async { layouts.as_mut().expect("guarded").next().await }, if layouts.is_some() => match next {
+			next = async { compositions.as_mut().expect("guarded").next().await }, if compositions.is_some() => match next {
 				Ok(Some(timed)) => read.send_modify(|read| read.push(Some(timed.value), timed.at)),
 				Ok(None) => {
-					layouts = None;
+					compositions = None;
 					alone();
 				}
 				Err(err) => {
-					tracing::error!(%err, "refusing the layer layout; playing the program alone");
-					layouts = None;
+					tracing::error!(%err, "refusing the composition; playing the program alone");
+					compositions = None;
 					refused = true;
 					read.send_modify(|read| {
 						read.refused = Some(err.to_string());
@@ -293,48 +356,71 @@ async fn instance(broadcast: moq_net::broadcast::Consumer, read: watch::Sender<R
 	}
 }
 
-/// The collection `layout` drives on a canvas the program's `size` when it
-/// has none: the program, and over it each picture's layer, with the program
-/// and each sound's layer in the audio scene on program.
-fn collection(layout: Option<&Layout>, size: Canvas) -> anyhow::Result<Collection> {
+/// The collection `composition` drives on a canvas the program's `size` when
+/// it has none: the program at `paths`, and over it each picture's layer,
+/// with the program and each child's sound in the audio scene on program.
+/// Refused when it lists the program elsewhere, references a broadcast above
+/// the connection's root, or places a broadcast it does not list.
+fn collection(composition: Option<&Composition>, size: Canvas, paths: &Paths) -> anyhow::Result<Collection> {
 	let mut collection = Collection::new();
-	collection.canvas = match layout {
-		Some(layout) => Canvas {
-			width: layout.canvas.width,
-			height: layout.canvas.height,
+	collection.canvas = match composition {
+		Some(composition) => Canvas {
+			width: composition.canvas.width,
+			height: composition.canvas.height,
 			framerate: size.framerate,
 		},
 		None => size,
 	};
-	collection
-		.sources
-		.insert(PROGRAM.into(), Source::Broadcast { path: String::new() });
+	collection.sources.insert(
+		PROGRAM.into(),
+		Source::Broadcast {
+			path: paths.program.to_string(),
+		},
+	);
 	let mut items = vec![Item::new(PROGRAM, Rect::fill(&collection.canvas))];
 	let mut sounds = BTreeSet::from([PROGRAM.to_string()]);
-	let mut layer = |source: &str| {
-		let name = format!("{LAYER}{source}");
-		collection.sources.insert(
-			name.clone(),
-			Source::Layer {
-				broadcast: PROGRAM.into(),
-				source: source.into(),
-			},
+	let layer = |source: &str| format!("{LAYER}{source}");
+	if let Some(composition) = composition {
+		let program = paths.at.try_resolve(&composition.program.broadcast);
+		anyhow::ensure!(
+			program.as_ref() == Some(&paths.program),
+			"the composition's program is at `{}`, not the watched `{}`",
+			composition.program.broadcast.as_str(),
+			paths.program
 		);
-		name
-	};
-	let mut audio = Vec::new();
-	for picture in layout.iter().flat_map(|layout| &layout.pictures) {
-		items.push(Item {
-			source: layer(&picture.item.source),
-			..picture.item.clone()
-		});
-	}
-	for sound in layout.iter().flat_map(|layout| &layout.sounds) {
-		let name = layer(&sound.source);
-		audio.push((name.clone(), sound.audio.clone()));
-		sounds.insert(name);
+		for (name, child) in &composition.sources {
+			let path = paths.at.try_resolve(&child.broadcast).with_context(|| {
+				format!(
+					"`{name}` is at `{}`, above the connection's root",
+					child.broadcast.as_str()
+				)
+			})?;
+			collection.sources.insert(
+				layer(name),
+				Source::Layer {
+					clock: PROGRAM.into(),
+					path: path.to_string(),
+					instance: child.instance.clone(),
+					offset: child.offset,
+				},
+			);
+			if let Some(audio) = &child.sound {
+				collection.audio.insert(layer(name), audio.clone());
+				sounds.insert(layer(name));
+			}
+		}
+		for picture in &composition.pictures {
+			anyhow::ensure!(
+				composition.sources.contains_key(&picture.source),
+				"a picture shows `{}`, which the composition does not list",
+				picture.source
+			);
+			items.push(Item {
+				source: layer(&picture.source),
+				..picture.clone()
+			});
+		}
 	}
-	collection.audio.extend(audio);
 	collection.scenes = vec![Scene {
 		items,
 		..Scene::new(SCENE)
@@ -344,20 +430,24 @@ fn collection(layout: Option<&Layout>, size: Canvas) -> anyhow::Result<Collectio
 		sounds,
 		..AudioScene::new(AudioScene::DEFAULT)
 	}];
-	collection.validate().context("cannot play the layer layout")?;
+	collection.validate().context("cannot play the composition")?;
 	Ok(collection)
 }
 
-/// The player: the collection the layout drives, and what plays it.
+/// The player: the collection the composition drives, and what plays it.
 struct Watch {
 	/// What the window says it waits for.
 	url: String,
 	read: watch::Sender<Read>,
+	paths: Paths,
 	collection: Collection,
 	/// Whether the sources run what `collection` holds.
 	synced: bool,
-	/// The layout in effect, or `None` for the program alone.
-	layout: Option<Layout>,
+	/// The composition in effect, or `None` for the program alone.
+	composition: Option<Composition>,
+	/// Whether `collection` holds the composition, which waits for the
+	/// program stream it names.
+	applied: bool,
 	/// The program's size, from its catalog.
 	size: Option<(u32, u32)>,
 	sources: Sources,
@@ -370,19 +460,29 @@ struct Watch {
 impl Watch {
 	/// Apply what was read and is now due at `now`, and draw the program.
 	fn render(&mut self, now: Instant) -> anyhow::Result<()> {
-		let schedule = self.sources.get(PROGRAM).and_then(|feed| feed.clock()).cloned();
+		let program = self.sources.get(PROGRAM);
+		let schedule = program.and_then(|feed| feed.clock()).cloned();
+		let playing = program.and_then(|feed| feed.instance());
 		let mut changed = !self.synced;
 		self.read.send_if_modified(|read| {
 			if read.size != self.size {
 				self.size = read.size;
 				changed = true;
 			}
-			if let Some(layout) = read.take_due(schedule.as_ref(), now) {
-				self.layout = layout;
+			if let Some(composition) = read.take_due(schedule.as_ref(), now) {
+				self.composition = composition;
 				changed = true;
 			}
 			false
 		});
+		// Its offsets are for the program stream it names; one a relay minted
+		// can neither match nor contradict it.
+		let applies = self.composition.as_ref().is_some_and(|composition| {
+			let named = composition.program.instance.as_ref();
+			let playing = playing.as_ref().filter(|playing| !playing.is_minted());
+			named.zip(playing).is_none_or(|(named, playing)| named == playing)
+		});
+		changed |= applies != self.applied;
 
 		if changed {
 			let size = match self.size {
@@ -393,15 +493,17 @@ impl Watch {
 				},
 				None => CANVAS,
 			};
-			let collection = match collection(self.layout.as_ref(), size) {
+			let composition = self.composition.as_ref().filter(|_| applies);
+			let collection = match collection(composition, size, &self.paths) {
 				Ok(collection) => collection,
 				Err(err) => {
 					tracing::error!(error = format!("{err:#}"), "playing the program alone");
 					self.read.send_modify(|read| read.refused = Some(format!("{err:#}")));
-					self.layout = None;
-					collection(None, size)?
+					self.composition = None;
+					collection(None, size, &self.paths)?
 				}
 			};
+			self.applied = applies && self.composition.is_some();
 			if collection.canvas != self.collection.canvas {
 				self.compositor.fit(&collection)?;
 			}
@@ -417,10 +519,10 @@ impl Watch {
 
 		// The keyframes play from `start` as far as the program has played,
 		// following the clock as it re-anchors or stalls with the sound.
-		if let (Some(layout), Some(schedule)) = (&self.layout, &schedule) {
+		if let (Some(composition), Some(schedule)) = (self.composition.as_ref().filter(|_| self.applied), &schedule) {
 			let went_on = match schedule.playhead(now) {
-				Some(head) => now.checked_sub(head.saturating_sub(layout.start)),
-				None => moq_net::Timestamp::try_from(layout.start)
+				Some(head) => now.checked_sub(head.saturating_sub(composition.start)),
+				None => moq_net::Timestamp::try_from(composition.start)
 					.ok()
 					.and_then(|start| schedule.due(start)),
 			};
@@ -490,13 +592,27 @@ impl eframe::App for Window {
 
 #[cfg(test)]
 mod tests {
-	use moq_scene::layout::{Picture, Sound, Version};
+	use std::collections::BTreeMap;
+
+	use moq_scene::composition::{Child, Program, Version};
 	use moq_scene::{Audio, Filter, Keyframe, Size};
 
 	use super::*;
 
-	/// A camera named as the program is, placed twice, and a microphone.
-	fn layout(start: Duration) -> Layout {
+	fn relative(path: &str) -> moq_net::path::Relative {
+		moq_net::path::Relative::new(path).unwrap()
+	}
+
+	fn paths() -> Paths {
+		Paths {
+			program: moq_net::Path::new("show").unwrap(),
+			at: moq_net::Path::new("show/composition").unwrap(),
+		}
+	}
+
+	/// A camera named as the program is, placed twice, and a guest heard,
+	/// each a broadcast of its own.
+	fn composition(start: Duration) -> Composition {
 		let mut cam = Item::new(
 			"program",
 			Rect {
@@ -511,29 +627,28 @@ mod tests {
 			x: 100.0,
 			..Keyframe::new(Duration::from_secs(1))
 		}];
-		let picture = Picture {
-			item: cam,
-			priority: 0,
-			toggle: false,
-		};
-		Layout {
+		let mut guest = Child::new(relative("../guests/alice"), Some("abc".parse().unwrap()), -1_500);
+		guest.sound = Some(Audio {
+			gain: 0.5,
+			delay: Duration::from_millis(80),
+			..Default::default()
+		});
+		Composition {
 			version: Version,
 			canvas: Size {
 				width: 640,
 				height: 360,
 			},
 			start,
-			pictures: vec![picture.clone(), picture],
-			sounds: vec![Sound {
-				source: "mic".into(),
-				audio: Audio {
-					gain: 0.5,
-					delay: Duration::from_millis(80),
-					..Default::default()
-				},
-				priority: 0,
-				toggle: false,
-			}],
+			program: Program {
+				broadcast: relative("."),
+				instance: None,
+			},
+			sources: BTreeMap::from([
+				("program".into(), Child::new(relative("source/program"), None, 0)),
+				("alice".into(), guest),
+			]),
+			pictures: vec![cam.clone(), cam],
 		}
 	}
 
@@ -541,39 +656,80 @@ mod tests {
 		moq_net::Timestamp::try_from(Duration::from_secs(secs)).unwrap()
 	}
 
-	/// The layout's pictures draw over the program from layers named apart
-	/// from it, even one named as it is, a source placed twice shares one
-	/// layer, and the audio scene on program plays the program and each
+	/// The composition's pictures draw over the program from layers named
+	/// apart from it, even one named as it is, each playing its own broadcast
+	/// on the program's clock at its offset, a broadcast placed twice shares
+	/// one layer, and the audio scene on program plays the program and each
 	/// sound at its gain and delay.
 	#[test]
-	fn a_layout_drives_the_collection() {
-		let layout = layout(Duration::ZERO);
-		let driven = collection(Some(&layout), CANVAS).unwrap();
+	fn a_composition_drives_the_collection() {
+		let composition = composition(Duration::ZERO);
+		let driven = collection(Some(&composition), CANVAS, &paths()).unwrap();
 		assert_eq!((driven.canvas.width, driven.canvas.height), (640, 360));
 		let items = &driven.scene(SCENE).unwrap().items;
 		let sources: Vec<&str> = items.iter().map(|item| item.source.as_str()).collect();
 		assert_eq!(sources, [PROGRAM, "layer/program", "layer/program"]);
-		assert_eq!(items[1].keyframes, layout.pictures[0].item.keyframes);
+		assert_eq!(items[1].keyframes, composition.pictures[0].keyframes);
+		assert_eq!(
+			driven.sources[PROGRAM],
+			Source::Broadcast { path: "show".into() }
+		);
 		assert_eq!(
 			driven.sources["layer/program"],
 			Source::Layer {
-				broadcast: PROGRAM.into(),
-				source: "program".into()
+				clock: PROGRAM.into(),
+				path: "show/source/program".into(),
+				instance: None,
+				offset: 0,
+			}
+		);
+		assert_eq!(
+			driven.sources["layer/alice"],
+			Source::Layer {
+				clock: PROGRAM.into(),
+				path: "guests/alice".into(),
+				instance: Some("abc".parse().unwrap()),
+				offset: -1_500,
 			}
 		);
 		let heard = driven.heard(AudioScene::DEFAULT);
-		assert_eq!(heard, BTreeSet::from([PROGRAM, "layer/mic"]));
-		assert_eq!(driven.audio["layer/mic"], layout.sounds[0].audio);
+		assert_eq!(heard, BTreeSet::from([PROGRAM, "layer/alice"]));
+		assert_eq!(Some(&driven.audio["layer/alice"]), composition.sources["alice"].sound.as_ref());
 
-		let alone = collection(None, CANVAS).unwrap();
+		let alone = collection(None, CANVAS, &paths()).unwrap();
 		assert_eq!(alone.sources.len(), 1, "the program alone");
 		assert_eq!(alone.canvas, CANVAS);
 	}
 
-	/// Of the layouts the program must have reached by the time a new one
-	/// arrives, only the newest waits.
+	/// A composition listing the program elsewhere, a broadcast above the
+	/// connection's root, or a picture of a broadcast it does not list, is
+	/// refused, saying why.
+	#[test]
+	fn refuses_what_it_cannot_place() {
+		let refused = |edit: &dyn Fn(&mut Composition), why: &str| {
+			let mut composition = composition(Duration::ZERO);
+			edit(&mut composition);
+			let err = format!("{:#}", collection(Some(&composition), CANVAS, &paths()).unwrap_err());
+			assert!(err.contains(why), "{err}");
+		};
+		refused(
+			&|composition| composition.program.broadcast = relative("other"),
+			"not the watched `show`",
+		);
+		refused(
+			&|composition| composition.sources.get_mut("alice").unwrap().broadcast = relative("../../../x"),
+			"above the connection's root",
+		);
+		refused(
+			&|composition| composition.pictures[0].source = "bob".into(),
+			"which the composition does not list",
+		);
+	}
+
+	/// Of the compositions the program must have reached by the time a new
+	/// one arrives, only the newest waits.
 	#[test]
-	fn only_the_newest_passed_layout_waits() {
+	fn only_the_newest_passed_composition_waits() {
 		let mut read = Read::default();
 		for secs in [1, 2, 3, 4] {
 			read.push(None, Some(stamp(secs)));
@@ -583,8 +739,8 @@ mod tests {
 		assert_eq!(stamps, [Some(stamp(3)), Some(stamp(4)), Some(stamp(5))]);
 	}
 
-	/// Another instance of the broadcast starts from nothing: the last one's
-	/// stamps and refusal are not its own.
+	/// Another instance of the composition starts from nothing: the last
+	/// one's stamps and refusal are not its own.
 	#[test]
 	fn a_new_instance_forgets_the_last() {
 		let mut read = Read::default();
@@ -593,13 +749,14 @@ mod tests {
 		read.reset();
 		assert_eq!(read.pending.len(), 1);
 		assert!(read.pending[0].0.is_none() && read.pending[0].1.is_none());
-		assert!(read.size.is_none() && read.refused.is_none());
+		assert!(read.refused.is_none());
 	}
 
-	/// Once the layout track is unlisted, the program plays alone at once,
-	/// even while a stalled program holds back a layout still waiting.
+	/// Once the composition track is unlisted, the program plays alone at
+	/// once, even while a stalled program holds back a composition still
+	/// waiting.
 	#[tokio::test(start_paused = true)]
-	async fn unlisting_supersedes_a_waiting_layout() {
+	async fn unlisting_supersedes_a_waiting_composition() {
 		let clock = timeline::Producer::new(Duration::from_millis(100));
 		let audio = timeline::Audio {
 			end: Duration::from_secs(1),
@@ -609,9 +766,8 @@ mod tests {
 		clock.audio(audio, Instant::now());
 		let schedule = clock.consume();
 
-		let (broadcast, catalog, read, reader) = broadcast();
-		let mut publisher = layout::Publisher::new(broadcast.clone(), catalog.clone());
-		publisher.update(layout(Duration::ZERO), stamp(5)).unwrap();
+		let (mut publisher, read, reader) = broadcast();
+		publisher.update(composition(Duration::ZERO), stamp(5)).unwrap();
 		pending(&read, 1).await;
 		tokio::time::advance(Duration::from_secs(60)).await;
 		let later = Instant::now();
@@ -632,34 +788,33 @@ mod tests {
 		reader.abort();
 	}
 
-	/// A layout of another version, as a newer studio would publish.
+	/// A composition of another version, as a newer studio would publish.
 	#[derive(serde::Serialize)]
 	struct Newer {
 		version: u32,
 	}
 
-	/// A broadcast with a catalog, and the instance reader's view of it.
+	/// A composition broadcast, and the instance reader's view of it.
 	fn broadcast() -> (
-		moq_net::broadcast::Producer,
-		moq_scene::publish::Catalog,
+		composition::Publisher,
 		watch::Sender<Read>,
 		tokio::task::JoinHandle<anyhow::Result<()>>,
 	) {
 		let mut broadcast = moq_net::broadcast::Info::new().produce();
-		let config = moq_mux::catalog::Config::default().with_catalog(Default::default());
-		let catalog = moq_scene::publish::Catalog::new(&mut broadcast, config).unwrap();
+		let publisher = composition::Publisher::new(&mut broadcast, moq_mux::Clock::default()).unwrap();
 		let (read, _) = watch::channel(Read::default());
 		let reader = tokio::spawn(instance(broadcast.consume(), read.clone()));
-		(broadcast, catalog, read, reader)
+		(publisher, read, reader)
 	}
 
-	/// What `read` holds once it has `count` layouts waiting, with their
-	/// stamps as durations, since one read back carries its track's timescale.
-	async fn pending(read: &watch::Sender<Read>, count: usize) -> Vec<(Option<Layout>, Option<Duration>)> {
+	/// What `read` holds once it has `count` compositions waiting, with their
+	/// stamps as durations, since one read back carries its track's
+	/// timescale.
+	async fn pending(read: &watch::Sender<Read>, count: usize) -> Vec<(Option<Composition>, Option<Duration>)> {
 		let mut reads = read.subscribe();
 		let read = reads.wait_for(|read| read.pending.len() >= count).await.unwrap();
 		let pending = read.pending.iter().cloned();
-		pending.map(|(layout, at)| (layout, at.map(Duration::from))).collect()
+		pending.map(|(composition, at)| (composition, at.map(Duration::from))).collect()
 	}
 
 	/// Wait until the newest thing `read` holds is the program alone.
@@ -669,44 +824,42 @@ mod tests {
 		reads.wait_for(alone).await.unwrap();
 	}
 
-	/// The reader hands over each layout at the media time it took effect,
-	/// and the program alone once the catalog stops listing the track, until
-	/// it lists it again.
+	/// The reader hands over each composition at the media time it took
+	/// effect, and the program alone once the composition ends.
 	#[tokio::test]
-	async fn reads_each_layout() {
-		let (broadcast, catalog, read, reader) = broadcast();
-		let mut publisher = layout::Publisher::new(broadcast.clone(), catalog.clone());
-		publisher.update(layout(Duration::ZERO), stamp(1)).unwrap();
-		let first = (Some(layout(Duration::ZERO)), Some(Duration::from_secs(1)));
+	async fn reads_each_composition() {
+		let (mut publisher, read, reader) = broadcast();
+		publisher.update(composition(Duration::ZERO), stamp(1)).unwrap();
+		let first = (Some(composition(Duration::ZERO)), Some(Duration::from_secs(1)));
 		assert_eq!(pending(&read, 1).await, [first]);
+		publisher.update(composition(Duration::from_secs(2)), stamp(2)).unwrap();
+		let second = (Some(composition(Duration::from_secs(2))), Some(Duration::from_secs(2)));
+		assert_eq!(pending(&read, 2).await[1], second);
 		publisher.finish().unwrap();
 		alone(&read).await;
-		assert_eq!(
-			pending(&read, 1).await,
-			[(None, None)],
-			"the program alone once unlisted"
-		);
-		publisher.update(layout(Duration::from_secs(2)), stamp(2)).unwrap();
-		let again = (Some(layout(Duration::from_secs(2))), Some(Duration::from_secs(2)));
-		assert_eq!(pending(&read, 2).await[1], again, "listed again");
+		assert_eq!(pending(&read, 1).await, [(None, None)], "the program alone once ended");
 		reader.abort();
 	}
 
-	/// A layout of another version is refused, saying why, and the program
-	/// plays alone.
+	/// A composition of another version is refused, saying why, and the
+	/// program plays alone.
 	#[tokio::test]
 	async fn refuses_another_version() {
-		let (broadcast, catalog, read, reader) = broadcast();
+		let mut broadcast = moq_net::broadcast::Info::new().produce();
+		let config = moq_mux::catalog::Config::default();
+		let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config).unwrap();
+		let (read, _) = watch::channel(Read::default());
+		let reader = tokio::spawn(instance(broadcast.consume(), read.clone()));
 		let info = moq_net::track::Info::default().with_timescale(moq_mux::Clock::TIMESCALE);
-		let track = broadcast.create_track(layout::TRACK, info).unwrap();
+		let track = broadcast.create_track(composition::TRACK, info).unwrap();
 		let options = moq_mux::json::Options::default().with_deltas(false);
 		let mut newer = catalog
 			.json_snapshot::<Newer>(track, moq_mux::json::Config::default(), options)
 			.unwrap();
-		newer.update(&Newer { version: 2 }, stamp(1)).unwrap();
+		newer.update(&Newer { version: 3 }, stamp(1)).unwrap();
 		assert_eq!(pending(&read, 1).await, [(None, None)]);
 		let refused = read.borrow().refused.clone().unwrap();
-		assert!(refused.contains("layer layout version 2 is not supported"), "{refused}");
+		assert!(refused.contains("composition version 3 is not supported"), "{refused}");
 		reader.abort();
 	}
 }

From 6aef6a2c850b5bee71a20be64a1ad4395dbb5acb Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 10:34:22 -0800
Subject: [PATCH 03/10] wip: docs, quests, watch

---
 README.md                       | 177 ++++++++++++++++++++------------
 quest/m0/README.md              |   2 +-
 quest/m2/compose/README.md      |   3 +-
 quest/m2/compose/controls.md    |  13 +--
 quest/m2/compose/hang-layers.md |   5 +-
 quest/m2/compose/hear.md        |  31 ++++++
 quest/m2/compose/layout.md      |  53 ----------
 quest/m2/compose/server.md      |  10 +-
 rs/moq-scene/src/collection.rs  |   3 +-
 rs/moq-scene/src/composition.rs |  19 +++-
 rs/moq-scene/src/publish.rs     |  16 ++-
 rs/moq-scene/src/source.rs      |  29 ++++--
 rs/moq-studio/src/engine.rs     |  37 +++++--
 rs/moq-studio/src/watch.rs      |  25 +++--
 14 files changed, 250 insertions(+), 173 deletions(-)
 create mode 100644 quest/m2/compose/hear.md
 delete mode 100644 quest/m2/compose/layout.md

diff --git a/README.md b/README.md
index a3b91ff..cec6f06 100644
--- a/README.md
+++ b/README.md
@@ -543,7 +543,9 @@ before it expires, and is then renewed for as long as they stay, until you
 remove them. A guest's broadcasts become sources named after them (`alice`,
 `alice screen`) when they first appear, in no scene or audio scene: place
 them from the Items panel and send them to the audio scene on program in Audio
-to put them on air. That includes a
+to put them on air, or tick **Published independently** to have viewers fetch
+them from the guest instead of through the program (see
+[Published independently](#published-independently)). That includes a
 guest invited before a restart whose link still works. A guest's source is
 saved to the scene file but is not your edit: it stays out of History, so undo
 never removes it and a guest joining never loses what you could redo. A guest
@@ -866,7 +868,7 @@ stream.
 
 Each camera, display, window, image, media file, color, microphone, and system
 audio also has a track of its own, so the studio can replay or record it on its
-own. These tracks stay in the studio unless a source is [published independently](#published-independently): otherwise the program is all it publishes to a relay. They are listed in a local
+own. These tracks stay in the studio unless a source is [published independently](#published-independently): otherwise the program and its composition are all it publishes to a relay. They are listed in a local
 catalog under the `live.kixel.studio` section's `sources`, by source name, each
 as a hang catalog of its own on the program's clock.
 
@@ -921,25 +923,33 @@ where it can and software otherwise.
 
 ### Published independently
 
-A source with a track of its own can be **Published independently**, a
-checkbox in the Sources panel, off by default and kept in the scene file's
-`published` list. Its track then goes to the relay beside the program, in the
-same broadcast: the program's catalog lists it under the `live.kixel.studio`
-section's `sources`, by source name, as a hang catalog of its own whose track
-names start with `source/`. Viewers fetch it and place it over the program
-themselves, as the [layer layout](#layer-layout) says.
+A broadcast source, such as a guest's camera, or a source with a track of its
+own can be **Published independently**, a checkbox in the Sources panel, off
+by default and kept in the scene file's `published` list. Viewers then fetch
+it as a broadcast of its own and place it over the program themselves, as the
+[composition](#composition) says:
+
+- A local source's track goes to the relay as a broadcast of its own at
+  `<--broadcast>/source/<name>`, with a hang catalog on the program's clock,
+  so its name is one segment of that path: no `/`, not `.` or `..`, and a `\`
+  only before another `\`.
+- A broadcast source is already its publisher's, so viewers read it where the
+  studio does, which their relay must let them: a guest's, under the room.
+  The studio publishes nothing more of it.
 
 The program leaves a published source out, wherever it or a clone of it is
-placed, and so does every audio scene's mix. The studio draws it only as
-viewers will: over the program, in the Program panel and the program's
-virtual camera, and over the scene in preview, so both show what viewers
-see. It goes over every other item of its scene, and over the top layer,
-however the scene stacks it. Recordings hold the program as published,
-without it, and recording **each source too** gives a published camera,
-display, window, or microphone a file of its own. Published and recorded
-scenes, and a scene that shows the program, leave it out too. While viewers read its track, it claims its bitrate of the connection beside the program's, and its video encodes at what the connection grants it. Its track carries one rendition, the
-plain capture before any filter or gain, and encodes for as long as it is
-published, holding an encode session as one on program does.
+placed, and so does every audio scene's mix, guests' return feeds included.
+The studio draws it only as viewers will: over the program, in the Program
+panel and the program's virtual camera, and over the scene in preview, so
+both show what viewers see. It goes over every other item of its scene, and
+over the top layer, however the scene stacks it. Recordings hold the program
+as published, without it, and recording **each source too** gives a published
+source a file of its own. Published and recorded scenes, and a scene that
+shows the program, leave it out too. While viewers read a local source's
+track, it claims its bitrate of the connection beside the program's, and its
+video encodes at what the connection grants it. Its track carries one
+rendition, the plain capture before any filter or gain, and encodes for as
+long as it is published, holding an encode session as one on program does.
 
 Every player must reproduce how it is placed, so an item showing it takes no
 filter but opacity and no blend mode, nor do its source's filters or its
@@ -947,74 +957,105 @@ keyframes, and no scene that another scene draws can place it. A source with
 its background removed cannot be published, since H.264 carries no
 transparency and its track would show the background.
 
-#### Layer layout
+#### Composition
 
-While a source is published independently, the program's broadcast also
-carries a JSON track, `live.kixel.studio.layers`, listed in its catalog's `json`
-section. It is a snapshot: each change is a new group, stamped on the media
-clock with the frame it takes effect on, so a viewer who joins late reads the
-layout in force. The format is the studio's own until hang specifies a layer
-layout:
+Beside the program, the studio publishes a composition at
+`<--broadcast>/composition`, a broadcast of its own whose catalog's `json`
+section lists one JSON track, `live.kixel.studio.composition`, and whose
+`media.clock` is the program's. The track is a snapshot: each change is a new
+group, stamped on the program's media clock with the frame it takes effect on,
+so a viewer who joins late reads the composition in force. A player that
+knows no compositions plays the program at `<--broadcast>` as before. The
+format is the studio's own until hang specifies a composition:
 
 ```json
 {
-  "version": 1,
+  "version": 2,
   "canvas": { "width": 1920, "height": 1080 },
   "start": 10000000,
+  "program": { "broadcast": ".", "instance": "5c1f0e3a9b7d4e21a8f6c0d3b2e19f47" },
+  "sources": {
+    "camera": { "broadcast": "source/camera" },
+    "mic": { "broadcast": "source/mic", "sound": { "gain": 1.0, "delay": "80ms" } },
+    "alice": {
+      "broadcast": "../guests/alice/camera.hang",
+      "instance": "9e4b7c21d0a3f6e85b1c2d4f7a9e0b36",
+      "offset": -1731412345678901,
+      "sound": { "gain": 0.8, "pan": -0.5 }
+    }
+  },
   "pictures": [
     {
-      "item": {
-        "source": "camera",
-        "rect": { "x": 1440.0, "y": 760.0, "width": 400.0, "height": 225.0 },
-        "visible": true,
-        "filters": [{ "kind": "opacity", "amount": 0.9 }],
-        "keyframes": [{ "at": "1s", "x": 600.0 }]
-      }
-    }
-  ],
-  "sounds": [{ "source": "mic", "audio": { "gain": 1.0, "muted": false, "delay": "80ms" } }]
+      "source": "camera",
+      "rect": { "x": 1440.0, "y": 760.0, "width": 400.0, "height": 225.0 },
+      "filters": [{ "kind": "opacity", "amount": 0.9 }],
+      "keyframes": [{ "at": "1s", "x": 600.0 }]
+    },
+    { "source": "alice", "rect": { "x": 40.0, "y": 760.0, "width": 400.0, "height": 225.0 } }
+  ]
 }
 ```
 
-- `version` is 1. A player refuses any other loudly and plays the program
-  alone.
+- `version` is 2. A player refuses any other loudly and plays the program
+  alone. Version 1 was the layer layout, a track of the program's broadcast
+  naming its tracks.
 - `canvas` is the program's size, which pictures are placed on in pixels.
 - `start` is when the scene on program went on, in microseconds on the media
   clock: the moment its pictures' keyframes play from.
+- `program` names the program's broadcast, and `sources` each source
+  published independently that a picture shows or the program's audio plays,
+  by source name. Each `broadcast` is relative to the composition's path, as
+  hang's references are, so `.` is the program and `..` walks up a segment.
+  An `instance` names the stream it describes, left out when the relay minted
+  the one the studio reads.
+- A source's `offset`, in microseconds (0 if absent), is added to its
+  broadcast's timestamps to put them on the program's clock. A local source
+  is stamped on that clock, at 0. A guest keeps a timeline of its own, so its
+  offset is where the studio played it: a new composition follows it once it
+  moves more than 10 ms, and a guest who joins again, as a new instance, gets
+  a new one. A guest the studio cannot play yet, such as one offline, is left
+  out with its pictures.
+- A source's `sound`, when the audio scene on program holds it, is the
+  `gain`, `muted`, `pan`, and `delay` it plays at.
+- Each source may carry a subscription `priority` (0 if absent) and whether a
+  viewer may `toggle` it off (`false` if absent).
 - `pictures` lists each item of the scene on program, then of the top layer,
   showing a published source, back to front over the program, shown or
-  hidden. Each `item` is a scene file item: its `source` names the source's
-  entry under the catalog's `live.kixel.studio` `sources` (the source a clone
-  shows), and its `crop` and `filters` fold in its source's own.
-- `sounds` lists each published source the audio scene on program holds,
-  with the `gain`, `muted`, `pan`, and `delay` it plays at.
-- Each picture and sound may carry a subscription `priority` (0 if absent)
-  and whether a viewer may `toggle` it off (`false` if absent).
-
-A take changes the layout on the frame the program starts showing the new
-scene, so the published sources of the scene leaving go off and those of the
-scene coming in go on at once, even through a transition.
+  hidden. Each is a scene file item: its `source` names a key of `sources`
+  (the source a clone shows), and its `crop` and `filters` fold in its
+  source's own.
+
+A take changes the composition on the frame the program starts showing the
+new scene, so the published sources of the scene leaving go off and those of
+the scene coming in go on at once, even through a transition. A published
+scene named `composition` would publish where the composition is, so it does
+not publish.
 
 #### Watching
 
-`moq-studio --watch https://relay.example/anon/my-show` plays a studio
-broadcast in a window as a viewer sees it: the program, with each picture of
-its layer layout over it and each sound mixed with it. The URL's path names
-the broadcast, as `moq play`'s does, and `--connect-token` and the `--quic-*`
-flags apply to it; `--connect`, `--failover`, and `--room` are refused
-beside it. It is a prototype for settling the layout's format, which goes
-once `moq play` plays layers.
-
-- Each layout takes effect when the program plays the frame it is stamped
-  with, and its pictures' keyframes play from its `start`.
-- Each source plays its own track on the program's clock: a picture shows
-  when the program's picture stamped alike does, and a sound plays with the
-  program's sound stamped alike, at its `gain`, `muted`, `pan`, and `delay`.
-  A frame too late for its moment is dropped.
-- A broadcast without a layout, or with a layout of another `version`, plays
-  its program alone; the window says why for the latter.
-- Guests' broadcasts are not in the layout yet, so only sources local to the
-  studio play as layers. `priority` and `toggle` are not applied.
+`moq-studio --watch https://relay.example/anon --broadcast my-show` plays a
+studio's composition in a window as a viewer sees it: the program at
+`my-show`, with each picture over it and each sound mixed with it. The URL
+names the relay as `--connect` does, and must reach every broadcast the
+composition lists, guests' included; `--connect-token` and the `--quic-*`
+flags apply to it, and `--connect`, `--failover`, and `--room` are refused
+beside it. It is a prototype for settling the composition's format, which
+goes once `moq play` plays compositions.
+
+- Each composition takes effect when the program plays the frame it is
+  stamped with, and its pictures' keyframes play from its `start`.
+- Each source plays its own broadcast on the program's clock, its timestamps
+  moved by its `offset`: a picture shows when the program's picture stamped
+  alike does, and a sound plays with the program's sound stamped alike, at
+  its `gain`, `muted`, `pan`, and `delay`. A frame too late for its moment is
+  dropped. A new offset plays on without fetching the broadcast again.
+- A source whose `instance` another stream replaced shows nothing until a
+  composition names the new one, and a composition naming another program
+  stream waits for it, so neither plays on a timeline its offset is not for.
+- A broadcast without a composition, or with one of another `version` or one
+  it cannot place, such as one listing a broadcast above the relay URL's
+  path, plays its program alone; the window says why for the latter.
+- `priority` and `toggle` are not applied.
 - Sound needs a build with `capture`; without it the window says so in the
   log and plays the pictures alone.
 
diff --git a/quest/m0/README.md b/quest/m0/README.md
index 6cab862..442abe8 100644
--- a/quest/m0/README.md
+++ b/quest/m0/README.md
@@ -88,7 +88,7 @@ each encoding costs an encoder session and consumer GPUs have few, so the
 [viewer-side composition](/quest/m2/compose/README.md) epic left m0 (now m2,
 replanned 2026-11-08 around independently published sources layered over the
 program). Overlays and animation render into the program here; that epic's
-layout track carries only the layers of independently published sources.
+composition lists only the independently published sources over it.
 
 Changed 2026-11-09 with the maintainer (/quest-plan): the studio gets one
 designed layout, a live picture with pages around it, in place of sixteen
diff --git a/quest/m2/compose/README.md b/quest/m2/compose/README.md
index 8642429..fe35dca 100644
--- a/quest/m2/compose/README.md
+++ b/quest/m2/compose/README.md
@@ -57,7 +57,8 @@ offset onto the composition's clock, and every independently published
 source, local or guest, its own broadcast (rejected: a layer layout track in
 the program's broadcast naming tracks; local sources as tracks of the
 program's broadcast, the 2026-10-26 rule this reverses). The studio
-prototypes the format first. See [the composition](/quest/m2/compose/layout.md).
+prototypes the format first: `rs/moq-scene/src/composition.rs`, documented in
+the README's "Composition".
 
 moq's side, in its own quest tree (m3): hang specifies the composition, and
 `moq play` and `@moq/watch` composite it. moq's three layers quests were
diff --git a/quest/m2/compose/controls.md b/quest/m2/compose/controls.md
index c3b2390..c355b6f 100644
--- a/quest/m2/compose/controls.md
+++ b/quest/m2/compose/controls.md
@@ -2,10 +2,10 @@
 
 ## Goal
 
-A viewer watching a studio broadcast can switch off any layer the layout
-marks toggleable (a facecam, a screen share), and stops fetching its track.
-The layout's per-layer priorities steer delivery, so under congestion the
-least important sources degrade first. The creator sets both per source in
+A viewer watching a studio broadcast can switch off any source the
+composition marks toggleable (a facecam, a screen share), and stops fetching
+its broadcast. The composition's per-source priorities steer delivery, so
+under congestion the least important sources degrade first. The creator sets both per source in
 the studio.
 
 ## Plan
@@ -26,5 +26,6 @@ Map layer priority onto the subscription priorities moq-lite already has
 (`moq/doc/concept/moq-lite.md`), rather than a second mechanism. A toggled-off
 layer is unsubscribed, so it costs the viewer and the relay nothing. The
 studio keeps encoding it, so toggling it back on can reach its recent past.
-Subscriptions are per track, not per layer: a source shown by several layers
-stays subscribed while any of them is on, at the highest priority among them.
+The composition carries `priority` and `toggle` on each source's entry
+(`rs/moq-scene/src/composition.rs`), not on each picture, so a source shown by
+several pictures is one subscription, on or off as a whole.
diff --git a/quest/m2/compose/hang-layers.md b/quest/m2/compose/hang-layers.md
index f3b2b43..c64d13b 100644
--- a/quest/m2/compose/hang-layers.md
+++ b/quest/m2/compose/hang-layers.md
@@ -19,8 +19,8 @@ quests (rejected: "both quests", unnamed, which left out `@moq/watch`).
 
 Decided 2026-11-12 (maintainer, /quest-unblock): hang specifies a
 composition, a broadcast listing a catalog per source, rather than a layer
-layout track; see [the composition](/quest/m2/compose/layout.md), whose
-prototype moq's spec starts from. moq's three quests below were planned for a
+layout track. The studio's prototype, which moq's spec starts from, is
+`rs/moq-scene/src/composition.rs`, documented in the README's "Composition". moq's three quests below were planned for a
 layer layout track and are replanned in moq's tree.
 
 ## Waiting
@@ -39,6 +39,5 @@ layer layout track and are replanned in moq's tree.
 
 ## Required
 
-- [The studio publishes a composition](/quest/m2/compose/layout.md) - the prototype hang's spec starts from
 - [Viewer controls](/quest/m2/compose/controls.md) - toggles and priorities the spec carries
 - [The studio is caught up to moq's main](/quest/m0/pin-main.md) - moq's breaking changes since moq-dev/moq#8272, so this pin takes only its own
diff --git a/quest/m2/compose/hear.md b/quest/m2/compose/hear.md
new file mode 100644
index 0000000..8d6ed13
--- /dev/null
+++ b/quest/m2/compose/hear.md
@@ -0,0 +1,31 @@
+# [M] The studio and its guests hear what is published independently
+
+## Goal
+
+A source published independently, such as a guest's camera and microphone,
+is heard where the studio's own people listen: in the audio scene **Listen**
+plays, and in every other guest's return feed, at the gain, mute, pan, and
+delay the composition gives viewers. The program's encoded audio, published
+scenes, and recordings still leave it out, since viewers mix it in from its
+own broadcast.
+
+## Plan
+
+Found while building [the composition](/quest/m2/compose/README.md): every
+audio scene's mix leaves a published source out, so a creator who publishes
+a guest independently no longer hears them on **Listen**, and the other
+guests lose them from their return feeds. That was already true of a local
+microphone published independently, where it mattered less.
+
+Recommended: route a published source into the mixes the studio plays to
+people (Listen and each return feed's mix-minus) while keeping it out of the
+mixes it encodes for viewers and recordings, rather than one mix per audio
+scene; the studio's preview then sounds as its pictures look.
+
+## Waiting
+
+- Maintainer: whether **Listen** and guests' return feeds hear published
+  sources (recommended), or only return feeds, or neither, as today. An
+  agent cannot take it: it reverses the Published independently rule that
+  every audio scene's mix leaves a published source out. Check: the answer
+  is recorded in this Plan.
diff --git a/quest/m2/compose/layout.md b/quest/m2/compose/layout.md
deleted file mode 100644
index 830d3bd..0000000
--- a/quest/m2/compose/layout.md
+++ /dev/null
@@ -1,53 +0,0 @@
-# [L] The studio publishes a composition
-
-## Goal
-
-The studio publishes a composition: a broadcast of its own whose catalog
-lists other broadcasts, the program and each independently published source,
-local or guest, with where and when each shows and how its sound mixes. Each
-listed broadcast keeps its own timeline, and the composition carries the
-offset that puts it on the composition's media clock. The `moq-studio --watch`
-prototype (`rs/moq-studio/src/watch.rs`) plays a composition, guests
-included, and it replaces the provisional `live.kixel.studio.layers` track
-(`rs/moq-scene/src/layout.rs`, and the README's "Layer layout").
-
-## Plan
-
-Decided 2026-11-12 (maintainer, /quest-unblock), settling how the layout
-names a guest:
-
-- **Naming:** ✅ a composition, a catalog of catalogs (rejected: the layer
-  layout naming each guest's broadcast with an offset; moq relaxing hang's
-  `include` for broadcasts on their own timeline; republishing guests'
-  tracks in the studio's broadcast). hang's `include`
-  ([moq-dev/moq#7943](https://github.com/moq-dev/moq/pull/7943)) requires an
-  included broadcast to share the listing catalog's PTS timeline,
-  `media.clock`, and `media.join.interval`, which a guest's does not; a
-  composition keeps `include`'s meaning and says how each timeline maps.
-- **Home:** ✅ its own broadcast (rejected: a section of the program's
-  catalog, which is `include` with a different clock). The program is one of
-  its children, and a player that knows no compositions still plays the
-  program.
-- **Local sources:** ✅ every independently published source is its own
-  broadcast (rejected: layers naming a broadcast and track, with local
-  sources staying tracks of the program's broadcast at offset zero). This
-  reverses the 2026-10-26 rule that local sources are tracks in the studio's
-  one broadcast, so the composition lists only catalogs.
-- **Format:** ✅ the studio prototypes it, provisional and versioned, before
-  moq's hang specifies it (rejected: straight to hang's spec), as the
-  2026-11-08 layer layout did.
-
-Recommended, not decided: the composition's media clock is the program's, so
-the program's offset is zero; each child's entry carries what the provisional
-layer format carries per layer today (placement, crop, opacity, visibility,
-keyframes, toggleability, priority, and gain, mute, pan, and delay for
-sound); and a change is a new snapshot group stamped on the composition's
-clock, as the layers track is now.
-
-`Source::publishes` refuses a broadcast source today, since it has no track
-in the studio's broadcast; under a composition a guest needs no track of the
-studio's. `README.md`'s "Published independently" and "Layer layout" become
-the composition's.
-
-Bump the format's `version`, since naming broadcasts instead of tracks is not
-additive.
diff --git a/quest/m2/compose/server.md b/quest/m2/compose/server.md
index 5dffb04..4117f5c 100644
--- a/quest/m2/compose/server.md
+++ b/quest/m2/compose/server.md
@@ -27,14 +27,10 @@ too and moq never depends on this repository. Settle its name in this quest
 and document it in `README.md`.
 
 It flattens the composition the studio publishes
-([the composition](/quest/m2/compose/layout.md)); until that lands, it
-flattens the provisional `live.kixel.studio.layers` track (`rs/moq-scene/src/layout.rs`,
-and the README's "Layer layout").
+(`rs/moq-scene/src/composition.rs`, and the README's "Composition"), placing
+each listed broadcast on the program's clock at its offset as the
+`moq-studio --watch` prototype (`rs/moq-studio/src/watch.rs`) does.
 
 ## Required
 
 - [Destinations](/quest/m0/destinations.md) - the egress library the server pushes RTMP and WHIP through
-
-## Related
-
-- [The studio publishes a composition](/quest/m2/compose/layout.md) - the format it flattens
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index 0775098..572d301 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -1874,7 +1874,8 @@ pub enum Source {
 		clock: String,
 		/// Its broadcast's path.
 		path: String,
-		/// The stream it must be, or `None` for whichever serves the path.
+		/// The stream `offset` is for, or `None` for whichever serves the
+		/// path: another stream shows nothing, unless a relay minted it.
 		instance: Option<moq_net::Instance>,
 		/// Microseconds added to its timestamps to put them on `clock`'s
 		/// timeline. A change plays on without opening the broadcast again.
diff --git a/rs/moq-scene/src/composition.rs b/rs/moq-scene/src/composition.rs
index 1f8acf8..7559780 100644
--- a/rs/moq-scene/src/composition.rs
+++ b/rs/moq-scene/src/composition.rs
@@ -308,7 +308,9 @@ impl Publisher {
 fn steady(composition: &mut Composition, published: &Composition) {
 	let drift = DRIFT.as_micros() as i64;
 	for (name, child) in &mut composition.sources {
-		let Some(before) = published.sources.get(name) else { continue };
+		let Some(before) = published.sources.get(name) else {
+			continue;
+		};
 		if before.broadcast == child.broadcast
 			&& before.instance == child.instance
 			&& before.offset.abs_diff(child.offset) <= drift.unsigned_abs()
@@ -406,7 +408,11 @@ mod tests {
 			("mic".into(), Child::new(relative("source/mic"), None, 0)),
 			(
 				"alice".into(),
-				Child::new(relative("../guests/alice/camera.hang"), Some("abc".parse().unwrap()), -1_500),
+				Child::new(
+					relative("../guests/alice/camera.hang"),
+					Some("abc".parse().unwrap()),
+					-1_500,
+				),
 			),
 		])
 	}
@@ -545,7 +551,8 @@ mod tests {
 		let text = toml::to_string(&composition).unwrap();
 		assert!(text.starts_with("version = 2\n"), "{text}");
 		assert!(text.contains("start = 1500\n"), "{text}");
-		let alice = "[sources.alice]\nbroadcast = \"../guests/alice/camera.hang\"\ninstance = \"abc\"\noffset = -1500\n";
+		let alice =
+			"[sources.alice]\nbroadcast = \"../guests/alice/camera.hang\"\ninstance = \"abc\"\noffset = -1500\n";
 		assert!(text.contains(alice), "{text}");
 		assert_eq!(toml::from_str::<Composition>(&text).unwrap(), composition);
 
@@ -568,7 +575,11 @@ mod tests {
 			let mut children = children();
 			children.insert(
 				"alice".into(),
-				Child::new(relative("../guests/alice/camera.hang"), Some(instance.parse().unwrap()), offset),
+				Child::new(
+					relative("../guests/alice/camera.hang"),
+					Some(instance.parse().unwrap()),
+					offset,
+				),
 			);
 			Composition::new(&collection, Some("live"), Duration::ZERO, program(), children)
 		};
diff --git a/rs/moq-scene/src/publish.rs b/rs/moq-scene/src/publish.rs
index a792c49..bd3dfff 100644
--- a/rs/moq-scene/src/publish.rs
+++ b/rs/moq-scene/src/publish.rs
@@ -266,8 +266,15 @@ struct Independent {
 
 impl Independent {
 	/// A broadcast at `<base>/<name>` on `origin`, its catalog on `clock`.
-	fn new(origin: &moq_net::origin::Producer, base: &moq_net::Path, name: &str, clock: moq_mux::Clock) -> Result<Self, Error> {
-		let path = moq_net::Path::new(name).and_then(|name| base.join(&name)).map_err(moq_net::Error::from)?;
+	fn new(
+		origin: &moq_net::origin::Producer,
+		base: &moq_net::Path,
+		name: &str,
+		clock: moq_mux::Clock,
+	) -> Result<Self, Error> {
+		let path = moq_net::Path::new(name)
+			.and_then(|name| base.join(&name))
+			.map_err(moq_net::Error::from)?;
 		let route = origin.route(path, moq_net::origin::RouteOptions::hidden())?;
 		let mut broadcast = route.broadcast().clone();
 		let config = moq_mux::catalog::Config::default().with_clock(clock);
@@ -1251,7 +1258,10 @@ mod tests {
 			assert_eq!(red.into_raw(), [255, 0, 0, 255]);
 
 			published.send(BTreeSet::new()).unwrap();
-			assert!(catalogs.next().await.unwrap().is_none(), "unpublished, its catalog ends");
+			assert!(
+				catalogs.next().await.unwrap().is_none(),
+				"unpublished, its catalog ends"
+			);
 		})
 		.await;
 	}
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index f04dc21..06eaeca 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -398,9 +398,7 @@ impl Sources {
 		let orphaned: Vec<String> = self
 			.feeds
 			.iter()
-			.filter(
-				|(_, feed)| matches!(&feed.source, Source::Layer { clock, .. } if !self.feeds.contains_key(clock)),
-			)
+			.filter(|(_, feed)| matches!(&feed.source, Source::Layer { clock, .. } if !self.feeds.contains_key(clock)))
 			.map(|(name, _)| name.clone())
 			.collect();
 		for name in orphaned {
@@ -1346,7 +1344,10 @@ impl Driver {
 			let now = kio::clock::now();
 			let offset = self.offset.load(Ordering::Relaxed);
 			// A picture moved off the clock's timeline never plays.
-			while queue.front().is_some_and(|frame| shift(frame.timestamp, offset).is_none()) {
+			while queue
+				.front()
+				.is_some_and(|frame| shift(frame.timestamp, offset).is_none())
+			{
 				queue.pop_front();
 			}
 			let on = |frame: &moq_video::Frame| shift(frame.timestamp, offset);
@@ -3185,7 +3186,9 @@ mod tests {
 			let mut live = live(&origin, false).await;
 			// The camera's own broadcast, on a timeline 250 ms behind the
 			// program's.
-			let publication = origin.route("room/cam", moq_net::origin::RouteOptions::hidden()).unwrap();
+			let publication = origin
+				.route("room/cam", moq_net::origin::RouteOptions::hidden())
+				.unwrap();
 			let mut broadcast = publication.broadcast().clone();
 			let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
 			let (mut cam, mut cam_encoder) = rendition(&broadcast, catalog.timebase()).await;
@@ -3244,7 +3247,10 @@ mod tests {
 	fn a_timestamp_shifts() {
 		let stamp = moq_net::Timestamp::from_millis(1_000).unwrap();
 		assert_eq!(shift(stamp, 0), Some(stamp));
-		assert_eq!(shift(stamp, 1_500).map(Duration::from), Some(Duration::from_micros(1_001_500)));
+		assert_eq!(
+			shift(stamp, 1_500).map(Duration::from),
+			Some(Duration::from_micros(1_001_500))
+		);
 		assert_eq!(shift(stamp, -1_000_000).map(Duration::from), Some(Duration::ZERO));
 		assert_eq!(shift(stamp, -1_000_001), None);
 		assert_eq!(shift(stamp, i64::MIN), None);
@@ -3415,8 +3421,15 @@ mod tests {
 			start(&sources, drivers).await;
 			let feed = sources.get("guest").unwrap();
 			let clock = feed.clock.clone().unwrap();
-			assert_eq!(feed.offset(Duration::from_secs(5), kio::clock::now()), None, "unanchored");
-			assert_eq!(sources.get("red").unwrap().offset(Duration::ZERO, kio::clock::now()), None);
+			assert_eq!(
+				feed.offset(Duration::from_secs(5), kio::clock::now()),
+				None,
+				"unanchored"
+			);
+			assert_eq!(
+				sources.get("red").unwrap().offset(Duration::ZERO, kio::clock::now()),
+				None
+			);
 
 			until_time(kio::clock::now()).await;
 			picture(&mut live.video, &mut live.encoder, 1_000);
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index d65f483..77a2006 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -835,7 +835,9 @@ impl Program {
 					// Offline, or not yet playing, it shows nothing here either.
 					let Some(feed) = state.sources.get(name) else { continue };
 					let Some(offset) = feed.offset(at, now) else { continue };
-					let Some(broadcast) = composed.child(name, Some(path)) else { continue };
+					let Some(broadcast) = composed.child(name, Some(path)) else {
+						continue;
+					};
 					moq_scene::composition::Child::new(broadcast, feed.instance(), offset)
 				}
 				Some(_) => match composed.child(name, None) {
@@ -847,7 +849,10 @@ impl Program {
 			children.insert(name.clone(), child);
 		}
 		let program = moq_scene::composition::Program {
-			broadcast: composed.program.relative(&composed.path).expect("the program is above it"),
+			broadcast: composed
+				.program
+				.relative(&composed.path)
+				.expect("the program is above it"),
 			instance: Some(self.publication.instance()),
 		};
 		// To the whole microsecond as the frame's stamp is, rather than
@@ -1948,7 +1953,12 @@ async fn publish(
 
 	let composition = Composed::new(&origin, path, clock.clone())?;
 	let (published, follow) = tokio::sync::watch::channel(BTreeSet::new());
-	let forward = (sources.clone(), origin.clone(), composition.sources.clone(), bandwidth.clone());
+	let forward = (
+		sources.clone(),
+		origin.clone(),
+		composition.sources.clone(),
+		bandwidth.clone(),
+	);
 	tokio::spawn(async move {
 		let (sources, origin, base, bandwidth) = forward;
 		if let Err(err) = sources.forward(follow, origin, base, bandwidth).await {
@@ -3315,10 +3325,8 @@ mod tests {
 		.expect("the catalog lists the composition");
 		assert_eq!(catalog.media.clock, engine.program.clock.wall(), "the program's clock");
 
-		let mut compositions = moq_json::snapshot::Consumer::<Composition>::new(
-			composed.track(TRACK).unwrap(),
-			Default::default(),
-		);
+		let mut compositions =
+			moq_json::snapshot::Consumer::<Composition>::new(composed.track(TRACK).unwrap(), Default::default());
 		let next = async |compositions: &mut moq_json::snapshot::Consumer<Composition>| {
 			kio::clock::timeout(TIMEOUT, compositions.next())
 				.await
@@ -3327,11 +3335,17 @@ mod tests {
 		};
 		let first = next(&mut compositions).await.expect("a composition");
 		assert_eq!(first.value.program.broadcast.as_str(), ".");
-		assert_eq!(first.value.program.instance, Some(engine.program.publication.instance()));
+		assert_eq!(
+			first.value.program.instance,
+			Some(engine.program.publication.instance())
+		);
 		let sources: Vec<&str> = first.value.pictures.iter().map(|item| item.source.as_str()).collect();
 		assert_eq!(sources, ["red"]);
 		let red = &first.value.sources["red"];
-		assert_eq!((red.broadcast.as_str(), red.offset, &red.instance), ("source/red", 0, &None));
+		assert_eq!(
+			(red.broadcast.as_str(), red.offset, &red.instance),
+			("source/red", 0, &None)
+		);
 
 		// Its own broadcast, on the program's clock.
 		let origin = engine.program._origin.consume();
@@ -3365,7 +3379,10 @@ mod tests {
 			state.commit(draft, None).unwrap();
 		}
 		let alone = next(&mut compositions).await.expect("a composition");
-		assert!(alone.value.sources.is_empty() && alone.value.pictures.is_empty(), "the program alone");
+		assert!(
+			alone.value.sources.is_empty() && alone.value.pictures.is_empty(),
+			"the program alone"
+		);
 		kio::clock::timeout(TIMEOUT, async { while own.next().await.unwrap().is_some() {} })
 			.await
 			.expect("the source's broadcast ends");
diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs
index 93219e4..f3a7b1b 100644
--- a/rs/moq-studio/src/watch.rs
+++ b/rs/moq-studio/src/watch.rs
@@ -267,10 +267,17 @@ async fn size(origin: moq_net::origin::Consumer, path: moq_net::Path, read: watc
 }
 
 /// Hand `set` the picture size of each catalog of `broadcast`.
-async fn catalogs(broadcast: moq_net::broadcast::Consumer, set: impl Fn(Option<(u32, u32)>) -> bool) -> anyhow::Result<()> {
+async fn catalogs(
+	broadcast: moq_net::broadcast::Consumer,
+	set: impl Fn(Option<(u32, u32)>) -> bool,
+) -> anyhow::Result<()> {
 	let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, Default::default()).await?;
 	while let Some(catalog) = moq_mux::catalog::Stream::next(&mut catalogs).await? {
-		let size = catalog.video.renditions.values().find_map(|config| config.coded_width.zip(config.coded_height));
+		let size = catalog
+			.video
+			.renditions
+			.values()
+			.find_map(|config| config.coded_width.zip(config.coded_height));
 		set(size);
 	}
 	Ok(())
@@ -670,10 +677,7 @@ mod tests {
 		let sources: Vec<&str> = items.iter().map(|item| item.source.as_str()).collect();
 		assert_eq!(sources, [PROGRAM, "layer/program", "layer/program"]);
 		assert_eq!(items[1].keyframes, composition.pictures[0].keyframes);
-		assert_eq!(
-			driven.sources[PROGRAM],
-			Source::Broadcast { path: "show".into() }
-		);
+		assert_eq!(driven.sources[PROGRAM], Source::Broadcast { path: "show".into() });
 		assert_eq!(
 			driven.sources["layer/program"],
 			Source::Layer {
@@ -694,7 +698,10 @@ mod tests {
 		);
 		let heard = driven.heard(AudioScene::DEFAULT);
 		assert_eq!(heard, BTreeSet::from([PROGRAM, "layer/alice"]));
-		assert_eq!(Some(&driven.audio["layer/alice"]), composition.sources["alice"].sound.as_ref());
+		assert_eq!(
+			Some(&driven.audio["layer/alice"]),
+			composition.sources["alice"].sound.as_ref()
+		);
 
 		let alone = collection(None, CANVAS, &paths()).unwrap();
 		assert_eq!(alone.sources.len(), 1, "the program alone");
@@ -814,7 +821,9 @@ mod tests {
 		let mut reads = read.subscribe();
 		let read = reads.wait_for(|read| read.pending.len() >= count).await.unwrap();
 		let pending = read.pending.iter().cloned();
-		pending.map(|(composition, at)| (composition, at.map(Duration::from))).collect()
+		pending
+			.map(|(composition, at)| (composition, at.map(Duration::from)))
+			.collect()
 	}
 
 	/// Wait until the newest thing `read` holds is the program alone.

From 4f3999f57f68dc2cc7e9a0bacacb860a40e7a5b5 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 10:40:56 -0800
Subject: [PATCH 04/10] test(studio): a viewer plays a guest where the studio
 did

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 justfile                   |   2 +-
 rs/moq-studio/src/watch.rs | 216 +++++++++++++++++++++++++++++++++++++
 2 files changed, 217 insertions(+), 1 deletion(-)

diff --git a/justfile b/justfile
index bf8397a..0158679 100644
--- a/justfile
+++ b/justfile
@@ -58,7 +58,7 @@ render-sw:
     icd=("$mesa"/share/vulkan/icd.d/lvp_icd.*.json)
     export VK_DRIVER_FILES="${icd[0]}"
     cargo nextest run --locked -p moq-scene --lib --run-ignored only -E 'test(/^compositor::tests::/) | test(/^browser::layers::tests::/)'
-    cargo nextest run --locked -p moq-studio --features openh264 --run-ignored only -E '(test(/^engine::tests::/) - test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)) | test(=setup::tests::times_every_canvas)'
+    cargo nextest run --locked -p moq-studio --features openh264 --run-ignored only -E '(test(/^engine::tests::/) - test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)) | test(=setup::tests::times_every_canvas) | test(=watch::tests::plays_a_guest_where_the_studio_did)'
     cargo nextest run --locked -p moq-studio --features cef --run-ignored only -E 'binary(browser)'
     sh/pipewire-session.sh cargo nextest run --locked -p moq-studio --features pipewire --run-ignored only -E 'test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)'
 
diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs
index f3a7b1b..3df6699 100644
--- a/rs/moq-studio/src/watch.rs
+++ b/rs/moq-studio/src/watch.rs
@@ -871,4 +871,220 @@ mod tests {
 		assert!(refused.contains("composition version 3 is not supported"), "{refused}");
 		reader.abort();
 	}
+
+	/// A guest's broadcast, published independently, reaches a viewer through
+	/// a relay as the studio played it: the composition lists it where it is,
+	/// at the offset its timeline sat from the program's when the studio
+	/// showed it, which its catalog's clock and the studio's playout delay
+	/// predict, and a player of that composition shows each of its pictures
+	/// beside the program picture that offset puts it with.
+	#[tokio::test(flavor = "multi_thread")]
+	#[ignore = "needs a Vulkan device and an H.264 encoder; run by just rs render-sw"]
+	async fn plays_a_guest_where_the_studio_did() {
+		use moq_mux::catalog::Stream;
+		const TIMEOUT: Duration = Duration::from_secs(30);
+		const PERIOD: Duration = Duration::from_millis(33);
+
+		let _ = moq_tokio::crypto::install_default();
+		let fixture = moq_relay::test_relay().await.expect("test relay");
+		let ready = fixture.relay.ready();
+		let relay = fixture.relay.cluster().origin.clone();
+		tokio::spawn(fixture.relay.run());
+		ready.wait().await.expect("relay ready");
+
+		// The guest, on a clock of its own started well before the program's.
+		let guest = moq_mux::Clock::new();
+		kio::clock::sleep(Duration::from_millis(1_500)).await;
+		let publication = relay
+			.route("guests/alice", moq_net::origin::RouteOptions::default())
+			.unwrap();
+		let mut broadcast = publication.broadcast().clone();
+		let config = moq_mux::catalog::Config::default().with_clock(guest.clone());
+		let catalog = moq_mux::catalog::Producer::new(&mut broadcast, config).unwrap();
+		// Its encoder stays on the thread that made it.
+		let stamping = guest.clone();
+		std::thread::spawn(move || {
+			let runtime = tokio::runtime::Builder::new_current_thread()
+				.enable_all()
+				.build()
+				.unwrap();
+			runtime.block_on(async move {
+				let mut config = moq_video::encode::Config::new(64, 64, moq_video::FrameRate::new(30, 1).unwrap());
+				config.kind = moq_video::encode::Kind::Software;
+				let rendition = config.probe().await.unwrap();
+				let reserved = catalog.timebase().reserve().with_interval(config.effective_join());
+				let mut video = moq_video::encode::Producer::new(broadcast, reserved, rendition).unwrap();
+				let mut encoder = moq_video::encode::Encoder::new(&config).unwrap();
+				let gray = vec![0x80; 64 * 64 * 4];
+				let mut pace = kio::clock::interval(PERIOD);
+				loop {
+					pace.tick().await;
+					let surface = moq_video::Surface::rgba(&gray, moq_video::Size::new(64, 64)).unwrap();
+					let frame = moq_video::Frame::new(surface, stamping.now());
+					if video.publish(&encoder.encode(&frame).unwrap()).is_err() {
+						return;
+					}
+				}
+			});
+		});
+
+		let mut client = moq_tokio::connect::Config::default();
+		client.tls.fingerprint = vec![fixture.fingerprint.clone()];
+		let client = client.init(Default::default()).expect("client");
+		let dir = tempfile::tempdir().unwrap();
+		let gpu = Gpu::new().await.expect("a GPU");
+		let (autosave, _) = crate::autosave::Autosave::open(dir.path().join("show.toml")).unwrap();
+		let mut studio = Collection::new();
+		studio.canvas = Canvas {
+			width: 640,
+			height: 360,
+			framerate: 30,
+		};
+		studio.sources.insert(
+			"bg".into(),
+			Source::Color {
+				color: moq_scene::Rgba([0, 0, 255, 255]),
+			},
+		);
+		studio.sources.insert(
+			"alice".into(),
+			Source::Broadcast {
+				path: "guests/alice".into(),
+			},
+		);
+		studio.scenes[0].items = vec![
+			Item::new("bg", Rect::fill(&studio.canvas)),
+			Item::new(
+				"alice",
+				Rect {
+					x: 16.0,
+					y: 16.0,
+					width: 160.0,
+					height: 90.0,
+				},
+			),
+		];
+		studio.published.insert("alice".into());
+		studio.validate().unwrap();
+		let launch = engine::Launch {
+			gpu,
+			relays: vec![engine::Relay {
+				client,
+				url: fixture.url.clone(),
+			}],
+			broadcast: "studio".into(),
+			on_demand: false,
+			recordings: dir.path().to_path_buf(),
+			room: None,
+		};
+		let loaded = crate::autosave::Loaded {
+			collection: studio,
+			history: moq_scene::History::new(),
+			dropped: 0,
+		};
+		let engine = engine::Engine::start(launch, autosave, loaded)
+			.await
+			.expect("the studio starts");
+
+		// The composition, as a viewer on the relay reads it.
+		let viewer = relay.consume();
+		let follow = |path: &'static str| {
+			let viewer = viewer.clone();
+			async move {
+				kio::clock::timeout(TIMEOUT, viewer.follow(path, None).unwrap().available())
+					.await
+					.expect("the relay routes it")
+					.unwrap()
+					.expect("an instance")
+			}
+		};
+		let program = follow("studio").await;
+		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&program, Default::default())
+			.await
+			.unwrap();
+		let program_clock = catalogs.next().await.unwrap().expect("a catalog").media.clock.unwrap();
+		let composed = follow("studio/composition").await;
+		let mut compositions = moq_json::snapshot::Consumer::<Composition>::new(
+			composed.track(composition::TRACK).unwrap(),
+			Default::default(),
+		);
+		let composition = kio::clock::timeout(TIMEOUT, async {
+			loop {
+				let read = compositions.next().await.unwrap().expect("a composition");
+				if read.value.sources.contains_key("alice") {
+					return read.value;
+				}
+			}
+		})
+		.await
+		.expect("the composition lists the guest once the studio plays it");
+		let alice = &composition.sources["alice"];
+		assert_eq!(alice.broadcast.as_str(), "../guests/alice");
+		assert!(alice.instance.as_ref().is_none_or(|instance| !instance.is_minted()));
+		assert_eq!(composition.pictures.len(), 1);
+
+		// Where the two clocks put one moment, and so the offset with no delay.
+		let micros = |clock: hang::catalog::Clock| Duration::from(clock.wall).as_micros() as i64;
+		let apart = micros(guest.wall().unwrap()) - micros(program_clock);
+		let delay = alice.offset - apart;
+		let playout = engine
+			.state
+			.lock()
+			.unwrap()
+			.sources
+			.get("alice")
+			.and_then(|feed| feed.delay());
+		let expected = playout.expect("the studio plays the guest").as_micros() as i64;
+		let drift = composition::DRIFT.as_micros() as i64;
+		let tick = PERIOD.as_micros() as i64;
+		tracing::info!(offset = alice.offset, apart, delay, "the guest's offset");
+		assert!(
+			(expected - drift..=expected + tick + drift).contains(&delay),
+			"the studio showed the guest {delay} us after its stamp, not its playout delay"
+		);
+
+		// A player of the composition, on the relay.
+		let gpu = Gpu::new().await.expect("a GPU");
+		let (bus, driver) = moq_audio::bus::Bus::new(Default::default()).unwrap();
+		let (_mixer, mixed) = source::Mixer::new(driver, Instant::now());
+		let mut sources = Sources::new(source::Context {
+			bus,
+			mixed,
+			origin: viewer.clone(),
+			dir: dir.path().to_path_buf(),
+			output: moq_video::render::output(&gpu.device),
+			publish: None,
+			browser: None,
+		});
+		let paths = Paths {
+			program: moq_net::Path::new("studio").unwrap(),
+			at: moq_net::Path::new("studio/composition").unwrap(),
+		};
+		let played = collection(Some(&composition), CANVAS, &paths).unwrap();
+		for driver in sources.sync(&played) {
+			engine::spawn(driver);
+		}
+		assert_eq!(
+			played.sources["layer/alice"],
+			Source::Layer {
+				clock: PROGRAM.into(),
+				path: "guests/alice".into(),
+				instance: alice.instance.clone(),
+				offset: alice.offset,
+			}
+		);
+		kio::clock::timeout(TIMEOUT, async {
+			while sources.get("layer/alice").unwrap().status() != Status::Live {
+				kio::clock::sleep(Duration::from_millis(10)).await;
+			}
+		})
+		.await
+		.expect("the player reads the guest from the relay");
+
+		let stopping = engine.clone();
+		tokio::task::spawn_blocking(move || stopping.stop()).await.unwrap();
+		kio::clock::timeout(TIMEOUT, engine.close())
+			.await
+			.expect("the studio closes");
+	}
 }

From a84f0754dc318491a9637427dd3814e50dc58388 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 10:55:45 -0800
Subject: [PATCH 05/10] fix(scene): a layer moved on its clock keeps its
 picture

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-scene/src/compositor.rs | 58 +++++++++++++++++---
 rs/moq-scene/src/source.rs     | 99 +++++++++++++++++++++-------------
 2 files changed, 114 insertions(+), 43 deletions(-)

diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 3b3dc8c..3aaae92 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -954,11 +954,16 @@ impl Compositor {
 	/// sources the collection no longer has or has since edited. An overlay
 	/// that arrives now starts its CSS timeline at `now`.
 	fn update(&mut self, collection: &Collection, sources: &Sources, now: Instant) {
-		self.layers
-			.retain(|name, layer| collection.sources.get(name) == Some(&layer.source));
+		// A layer only moved on its clock keeps its picture until the next.
+		self.layers.retain(|name, layer| {
+			collection
+				.sources
+				.get(name)
+				.is_some_and(|source| source.plays_alike(&layer.source))
+		});
 
 		for (name, source) in &collection.sources {
-			let Some(feed) = sources.get(name).filter(|feed| feed.source() == source) else {
+			let Some(feed) = sources.get(name).filter(|feed| feed.source().plays_alike(source)) else {
 				continue;
 			};
 			let taken = feed.take();
@@ -978,6 +983,7 @@ impl Compositor {
 				},
 				None => continue,
 			};
+			layer.source = source.clone();
 			if let Some(taken) = taken {
 				if taken.cleared {
 					// Nothing from before the clear may show, even if the picture
@@ -2201,7 +2207,7 @@ mod tests {
 
 	use super::*;
 	use crate::collection::{Blend, MaskMode, Rgba, Scene, Size, Video};
-	use crate::source::test::{context, local, start, until, until_time};
+	use crate::source::test::{Still, context, local, start, until, until_time};
 
 	/// A fade over a second.
 	const FADE: Transition = Transition::Fade {
@@ -2285,7 +2291,7 @@ mod tests {
 		pub(super) compositor: Compositor,
 		pub(super) device: wgpu::Device,
 		queue: wgpu::Queue,
-		_origin: moq_net::origin::Producer,
+		origin: moq_net::origin::Producer,
 		_dir: tempfile::TempDir,
 	}
 
@@ -2314,7 +2320,7 @@ mod tests {
 				queue,
 				collection,
 				sources,
-				_origin: origin,
+				origin,
 				_dir: dir,
 			}
 		}
@@ -3084,6 +3090,46 @@ mod tests {
 		.await;
 	}
 
+	/// A layer whose offset alone changes keeps showing its picture, rather
+	/// than going blank until its broadcast sends another.
+	#[tokio::test]
+	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
+	async fn a_layer_moved_on_its_clock_keeps_its_picture() {
+		local(async {
+			let mut collection = collection();
+			collection.sources.insert(
+				"guest".into(),
+				Source::Broadcast {
+					path: "room/offline".into(),
+				},
+			);
+			let layer = |offset| Source::Layer {
+				clock: "guest".into(),
+				path: "room/logo".into(),
+				instance: None,
+				offset,
+			};
+			collection.sources.insert("logo".into(), layer(0));
+			collection.scenes[1].items = vec![Item::new("logo", Rect::fill(&collection.canvas))];
+			collection.validate().unwrap();
+			let mut studio = Studio::new(collection).await;
+			let _still = Still::new(&studio.origin, "room/logo", GREEN);
+			studio.compositor.set_preview(Some("blue".into()));
+			studio.compositor.cut(&studio.collection, &studio.sources).unwrap();
+			until(|| {
+				studio.render(Instant::now());
+				(pixel(&studio.program(), 1, 1) == GREEN).then_some(())
+			})
+			.await;
+
+			studio.collection.sources.insert("logo".into(), layer(250_000));
+			assert!(studio.sources.sync(&studio.collection).is_empty(), "it plays on");
+			studio.render(Instant::now());
+			assert_eq!(pixel(&studio.program(), 1, 1), GREEN);
+		})
+		.await;
+	}
+
 	/// Scenes "red" on program and "blue" in preview, with a stinger playing
 	/// `file` as the media source "sting", cutting 300 ms into it.
 	async fn stinging(file: &[u8]) -> Studio {
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index 06eaeca..d32fe73 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -365,28 +365,17 @@ impl Sources {
 	pub fn sync(&mut self, collection: &Collection) -> Vec<Driver> {
 		let mixes = &self.mixes;
 		self.feeds.retain(|name, feed| {
-			let keep = match (collection.sources.get(name), &mut feed.source) {
+			let keep = match collection.sources.get(name) {
 				// A layer moved onto its clock anew plays on, so a guest's offset
 				// changing never opens their broadcast again.
-				(
-					Some(Source::Layer {
-						clock,
-						path,
-						instance,
-						offset,
-					}),
-					Source::Layer {
-						clock: playing,
-						path: played,
-						instance: serving,
-						offset: was,
-					},
-				) if clock == playing && path == played && instance == serving => {
-					*was = *offset;
-					feed.offset.store(*offset, Ordering::Relaxed);
+				Some(source) if source.plays_alike(&feed.source) => {
+					if let Source::Layer { offset, .. } = source {
+						feed.offset.store(*offset, Ordering::Relaxed);
+					}
+					feed.source = source.clone();
 					true
 				}
-				(source, playing) => source == Some(&*playing),
+				_ => false,
 			};
 			if !keep {
 				leave(mixes, feed);
@@ -2514,6 +2503,25 @@ impl Source {
 	pub fn independent(&self) -> bool {
 		self.publishes() || matches!(self, Source::Broadcast { .. })
 	}
+
+	/// Whether what plays `self` plays `other` as is: the same source, or a
+	/// layer only moved on its clock, which its feed and picture follow.
+	pub fn plays_alike(&self, other: &Source) -> bool {
+		match (self, other) {
+			(
+				Source::Layer {
+					clock, path, instance, ..
+				},
+				Source::Layer {
+					clock: other_clock,
+					path: other_path,
+					instance: other_instance,
+					..
+				},
+			) => clock == other_clock && path == other_path && instance == other_instance,
+			_ => self == other,
+		}
+	}
 }
 
 /// `timestamp` moved `offset` microseconds, or `None` off a timestamp's range.
@@ -2714,11 +2722,45 @@ pub(crate) mod test {
 	pub(crate) async fn local<F: Future>(f: F) -> F::Output {
 		tokio::task::LocalSet::new().run_until(f).await
 	}
+
+	/// A broadcast at `path` of a one-pixel `rgba` PNG still, as a layer
+	/// reads it, published while this lives.
+	pub(crate) struct Still {
+		_publication: moq_net::origin::Route,
+		_catalog: moq_mux::catalog::Producer,
+		_track: moq_net::track::Producer,
+	}
+
+	impl Still {
+		pub(crate) fn new(origin: &moq_net::origin::Producer, path: &str, rgba: [u8; 4]) -> Self {
+			let publication = origin.route(path, moq_net::origin::RouteOptions::hidden()).unwrap();
+			let mut broadcast = publication.broadcast().clone();
+			let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
+			let mut track = broadcast.create_track("still.png", None).unwrap();
+			let pixel = image::RgbaImage::from_raw(1, 1, rgba.to_vec()).unwrap();
+			let mut png = std::io::Cursor::new(Vec::new());
+			pixel.write_to(&mut png, image::ImageFormat::Png).unwrap();
+			track.write_frame(None, bytes::Bytes::from(png.into_inner())).unwrap();
+			let mut still = hang::catalog::BinaryConfig::new(hang::catalog::Mode::Snapshot);
+			still.mime = Some("image/png".into());
+			catalog
+				.mutate(|root| {
+					root.binary.tracks.insert("still.png".into(), still);
+				})
+				.unwrap();
+			publication.announce().unwrap();
+			Self {
+				_publication: publication,
+				_catalog: catalog,
+				_track: track,
+			}
+		}
+	}
 }
 
 #[cfg(test)]
 mod tests {
-	use super::test::{context, local, start, until, until_time, video};
+	use super::test::{Still, context, local, start, until, until_time, video};
 	use super::*;
 	use crate::collection::{Audio, Rgba};
 
@@ -3264,24 +3306,7 @@ mod tests {
 			let dir = tempfile::tempdir().unwrap();
 			let (context, origin) = context(dir.path());
 			let _live = live(&origin, false).await;
-			let publication = origin
-				.route("room/logo", moq_net::origin::RouteOptions::hidden())
-				.unwrap();
-			let mut broadcast = publication.broadcast().clone();
-			let mut catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
-			let mut track = broadcast.create_track("logo.png", None).unwrap();
-			let pixel = image::RgbaImage::from_raw(1, 1, vec![255, 0, 0, 255]).unwrap();
-			let mut png = std::io::Cursor::new(Vec::new());
-			pixel.write_to(&mut png, image::ImageFormat::Png).unwrap();
-			track.write_frame(None, bytes::Bytes::from(png.into_inner())).unwrap();
-			let mut still = hang::catalog::BinaryConfig::new(hang::catalog::Mode::Snapshot);
-			still.mime = Some("image/png".into());
-			catalog
-				.mutate(|root| {
-					root.binary.tracks.insert("logo.png".into(), still);
-				})
-				.unwrap();
-			publication.announce().unwrap();
+			let _still = Still::new(&origin, "room/logo", [255, 0, 0, 255]);
 
 			let mut collection = collection();
 			collection.sources.insert(

From 4fb2e6338dc12deee3d34fc8ed0c3ec6bb873c06 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 11:37:45 -0800
Subject: [PATCH 06/10] fix(scene): an offline guest keeps its composition
 entry, and a layer fetches only the sound it plays

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                      |  11 +-
 rs/moq-scene/src/collection.rs |  24 ++--
 rs/moq-scene/src/compositor.rs |   1 +
 rs/moq-scene/src/source.rs     | 195 +++++++++++++++++++++++++++------
 rs/moq-studio/src/engine.rs    |  11 +-
 rs/moq-studio/src/watch.rs     |   4 +
 6 files changed, 197 insertions(+), 49 deletions(-)

diff --git a/README.md b/README.md
index cec6f06..f8277d5 100644
--- a/README.md
+++ b/README.md
@@ -300,7 +300,9 @@ broadcast through the first relay while that relay has a route to it, and
 through the failover otherwise, so a publisher restarted behind only the
 failover replaces the first relay's copy once that copy ends. It plays the
 best video and audio its catalog lists, switches when the catalog changes, and
-comes back on its own when the publisher restarts.
+comes back on its own when the publisher restarts. A broadcast without video
+but with an image, such as a studio's image or color published
+independently, shows that image.
 
 A broadcast source, a guest's included, plays on its publisher's timestamps,
 so its sound and picture stay in sync through network jitter and stalls. Its
@@ -1013,8 +1015,11 @@ format is the studio's own until hang specifies a composition:
   is stamped on that clock, at 0. A guest keeps a timeline of its own, so its
   offset is where the studio played it: a new composition follows it once it
   moves more than 10 ms, and a guest who joins again, as a new instance, gets
-  a new one. A guest the studio cannot play yet, such as one offline, is left
-  out with its pictures.
+  a new one. A guest the studio has not played yet, such as one offline from
+  the start, is left out with its pictures. One that goes offline after keeps
+  its entry, as the studio and every viewer hold its last picture. A still,
+  such as another studio's published image, has no moment, so without sound
+  its offset is 0.
 - A source's `sound`, when the audio scene on program holds it, is the
   `gain`, `muted`, `pan`, and `delay` it plays at.
 - Each source may carry a subscription `priority` (0 if absent) and whether a
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index 572d301..d3b0368 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -1880,6 +1880,8 @@ pub enum Source {
 		/// Microseconds added to its timestamps to put them on `clock`'s
 		/// timeline. A change plays on without opening the broadcast again.
 		offset: i64,
+		/// Whether its sound plays; without it, its sound is never fetched.
+		sound: bool,
 	},
 }
 
@@ -1929,16 +1931,18 @@ impl Source {
 
 	/// Whether the source feeds the program audio.
 	pub fn has_audio(&self) -> bool {
-		matches!(
-			self,
-			Self::Microphone { .. }
-				| Self::SystemAudio
-				| Self::Media { .. }
-				| Self::Broadcast { .. }
-				| Self::Browser { .. }
-				| Self::Replay
-				| Self::Layer { .. }
-		)
+		match self {
+			Self::Layer { sound, .. } => *sound,
+			_ => matches!(
+				self,
+				Self::Microphone { .. }
+					| Self::SystemAudio
+					| Self::Media { .. }
+					| Self::Broadcast { .. }
+					| Self::Browser { .. }
+					| Self::Replay
+			),
+		}
 	}
 
 	fn validate(&self, name: &str) -> Result<(), Error> {
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 3aaae92..124cff8 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -3108,6 +3108,7 @@ mod tests {
 				path: "room/logo".into(),
 				instance: None,
 				offset,
+				sound: false,
 			};
 			collection.sources.insert("logo".into(), layer(0));
 			collection.scenes[1].items = vec![Item::new("logo", Rect::fill(&collection.canvas))];
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index d32fe73..bab9dff 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -111,6 +111,8 @@ struct Played {
 	audio: Option<(String, AudioConfig)>,
 	/// The newest picture shown from it, where a replay of it ends.
 	newest: Option<moq_net::Timestamp>,
+	/// Whether it shows a still, which has no moment, rather than video.
+	still: bool,
 }
 
 type Playback = Arc<Mutex<Played>>;
@@ -537,6 +539,18 @@ pub struct Feed {
 	/// A layer's offset onto its clock, in microseconds, which its driver
 	/// reads as it plays.
 	offset: Arc<AtomicI64>,
+	/// Where a broadcast source last landed on a timeline.
+	landed: Mutex<Option<Landing>>,
+}
+
+/// Where a broadcast source's timestamps land on another timeline, as
+/// [`Feed::lands`] finds it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Landing {
+	/// The stream it holds for, `None` when the origin names none.
+	pub instance: Option<moq_net::Instance>,
+	/// Microseconds to add to its timestamps to put them on the timeline.
+	pub offset: i64,
 }
 
 impl Feed {
@@ -732,21 +746,40 @@ impl Feed {
 		played.broadcast.as_ref()?.info().instance.clone()
 	}
 
-	/// Microseconds to add to a broadcast source's timestamps to put them on
-	/// a timeline that reads `at` at `now`: where what it plays lands on that
-	/// timeline. `None` until its clock is anchored, and for any other source.
-	pub fn offset(&self, at: Duration, now: Instant) -> Option<i64> {
-		if !matches!(self.source, Source::Broadcast { .. }) || self.status() != Status::Live {
+	/// Where a broadcast source's timestamps land on a timeline that reads
+	/// `at` at `now`: where what it shows lands there. While that cannot be
+	/// found, such as offline, failed, or before a new stream shows anything,
+	/// where it last landed, since its last picture stays until another
+	/// replaces it. `None` before it ever lands, and for any other source.
+	pub fn lands(&self, at: Duration, now: Instant) -> Option<Landing> {
+		if !matches!(self.source, Source::Broadcast { .. }) {
+			return None;
+		}
+		let mut landed = self.landed.lock().unwrap();
+		if let Some(landing) = self.landing(at, now) {
+			*landed = Some(landing);
+		}
+		landed.clone()
+	}
+
+	/// Where the stream online now lands, once its clock is anchored. A still
+	/// has no moment, so without sound to anchor it, it lands at 0.
+	fn landing(&self, at: Duration, now: Instant) -> Option<Landing> {
+		if self.status() != Status::Live {
 			return None;
 		}
 		let clock = self.clock.as_ref()?;
+		let played = self.played.lock().unwrap();
+		let instance = played.broadcast.as_ref()?.info().instance.clone();
 		// Any stamp maps through the one anchor: the newest picture shown, or
 		// without one, the sound playing now.
-		let newest = self.played.lock().unwrap().newest;
-		let reference = match newest {
-			Some(newest) => newest,
-			None => moq_net::Timestamp::try_from(clock.playhead(now)?).ok()?,
+		let reference = match (played.newest, clock.playhead(now)) {
+			(Some(newest), _) => newest,
+			(None, Some(head)) => moq_net::Timestamp::try_from(head).ok()?,
+			(None, None) if played.still => return Some(Landing { instance, offset: 0 }),
+			(None, None) => return None,
 		};
+		drop(played);
 		let due = clock.due(reference)?;
 		let micros = |duration: Duration| i64::try_from(duration.as_micros()).ok();
 		// When the reference plays, on the timeline.
@@ -754,7 +787,8 @@ impl Feed {
 			Some(ahead) => micros(at)?.checked_add(micros(ahead)?)?,
 			None => micros(at)?.checked_sub(micros(now.duration_since(due))?)?,
 		};
-		lands.checked_sub(micros(Duration::from(reference))?)
+		let offset = lands.checked_sub(micros(Duration::from(reference))?)?;
+		Some(Landing { instance, offset })
 	}
 
 	/// The source's gain, mute, delay, and meter in every mix, if it has sound.
@@ -1252,14 +1286,12 @@ impl Driver {
 						return Ok(());
 					};
 					let next_video = pick(catalog.video.enabled())?;
-					let next_audio = pick(catalog.audio.enabled())?;
-					// A source without video, such as an image or a color, is a still.
-					let still = {
-						let mut stills = catalog.binary.tracks.iter();
-						stills
-							.find(|(_, config)| config.broadcast.is_none() && config.mime.as_deref().is_some_and(|mime| mime.starts_with("image/")))
-							.map(|(id, config)| Reference::track(config, id).to_string())
+					// Sound it does not play, it never fetches.
+					let next_audio = match self.strip {
+						Some(_) => pick(catalog.audio.enabled())?,
+						None => None,
 					};
+					let still = still(&catalog.binary);
 					let track = match &next_video {
 						Some((id, config)) => Some(Reference::track(config, id).to_string()),
 						None => still.clone(),
@@ -1485,9 +1517,13 @@ impl Driver {
 					};
 					let next_video = pick(catalog.video.enabled())?;
 					let next_audio = pick(catalog.audio.enabled())?;
-					let track = next_video
-						.as_ref()
-						.map(|(id, config)| (Reference::track(config, id).to_string(), next_audio.is_some()));
+					// A broadcast without video, such as another studio's
+					// published image, shows a still, as a layer of it does.
+					let still = still(&catalog.binary);
+					let track = match &next_video {
+						Some((id, config)) => Some((Reference::track(config, id).to_string(), next_audio.is_some())),
+						None => still.clone().map(|still| (still, false)),
+					};
 					if track != video {
 						video = track;
 						let mut played = self.played.lock().unwrap();
@@ -1495,13 +1531,15 @@ impl Driver {
 						// The newest picture was the old track's, a moment the
 						// new one may not hold.
 						played.newest = None;
+						played.still = next_video.is_none() && still.is_some();
 						drop(played);
 						// Video waits for its audio as long as audio's target can
 						// grow; alone, it waits only its own delay.
 						let max = if next_audio.is_some() { MAX_DELAY } else { VIDEO_DELAY };
-						video_playing = match next_video {
-							Some((id, config)) => Box::pin(self.play_video(&broadcast, id, config, &clock, max)),
-							None => Box::pin(std::future::pending()),
+						video_playing = match (next_video, still) {
+							(Some((id, config)), _) => Box::pin(self.play_video(&broadcast, id, config, &clock, max)),
+							(None, Some(still)) => Box::pin(self.follow_still(&broadcast, still)),
+							(None, None) => Box::pin(std::future::pending()),
 						};
 					}
 					let track = next_audio.as_ref().map(|(id, config)| Reference::track(config, id).to_string());
@@ -2440,6 +2478,7 @@ fn open(
 			None => clock.as_ref().map(timeline::Producer::consume),
 		},
 		offset: offset.clone(),
+		landed: Mutex::new(None),
 	};
 	let driver = Driver {
 		name: name.to_string(),
@@ -2510,20 +2549,37 @@ impl Source {
 		match (self, other) {
 			(
 				Source::Layer {
-					clock, path, instance, ..
+					clock,
+					path,
+					instance,
+					sound,
+					..
 				},
 				Source::Layer {
 					clock: other_clock,
 					path: other_path,
 					instance: other_instance,
+					sound: other_sound,
 					..
 				},
-			) => clock == other_clock && path == other_path && instance == other_instance,
+			) => clock == other_clock && path == other_path && instance == other_instance && sound == other_sound,
 			_ => self == other,
 		}
 	}
 }
 
+/// The image track a broadcast without video shows as a still, such as a
+/// published image or color.
+fn still(binary: &hang::catalog::Binary) -> Option<String> {
+	binary
+		.tracks
+		.iter()
+		.find(|(_, config)| {
+			config.broadcast.is_none() && config.mime.as_deref().is_some_and(|mime| mime.starts_with("image/"))
+		})
+		.map(|(id, config)| Reference::track(config, id).to_string())
+}
+
 /// `timestamp` moved `offset` microseconds, or `None` off a timestamp's range.
 fn shift(timestamp: moq_net::Timestamp, offset: i64) -> Option<moq_net::Timestamp> {
 	// Unmoved, it keeps its own timescale.
@@ -3242,6 +3298,7 @@ mod tests {
 				path: "room/cam".into(),
 				instance: None,
 				offset,
+				sound: false,
 			};
 			collection.sources.insert("cam".into(), layer(250_000));
 			collection.validate().unwrap();
@@ -3316,6 +3373,7 @@ mod tests {
 					path: "room/logo".into(),
 					instance: None,
 					offset: 0,
+					sound: false,
 				},
 			);
 			let mut sources = Sources::new(context);
@@ -3332,6 +3390,61 @@ mod tests {
 		.await;
 	}
 
+	/// A broadcast without video, such as another studio's published image,
+	/// shows its still, which has no moment, so it lands on any timeline at 0.
+	#[tokio::test]
+	async fn a_broadcast_shows_a_still() {
+		local(async {
+			let dir = tempfile::tempdir().unwrap();
+			let (context, origin) = context(dir.path());
+			let _still = Still::new(&origin, "room/guest", [255, 0, 0, 255]);
+			let mut sources = Sources::new(context);
+			let drivers = sources.sync(&collection());
+			start(&sources, drivers).await;
+			let feed = sources.get("guest").unwrap();
+			let pixels = until(|| match feed.next_picture() {
+				Some(Picture::Rgba { pixels, .. }) => Some(pixels),
+				_ => None,
+			})
+			.await;
+			assert_eq!(pixels, [255, 0, 0, 255]);
+			let landing = feed.lands(Duration::from_secs(5), kio::clock::now()).unwrap();
+			assert_eq!(landing.offset, 0);
+			assert!(landing.instance.is_some());
+		})
+		.await;
+	}
+
+	/// A layer whose sound plays nowhere has no strip, so it never fetches
+	/// its broadcast's sound.
+	#[tokio::test]
+	async fn a_layer_fetches_only_the_sound_it_plays() {
+		local(async {
+			let dir = tempfile::tempdir().unwrap();
+			let (context, _origin) = context(dir.path());
+			let mut collection = collection();
+			let layer = |sound| Source::Layer {
+				clock: "guest".into(),
+				path: "room/cam".into(),
+				instance: None,
+				offset: 0,
+				sound,
+			};
+			collection.sources.insert("cam".into(), layer(false));
+			let mut sources = Sources::new(context);
+			let drivers = sources.sync(&collection);
+			start(&sources, drivers).await;
+			assert!(sources.get("cam").unwrap().strip().is_none());
+
+			collection.sources.insert("cam".into(), layer(true));
+			let drivers = sources.sync(&collection);
+			assert_eq!(drivers.len(), 1, "opened again to play its sound");
+			start(&sources, drivers).await;
+			assert!(sources.get("cam").unwrap().strip().is_some());
+		})
+		.await;
+	}
+
 	/// A layer stops with its broadcast source, and starts again on its
 	/// replacement's clock, and opens again for another broadcast or stream.
 	#[tokio::test]
@@ -3345,6 +3458,7 @@ mod tests {
 				path: path.into(),
 				instance: instance.map(|instance| instance.parse().unwrap()),
 				offset: 0,
+				sound: false,
 			};
 			collection.sources.insert("cam".into(), layer("room/cam", None));
 			let mut sources = Sources::new(context);
@@ -3447,12 +3561,12 @@ mod tests {
 			let feed = sources.get("guest").unwrap();
 			let clock = feed.clock.clone().unwrap();
 			assert_eq!(
-				feed.offset(Duration::from_secs(5), kio::clock::now()),
+				feed.lands(Duration::from_secs(5), kio::clock::now()),
 				None,
 				"unanchored"
 			);
 			assert_eq!(
-				sources.get("red").unwrap().offset(Duration::ZERO, kio::clock::now()),
+				sources.get("red").unwrap().lands(Duration::ZERO, kio::clock::now()),
 				None
 			);
 
@@ -3462,14 +3576,33 @@ mod tests {
 			let due = until(|| clock.due(stamp)).await;
 			until_time(due).await;
 			assert_eq!(shown(feed).await, Duration::from(stamp));
-			assert!(feed.instance().is_some(), "an origin names the stream");
+			let instance = feed.instance();
+			assert!(instance.is_some(), "an origin names the stream");
 			let now = kio::clock::now();
+			let offset = |at, now| feed.lands(at, now).map(|landing| landing.offset);
 			// Shown now, as the timeline reads 5 s: 4 s after its own stamp.
-			assert_eq!(feed.offset(Duration::from_secs(5), now), Some(4_000_000));
-			assert_eq!(feed.offset(Duration::from_millis(400), now), Some(-600_000));
+			assert_eq!(offset(Duration::from_secs(5), now), Some(4_000_000));
+			assert_eq!(offset(Duration::from_millis(400), now), Some(-600_000));
 			// Read 10 ms later, it was shown 10 ms before then.
 			let later = now + Duration::from_millis(10);
-			assert_eq!(feed.offset(Duration::from_secs(5), later), Some(3_990_000));
+			assert_eq!(
+				feed.lands(Duration::from_secs(5), later),
+				Some(Landing {
+					instance: instance.clone(),
+					offset: 3_990_000
+				})
+			);
+
+			// Offline, its last picture stays, so it lands where it last did.
+			drop(live);
+			until(|| (feed.status() == Status::Offline).then_some(())).await;
+			assert_eq!(
+				feed.lands(Duration::from_secs(6), later + Duration::from_secs(1)),
+				Some(Landing {
+					instance,
+					offset: 3_990_000
+				})
+			);
 		})
 		.await;
 	}
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 77a2006..872f345 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -819,8 +819,8 @@ impl Program {
 
 	/// Publish the composition of what `state` drew on program at `at` on
 	/// the media clock, at `now`: the program, and each source published
-	/// independently that is online, a broadcast source where what it showed
-	/// then lands on the program's clock.
+	/// independently, a broadcast source once it has shown anything, where
+	/// what it showed lands on the program's clock.
 	fn compose(&self, state: &State, at: Duration, now: Instant) {
 		// Past what a timestamp holds, the frame goes unstamped too.
 		let Ok(stamp) = moq_net::Timestamp::try_from(at) else {
@@ -832,13 +832,14 @@ impl Program {
 		for name in &collection.published {
 			let child = match collection.sources.get(name) {
 				Some(Source::Broadcast { path }) => {
-					// Offline, or not yet playing, it shows nothing here either.
+					// Before it ever shows, it shows nothing here either; offline
+					// after, both hold its last picture where it landed.
 					let Some(feed) = state.sources.get(name) else { continue };
-					let Some(offset) = feed.offset(at, now) else { continue };
+					let Some(landing) = feed.lands(at, now) else { continue };
 					let Some(broadcast) = composed.child(name, Some(path)) else {
 						continue;
 					};
-					moq_scene::composition::Child::new(broadcast, feed.instance(), offset)
+					moq_scene::composition::Child::new(broadcast, landing.instance, landing.offset)
 				}
 				Some(_) => match composed.child(name, None) {
 					Some(broadcast) => moq_scene::composition::Child::new(broadcast, None, 0),
diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs
index 3df6699..6cf2f69 100644
--- a/rs/moq-studio/src/watch.rs
+++ b/rs/moq-studio/src/watch.rs
@@ -409,6 +409,7 @@ fn collection(composition: Option<&Composition>, size: Canvas, paths: &Paths) ->
 					path: path.to_string(),
 					instance: child.instance.clone(),
 					offset: child.offset,
+					sound: child.sound.is_some(),
 				},
 			);
 			if let Some(audio) = &child.sound {
@@ -685,6 +686,7 @@ mod tests {
 				path: "show/source/program".into(),
 				instance: None,
 				offset: 0,
+				sound: false,
 			}
 		);
 		assert_eq!(
@@ -694,6 +696,7 @@ mod tests {
 				path: "guests/alice".into(),
 				instance: Some("abc".parse().unwrap()),
 				offset: -1_500,
+				sound: true,
 			}
 		);
 		let heard = driven.heard(AudioScene::DEFAULT);
@@ -1071,6 +1074,7 @@ mod tests {
 				path: "guests/alice".into(),
 				instance: alice.instance.clone(),
 				offset: alice.offset,
+				sound: alice.sound.is_some(),
 			}
 		);
 		kio::clock::timeout(TIMEOUT, async {

From b2c65981b04400732f6d60a876df9e4882058c3d Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 13:17:47 -0800
Subject: [PATCH 07/10] fix(scene): an offline broadcast source clears its
 picture, and the composition waits for timed catalogs

A broadcast source clears what a stream showed once it ends or another
replaces it, so the composition drops an offline guest instead of
remembering its offset. A layer keeps its strip and fetches its sound only
while a mix routes it, so a sound change no longer reopens it, and a still
never reads as stalled.

The quest is rewritten to moving the composition into its broadcast's hang
catalog, which requires the new pin-timed-catalog quest.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                             |  18 ++-
 quest/m2/compose/README.md            |   3 +-
 quest/m2/compose/layout.md            |  41 ++++++
 quest/m2/compose/pin-timed-catalog.md |  29 ++++
 rs/moq-scene/src/collection.rs        |  24 ++--
 rs/moq-scene/src/compositor.rs        |   1 -
 rs/moq-scene/src/source.rs            | 184 ++++++++++++++------------
 rs/moq-studio/src/engine.rs           |   6 +-
 rs/moq-studio/src/watch.rs            |   4 -
 9 files changed, 198 insertions(+), 112 deletions(-)
 create mode 100644 quest/m2/compose/layout.md
 create mode 100644 quest/m2/compose/pin-timed-catalog.md

diff --git a/README.md b/README.md
index f8277d5..24fcbae 100644
--- a/README.md
+++ b/README.md
@@ -300,9 +300,12 @@ broadcast through the first relay while that relay has a route to it, and
 through the failover otherwise, so a publisher restarted behind only the
 failover replaces the first relay's copy once that copy ends. It plays the
 best video and audio its catalog lists, switches when the catalog changes, and
-comes back on its own when the publisher restarts. A broadcast without video
-but with an image, such as a studio's image or color published
-independently, shows that image.
+comes back on its own when the publisher restarts. While it is offline, or
+once a new stream replaces the one it played, it shows nothing until the new
+stream's first picture, rather than freezing on the last one. A broadcast
+without video but with an image, such as a studio's image or color published
+independently, shows that image, and never reads as stalled, since it sends
+a picture only when it changes.
 
 A broadcast source, a guest's included, plays on its publisher's timestamps,
 so its sound and picture stay in sync through network jitter and stalls. Its
@@ -1015,9 +1018,8 @@ format is the studio's own until hang specifies a composition:
   is stamped on that clock, at 0. A guest keeps a timeline of its own, so its
   offset is where the studio played it: a new composition follows it once it
   moves more than 10 ms, and a guest who joins again, as a new instance, gets
-  a new one. A guest the studio has not played yet, such as one offline from
-  the start, is left out with its pictures. One that goes offline after keeps
-  its entry, as the studio and every viewer hold its last picture. A still,
+  a new one. A guest the studio shows nothing of, such as one offline, is
+  left out with its pictures until it shows again. A still,
   such as another studio's published image, has no moment, so without sound
   its offset is 0.
 - A source's `sound`, when the audio scene on program holds it, is the
@@ -1053,7 +1055,9 @@ goes once `moq play` plays compositions.
   moved by its `offset`: a picture shows when the program's picture stamped
   alike does, and a sound plays with the program's sound stamped alike, at
   its `gain`, `muted`, `pan`, and `delay`. A frame too late for its moment is
-  dropped. A new offset plays on without fetching the broadcast again.
+  dropped. A new offset plays on without fetching the broadcast again. A
+  source's sound is fetched only while the composition gives it a `sound`,
+  and gaining or losing one does not fetch its picture again.
 - A source whose `instance` another stream replaced shows nothing until a
   composition names the new one, and a composition naming another program
   stream waits for it, so neither plays on a timeline its offset is not for.
diff --git a/quest/m2/compose/README.md b/quest/m2/compose/README.md
index fe35dca..1ddafdb 100644
--- a/quest/m2/compose/README.md
+++ b/quest/m2/compose/README.md
@@ -58,7 +58,8 @@ source, local or guest, its own broadcast (rejected: a layer layout track in
 the program's broadcast naming tracks; local sources as tracks of the
 program's broadcast, the 2026-10-26 rule this reverses). The studio
 prototypes the format first: `rs/moq-scene/src/composition.rs`, documented in
-the README's "Composition".
+the README's "Composition". [Moving it into its broadcast's
+catalog](/quest/m2/compose/layout.md) waits for hang's timed catalogs.
 
 moq's side, in its own quest tree (m3): hang specifies the composition, and
 `moq play` and `@moq/watch` composite it. moq's three layers quests were
diff --git a/quest/m2/compose/layout.md b/quest/m2/compose/layout.md
new file mode 100644
index 0000000..764ab8c
--- /dev/null
+++ b/quest/m2/compose/layout.md
@@ -0,0 +1,41 @@
+# [M] The composition is in its broadcast's hang catalog
+
+## Goal
+
+The composition the studio publishes (`rs/moq-scene/src/composition.rs`, the
+README's "Composition") travels in the composition broadcast's hang catalog,
+each update applied at its timestamp on the program's clock, in place of the
+interim `live.kixel.studio.composition` JSON snapshot track. `moq-studio
+--watch` (`rs/moq-studio/src/watch.rs`) reads it from that catalog, and
+`README.md`'s "Composition" and "Watching" say so.
+
+## Plan
+
+Decided 2026-11-12 (maintainer, /quest-complete on
+[moq-dev/studio#146](https://github.com/moq-dev/studio/pull/146)), which
+landed the composition on the interim track:
+
+- **Home:** ✅ the composition broadcast's hang catalog, applied at each
+  update's timestamp (rejected: shipping the interim JSON snapshot track as
+  the format). moq plans timed catalogs in
+  [catalog-at-timestamp](https://github.com/moq-dev/moq/blob/main/quest/m2/catalog-at-timestamp.md)
+  (m2, on lite-07's time addressing), and the rest of its composition plan in
+  [composed broadcasts](https://github.com/moq-dev/moq/blob/main/quest/m3/layers/README.md).
+- **Shape:** ✅ kept as #146 has it: each child entry carries `sound`,
+  `priority`, and `toggle`, and placements live in `pictures`, each naming a
+  child, so one broadcast can show in several places (rejected: one
+  placement per child, as moq's spec quest said; moq's
+  `quest/m3/layers/spec.md` is updated to match).
+
+Recommended, not decided: the composition goes in a section of the catalog
+under the studio's own name until hang specifies one, with `version` kept,
+since moq's spec may still change it; the catalog also lists the program's
+renditions, as moq's plan has a composition list its main's, so a player
+that knows no compositions plays the program from it. A child's offset and
+each placement then change with one timed catalog update, and the watcher
+applies each when the program plays the frame stamped alike, as it applies
+the track's groups now.
+
+## Required
+
+- [hang's timed catalog is pinned](/quest/m2/compose/pin-timed-catalog.md) - hands the studio each catalog update with its timestamp
diff --git a/quest/m2/compose/pin-timed-catalog.md b/quest/m2/compose/pin-timed-catalog.md
new file mode 100644
index 0000000..af87a3d
--- /dev/null
+++ b/quest/m2/compose/pin-timed-catalog.md
@@ -0,0 +1,29 @@
+# [S] hang's timed catalog is pinned
+
+## Goal
+
+The `moq` submodule includes hang applying each catalog update at its
+timestamp, from moq's
+[hang applies catalog updates at their timestamp](https://github.com/moq-dev/moq/blob/main/quest/m2/catalog-at-timestamp.md),
+so `rs/hang`'s catalog consumer hands the studio each update with its
+timestamp, which [the composition](/quest/m2/compose/layout.md) needs to move
+into its broadcast's catalog.
+
+## Plan
+
+Once the wait clears, advance it with `just upgrade-moq` in its own PR,
+fixing whatever the new API breaks here. That quest builds on moq's lite-07
+time addressing (groups addressed by their start), so the pin may cross
+that model change too, which is why it is sized above the usual pin.
+
+## Waiting
+
+- moq-dev/moq: the catalog-at-timestamp quest lands. Check: its PR has
+  merged on moq's `main`, deleting `quest/m2/catalog-at-timestamp.md`, and
+  `rs/hang/src/catalog/consumer.rs` returns each catalog with its timestamp.
+  A quest file that moved, or went away without its work landing, does not
+  count.
+
+## Required
+
+- [The studio is caught up to moq's main](/quest/m0/pin-main.md) - moq's breaking changes since moq-dev/moq#8272, so this pin takes only its own
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index d3b0368..572d301 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -1880,8 +1880,6 @@ pub enum Source {
 		/// Microseconds added to its timestamps to put them on `clock`'s
 		/// timeline. A change plays on without opening the broadcast again.
 		offset: i64,
-		/// Whether its sound plays; without it, its sound is never fetched.
-		sound: bool,
 	},
 }
 
@@ -1931,18 +1929,16 @@ impl Source {
 
 	/// Whether the source feeds the program audio.
 	pub fn has_audio(&self) -> bool {
-		match self {
-			Self::Layer { sound, .. } => *sound,
-			_ => matches!(
-				self,
-				Self::Microphone { .. }
-					| Self::SystemAudio
-					| Self::Media { .. }
-					| Self::Broadcast { .. }
-					| Self::Browser { .. }
-					| Self::Replay
-			),
-		}
+		matches!(
+			self,
+			Self::Microphone { .. }
+				| Self::SystemAudio
+				| Self::Media { .. }
+				| Self::Broadcast { .. }
+				| Self::Browser { .. }
+				| Self::Replay
+				| Self::Layer { .. }
+		)
 	}
 
 	fn validate(&self, name: &str) -> Result<(), Error> {
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 124cff8..3aaae92 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -3108,7 +3108,6 @@ mod tests {
 				path: "room/logo".into(),
 				instance: None,
 				offset,
-				sound: false,
 			};
 			collection.sources.insert("logo".into(), layer(0));
 			collection.scenes[1].items = vec![Item::new("logo", Rect::fill(&collection.canvas))];
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index bab9dff..eccb908 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -457,6 +457,10 @@ impl Sources {
 						mix.unroute(strip);
 					}
 				}
+				if let Some(sound) = &self.feeds[name].sound {
+					let heard = self.mixes.values().any(|mix| mix.routes(strip));
+					sound.send_if_modified(|playing| std::mem::replace(playing, heard) != heard);
+				}
 			}
 		}
 		drivers
@@ -539,8 +543,9 @@ pub struct Feed {
 	/// A layer's offset onto its clock, in microseconds, which its driver
 	/// reads as it plays.
 	offset: Arc<AtomicI64>,
-	/// Where a broadcast source last landed on a timeline.
-	landed: Mutex<Option<Landing>>,
+	/// Whether any mix plays a layer's sound, which its driver fetches only
+	/// while one does.
+	sound: Option<watch::Sender<bool>>,
 }
 
 /// Where a broadcast source's timestamps land on another timeline, as
@@ -707,7 +712,8 @@ impl Feed {
 	/// without delivering, once that is at least [`STALL`] at `now`.
 	///
 	/// Displays and windows are never stalled: a capture of a still screen
-	/// delivers nothing until it changes. Neither are sources that have not
+	/// delivers nothing until it changes. Nor is a broadcast showing a still,
+	/// which sends a picture only when it changes. Neither are sources that have not
 	/// delivered yet, such as an audio-only broadcast: a broadcast stalls by its
 	/// picture alone.
 	pub fn stalled(&self, now: Instant) -> Option<Stall> {
@@ -716,7 +722,7 @@ impl Feed {
 			Source::Microphone { .. } | Source::SystemAudio => Stall::Sound,
 			_ => return None,
 		};
-		if self.status() != Status::Live {
+		if self.status() != Status::Live || self.played.lock().unwrap().still {
 			return None;
 		}
 		let delivered = (*self.delivered.lock().unwrap())?;
@@ -747,25 +753,12 @@ impl Feed {
 	}
 
 	/// Where a broadcast source's timestamps land on a timeline that reads
-	/// `at` at `now`: where what it shows lands there. While that cannot be
-	/// found, such as offline, failed, or before a new stream shows anything,
-	/// where it last landed, since its last picture stays until another
-	/// replaces it. `None` before it ever lands, and for any other source.
+	/// `at` at `now`: where what the stream online now shows lands there. A
+	/// still has no moment, so without sound to anchor it, it lands at 0.
+	/// `None` while it shows nothing of that stream, such as offline, failed,
+	/// or before its clock anchors, and for any other source.
 	pub fn lands(&self, at: Duration, now: Instant) -> Option<Landing> {
-		if !matches!(self.source, Source::Broadcast { .. }) {
-			return None;
-		}
-		let mut landed = self.landed.lock().unwrap();
-		if let Some(landing) = self.landing(at, now) {
-			*landed = Some(landing);
-		}
-		landed.clone()
-	}
-
-	/// Where the stream online now lands, once its clock is anchored. A still
-	/// has no moment, so without sound to anchor it, it lands at 0.
-	fn landing(&self, at: Duration, now: Instant) -> Option<Landing> {
-		if self.status() != Status::Live {
+		if !matches!(self.source, Source::Broadcast { .. }) || self.status() != Status::Live {
 			return None;
 		}
 		let clock = self.clock.as_ref()?;
@@ -841,6 +834,8 @@ pub struct Driver {
 	follows: Option<timeline::Consumer>,
 	/// A layer's offset onto that clock, in microseconds.
 	offset: Arc<AtomicI64>,
+	/// Whether any mix plays a layer's sound.
+	sound: Option<watch::Receiver<bool>>,
 }
 
 /// Where a source's own track goes, its claim on the local catalog's listing
@@ -1219,7 +1214,6 @@ impl Driver {
 				.zip(serving)
 				.is_some_and(|(named, serving)| !serving.is_minted() && named != serving);
 			if other {
-				self.picture.lock().unwrap().clear();
 				return Box::pin(std::future::pending());
 			}
 			Box::pin(self.play_layer(broadcast, path, schedule))
@@ -1228,7 +1222,9 @@ impl Driver {
 	}
 
 	/// Play each instance of the broadcast at `path` with `start` as it comes
-	/// online, until the next replaces it or it goes offline.
+	/// online, until the next replaces it or it goes offline. What one showed
+	/// clears as it ends, so nothing holds a frozen picture of a stream
+	/// that is gone, which a viewer joining later could not see.
 	async fn follow<'a>(
 		&'a self,
 		path: &str,
@@ -1242,11 +1238,18 @@ impl Driver {
 			tokio::select! {
 				event = instances.available() => match event {
 					Ok(Some(broadcast)) => {
+						// The last stream's picture is not this one's, and it
+						// stops before the clear, so it shows nothing after.
+						if playing.take().is_some() {
+							self.picture.lock().unwrap().clear();
+						}
 						set(&self.status, Status::Live);
 						playing = Some(start(broadcast));
 					}
 					Ok(None) => {
-						playing = None;
+						if playing.take().is_some() {
+							self.picture.lock().unwrap().clear();
+						}
 						*self.played.lock().unwrap() = Played::default();
 						set(&self.status, Status::Offline);
 					}
@@ -1254,6 +1257,8 @@ impl Driver {
 				},
 				result = async { playing.as_mut().expect("guarded").await }, if playing.is_some() => {
 					playing = None;
+					*self.played.lock().unwrap() = Played::default();
+					self.picture.lock().unwrap().clear();
 					set(&self.status, match result {
 						Ok(()) => Status::Offline,
 						Err(err) => Status::Failed(err.to_string()),
@@ -1275,8 +1280,10 @@ impl Driver {
 	) -> Result<(), Error> {
 		let format = moq_mux::catalog::CatalogFormat::detect(path).unwrap_or_default();
 		let mut catalogs = moq_mux::catalog::Consumer::<()>::new(&broadcast, format).await?;
+		let mut sound = self.sound.clone().expect("a layer has a sound flag");
 		let mut video: Option<String> = None;
 		let mut audio: Option<String> = None;
+		let mut audios = None;
 		let mut video_playing: Playing<'_> = Box::pin(std::future::pending());
 		let mut audio_playing: Playing<'_> = Box::pin(std::future::pending());
 		loop {
@@ -1286,11 +1293,6 @@ impl Driver {
 						return Ok(());
 					};
 					let next_video = pick(catalog.video.enabled())?;
-					// Sound it does not play, it never fetches.
-					let next_audio = match self.strip {
-						Some(_) => pick(catalog.audio.enabled())?,
-						None => None,
-					};
 					let still = still(&catalog.binary);
 					let track = match &next_video {
 						Some((id, config)) => Some(Reference::track(config, id).to_string()),
@@ -1298,6 +1300,7 @@ impl Driver {
 					};
 					if track != video {
 						video = track;
+						self.played.lock().unwrap().still = next_video.is_none() && still.is_some();
 						video_playing = match (next_video, still) {
 							(Some((id, config)), _) => Box::pin(self.follow_video(&broadcast, id, config, schedule)),
 							(None, Some(still)) => Box::pin(self.follow_still(&broadcast, still)),
@@ -1307,15 +1310,9 @@ impl Driver {
 							}
 						};
 					}
-					let track = next_audio.as_ref().map(|(id, config)| Reference::track(config, id).to_string());
-					if track != audio {
-						audio = track;
-						audio_playing = match next_audio {
-							Some((id, config)) => Box::pin(self.follow_audio(&broadcast, id, config, schedule)),
-							None => Box::pin(std::future::pending()),
-						};
-					}
+					audios = Some(catalog.audio);
 				}
+				Ok(()) = sound.changed() => {}
 				result = &mut video_playing => {
 					result?;
 					video_playing = Box::pin(std::future::pending());
@@ -1325,6 +1322,21 @@ impl Driver {
 					audio_playing = Box::pin(std::future::pending());
 				}
 			}
+			// Sound no mix plays, it never fetches.
+			let next_audio = match (*sound.borrow_and_update(), &audios) {
+				(true, Some(audios)) => pick(audios.enabled())?,
+				_ => None,
+			};
+			let track = next_audio
+				.as_ref()
+				.map(|(id, config)| Reference::track(config, id).to_string());
+			if track != audio {
+				audio = track;
+				audio_playing = match next_audio {
+					Some((id, config)) => Box::pin(self.follow_audio(&broadcast, id, config, schedule)),
+					None => Box::pin(std::future::pending()),
+				};
+			}
 		}
 	}
 
@@ -1539,7 +1551,10 @@ impl Driver {
 						video_playing = match (next_video, still) {
 							(Some((id, config)), _) => Box::pin(self.play_video(&broadcast, id, config, &clock, max)),
 							(None, Some(still)) => Box::pin(self.follow_still(&broadcast, still)),
-							(None, None) => Box::pin(std::future::pending()),
+							(None, None) => {
+								self.picture.lock().unwrap().clear();
+								Box::pin(std::future::pending())
+							}
 						};
 					}
 					let track = next_audio.as_ref().map(|(id, config)| Reference::track(config, id).to_string());
@@ -2455,6 +2470,8 @@ fn open(
 		Source::Layer { offset, .. } => *offset,
 		_ => 0,
 	}));
+	// Silent until a sync routes it into a mix.
+	let sound = matches!(source, Source::Layer { .. }).then(|| watch::channel(false));
 	let runs = Runs::new(Mutex::new(Latest {
 		run: Run::default(),
 		stopped: held,
@@ -2478,7 +2495,7 @@ fn open(
 			None => clock.as_ref().map(timeline::Producer::consume),
 		},
 		offset: offset.clone(),
-		landed: Mutex::new(None),
+		sound: sound.as_ref().map(|(sender, _)| sender.clone()),
 	};
 	let driver = Driver {
 		name: name.to_string(),
@@ -2498,6 +2515,7 @@ fn open(
 		clock,
 		follows,
 		offset,
+		sound: sound.map(|(_, receiver)| receiver),
 	};
 	(feed, driver)
 }
@@ -2549,20 +2567,15 @@ impl Source {
 		match (self, other) {
 			(
 				Source::Layer {
-					clock,
-					path,
-					instance,
-					sound,
-					..
+					clock, path, instance, ..
 				},
 				Source::Layer {
 					clock: other_clock,
 					path: other_path,
 					instance: other_instance,
-					sound: other_sound,
 					..
 				},
-			) => clock == other_clock && path == other_path && instance == other_instance && sound == other_sound,
+			) => clock == other_clock && path == other_path && instance == other_instance,
 			_ => self == other,
 		}
 	}
@@ -3177,7 +3190,7 @@ mod tests {
 		.await;
 	}
 
-	/// A live broadcast at `room/guest`, writing nothing until the test does.
+	/// A live broadcast, writing nothing until the test does.
 	struct Live {
 		_publication: moq_net::origin::Route,
 		broadcast: moq_net::broadcast::Producer,
@@ -3202,9 +3215,12 @@ mod tests {
 
 	/// A broadcast with a video track, and an audio one with `audio`.
 	async fn live(origin: &moq_net::origin::Producer, audio: bool) -> Live {
-		let publication = origin
-			.route("room/guest", moq_net::origin::RouteOptions::hidden())
-			.unwrap();
+		live_at(origin, "room/guest", audio).await
+	}
+
+	/// A live broadcast at `path`, as [`live`] publishes one.
+	async fn live_at(origin: &moq_net::origin::Producer, path: &str, audio: bool) -> Live {
+		let publication = origin.route(path, moq_net::origin::RouteOptions::hidden()).unwrap();
 		let mut broadcast = publication.broadcast().clone();
 		let catalog = moq_mux::catalog::Producer::new(&mut broadcast, Default::default()).unwrap();
 		let (video, encoder) = rendition(&broadcast, catalog.timebase()).await;
@@ -3298,7 +3314,6 @@ mod tests {
 				path: "room/cam".into(),
 				instance: None,
 				offset,
-				sound: false,
 			};
 			collection.sources.insert("cam".into(), layer(250_000));
 			collection.validate().unwrap();
@@ -3373,7 +3388,6 @@ mod tests {
 					path: "room/logo".into(),
 					instance: None,
 					offset: 0,
-					sound: false,
 				},
 			);
 			let mut sources = Sources::new(context);
@@ -3391,7 +3405,8 @@ mod tests {
 	}
 
 	/// A broadcast without video, such as another studio's published image,
-	/// shows its still, which has no moment, so it lands on any timeline at 0.
+	/// shows its still, which has no moment, so it never stalls and lands on
+	/// any timeline at 0.
 	#[tokio::test]
 	async fn a_broadcast_shows_a_still() {
 		local(async {
@@ -3408,6 +3423,8 @@ mod tests {
 			})
 			.await;
 			assert_eq!(pixels, [255, 0, 0, 255]);
+			// It sends nothing until it changes, which is no stall.
+			assert_eq!(feed.stalled(kio::clock::now() + STALL * 3), None);
 			let landing = feed.lands(Duration::from_secs(5), kio::clock::now()).unwrap();
 			assert_eq!(landing.offset, 0);
 			assert!(landing.instance.is_some());
@@ -3415,32 +3432,39 @@ mod tests {
 		.await;
 	}
 
-	/// A layer whose sound plays nowhere has no strip, so it never fetches
-	/// its broadcast's sound.
+	/// A layer fetches its broadcast's sound only while a mix plays it, and
+	/// that starting or stopping never opens the layer again.
 	#[tokio::test]
 	async fn a_layer_fetches_only_the_sound_it_plays() {
 		local(async {
 			let dir = tempfile::tempdir().unwrap();
-			let (context, _origin) = context(dir.path());
+			let (context, origin) = context(dir.path());
+			let _live = live(&origin, false).await;
+			let cam = live_at(&origin, "room/cam", true).await;
+			let demand = cam.audio.as_ref().unwrap().demand();
 			let mut collection = collection();
-			let layer = |sound| Source::Layer {
-				clock: "guest".into(),
-				path: "room/cam".into(),
-				instance: None,
-				offset: 0,
-				sound,
-			};
-			collection.sources.insert("cam".into(), layer(false));
+			collection.sources.insert(
+				"cam".into(),
+				Source::Layer {
+					clock: "guest".into(),
+					path: "room/cam".into(),
+					instance: None,
+					offset: 0,
+				},
+			);
+			collection.audio_scenes[0].sounds.insert("cam".into());
 			let mut sources = Sources::new(context);
 			let drivers = sources.sync(&collection);
 			start(&sources, drivers).await;
-			assert!(sources.get("cam").unwrap().strip().is_none());
+			until(|| demand.wanted().is_some().then_some(())).await;
 
-			collection.sources.insert("cam".into(), layer(true));
-			let drivers = sources.sync(&collection);
-			assert_eq!(drivers.len(), 1, "opened again to play its sound");
-			start(&sources, drivers).await;
-			assert!(sources.get("cam").unwrap().strip().is_some());
+			collection.audio_scenes[0].sounds.remove("cam");
+			assert!(sources.sync(&collection).is_empty(), "opened again");
+			until(|| demand.wanted().is_none().then_some(())).await;
+
+			collection.audio_scenes[0].sounds.insert("cam".into());
+			assert!(sources.sync(&collection).is_empty(), "opened again");
+			until(|| demand.wanted().is_some().then_some(())).await;
 		})
 		.await;
 	}
@@ -3458,7 +3482,6 @@ mod tests {
 				path: path.into(),
 				instance: instance.map(|instance| instance.parse().unwrap()),
 				offset: 0,
-				sound: false,
 			};
 			collection.sources.insert("cam".into(), layer("room/cam", None));
 			let mut sources = Sources::new(context);
@@ -3548,7 +3571,8 @@ mod tests {
 
 	/// A broadcast source's offset onto a timeline puts the picture it shows
 	/// where that timeline reads when it shows it, signed either way, and
-	/// there is none before its clock anchors.
+	/// there is none before its clock anchors, or once it goes offline and
+	/// clears its picture.
 	#[tokio::test(start_paused = true)]
 	async fn a_broadcast_lands_on_a_timeline() {
 		local(async {
@@ -3588,21 +3612,17 @@ mod tests {
 			assert_eq!(
 				feed.lands(Duration::from_secs(5), later),
 				Some(Landing {
-					instance: instance.clone(),
+					instance,
 					offset: 3_990_000
 				})
 			);
 
-			// Offline, its last picture stays, so it lands where it last did.
+			// Offline, it clears its picture, so it lands nowhere.
 			drop(live);
 			until(|| (feed.status() == Status::Offline).then_some(())).await;
-			assert_eq!(
-				feed.lands(Duration::from_secs(6), later + Duration::from_secs(1)),
-				Some(Landing {
-					instance,
-					offset: 3_990_000
-				})
-			);
+			let taken = feed.take().unwrap();
+			assert!(taken.cleared, "held its last picture");
+			assert_eq!(feed.lands(Duration::from_secs(6), later + Duration::from_secs(1)), None);
 		})
 		.await;
 	}
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 872f345..7d62abc 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -819,7 +819,7 @@ impl Program {
 
 	/// Publish the composition of what `state` drew on program at `at` on
 	/// the media clock, at `now`: the program, and each source published
-	/// independently, a broadcast source once it has shown anything, where
+	/// independently, a broadcast source while it shows its stream, where
 	/// what it showed lands on the program's clock.
 	fn compose(&self, state: &State, at: Duration, now: Instant) {
 		// Past what a timestamp holds, the frame goes unstamped too.
@@ -832,8 +832,8 @@ impl Program {
 		for name in &collection.published {
 			let child = match collection.sources.get(name) {
 				Some(Source::Broadcast { path }) => {
-					// Before it ever shows, it shows nothing here either; offline
-					// after, both hold its last picture where it landed.
+					// While it shows nothing of a stream, such as offline, the
+					// studio shows nothing of it, so viewers drop it too.
 					let Some(feed) = state.sources.get(name) else { continue };
 					let Some(landing) = feed.lands(at, now) else { continue };
 					let Some(broadcast) = composed.child(name, Some(path)) else {
diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs
index 6cf2f69..3df6699 100644
--- a/rs/moq-studio/src/watch.rs
+++ b/rs/moq-studio/src/watch.rs
@@ -409,7 +409,6 @@ fn collection(composition: Option<&Composition>, size: Canvas, paths: &Paths) ->
 					path: path.to_string(),
 					instance: child.instance.clone(),
 					offset: child.offset,
-					sound: child.sound.is_some(),
 				},
 			);
 			if let Some(audio) = &child.sound {
@@ -686,7 +685,6 @@ mod tests {
 				path: "show/source/program".into(),
 				instance: None,
 				offset: 0,
-				sound: false,
 			}
 		);
 		assert_eq!(
@@ -696,7 +694,6 @@ mod tests {
 				path: "guests/alice".into(),
 				instance: Some("abc".parse().unwrap()),
 				offset: -1_500,
-				sound: true,
 			}
 		);
 		let heard = driven.heard(AudioScene::DEFAULT);
@@ -1074,7 +1071,6 @@ mod tests {
 				path: "guests/alice".into(),
 				instance: alice.instance.clone(),
 				offset: alice.offset,
-				sound: alice.sound.is_some(),
 			}
 		);
 		kio::clock::timeout(TIMEOUT, async {

From 6c47d61459784ae7795e679f9cc51382e1e43fc0 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 14:03:08 -0800
Subject: [PATCH 08/10] fix(scene): a new offset wakes a layer, and a replaced
 video track keeps its landing

A layer's offset is a watch, so playback finds its moments again when the
composition moves it, even with its queue full. A broadcast source keeps
where its stream last landed while a replacement video track has shown
nothing, so a video-only guest stays in the composition. The README's
example offset is a realistic one.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                  |  2 +-
 rs/moq-scene/src/source.rs | 58 +++++++++++++++++++++++++++-----------
 2 files changed, 42 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 24fcbae..900a6ac 100644
--- a/README.md
+++ b/README.md
@@ -985,7 +985,7 @@ format is the studio's own until hang specifies a composition:
     "alice": {
       "broadcast": "../guests/alice/camera.hang",
       "instance": "9e4b7c21d0a3f6e85b1c2d4f7a9e0b36",
-      "offset": -1731412345678901,
+      "offset": -1500000,
       "sound": { "gain": 0.8, "pan": -0.5 }
     }
   },
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index eccb908..0327ffc 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -15,7 +15,7 @@ use std::collections::{BTreeMap, BTreeSet, VecDeque};
 use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -113,6 +113,8 @@ struct Played {
 	newest: Option<moq_net::Timestamp>,
 	/// Whether it shows a still, which has no moment, rather than video.
 	still: bool,
+	/// Where this stream last landed on a timeline, as [`Feed::lands`] found.
+	landed: Option<i64>,
 }
 
 type Playback = Arc<Mutex<Played>>;
@@ -372,7 +374,8 @@ impl Sources {
 				// changing never opens their broadcast again.
 				Some(source) if source.plays_alike(&feed.source) => {
 					if let Source::Layer { offset, .. } = source {
-						feed.offset.store(*offset, Ordering::Relaxed);
+						feed.offset
+							.send_if_modified(|moved| std::mem::replace(moved, *offset) != *offset);
 					}
 					feed.source = source.clone();
 					true
@@ -540,9 +543,9 @@ pub struct Feed {
 	silent: Arc<AtomicBool>,
 	/// A broadcast source's playout clock, or the one a layer plays on.
 	clock: Option<timeline::Consumer>,
-	/// A layer's offset onto its clock, in microseconds, which its driver
-	/// reads as it plays.
-	offset: Arc<AtomicI64>,
+	/// A layer's offset onto its clock, in microseconds, which wakes its
+	/// driver as it changes.
+	offset: watch::Sender<i64>,
 	/// Whether any mix plays a layer's sound, which its driver fetches only
 	/// while one does.
 	sound: Option<watch::Sender<bool>>,
@@ -755,8 +758,10 @@ impl Feed {
 	/// Where a broadcast source's timestamps land on a timeline that reads
 	/// `at` at `now`: where what the stream online now shows lands there. A
 	/// still has no moment, so without sound to anchor it, it lands at 0.
-	/// `None` while it shows nothing of that stream, such as offline, failed,
-	/// or before its clock anchors, and for any other source.
+	/// While a new video track of the same stream has shown nothing yet, its
+	/// last picture stays, so where that stream last landed. `None` while it
+	/// shows nothing of a stream, such as offline, failed, or before its clock
+	/// anchors, and for any other source.
 	pub fn lands(&self, at: Duration, now: Instant) -> Option<Landing> {
 		if !matches!(self.source, Source::Broadcast { .. }) || self.status() != Status::Live {
 			return None;
@@ -770,7 +775,7 @@ impl Feed {
 			(Some(newest), _) => newest,
 			(None, Some(head)) => moq_net::Timestamp::try_from(head).ok()?,
 			(None, None) if played.still => return Some(Landing { instance, offset: 0 }),
-			(None, None) => return None,
+			(None, None) => return played.landed.map(|offset| Landing { instance, offset }),
 		};
 		drop(played);
 		let due = clock.due(reference)?;
@@ -781,6 +786,15 @@ impl Feed {
 			None => micros(at)?.checked_sub(micros(now.duration_since(due))?)?,
 		};
 		let offset = lands.checked_sub(micros(Duration::from(reference))?)?;
+		let mut played = self.played.lock().unwrap();
+		// Unless another stream replaced it meanwhile.
+		if played
+			.broadcast
+			.as_ref()
+			.is_some_and(|broadcast| broadcast.info().instance == instance)
+		{
+			played.landed = Some(offset);
+		}
 		Some(Landing { instance, offset })
 	}
 
@@ -833,7 +847,7 @@ pub struct Driver {
 	/// The clock of the broadcast source a layer plays on.
 	follows: Option<timeline::Consumer>,
 	/// A layer's offset onto that clock, in microseconds.
-	offset: Arc<AtomicI64>,
+	offset: watch::Receiver<i64>,
 	/// Whether any mix plays a layer's sound.
 	sound: Option<watch::Receiver<bool>>,
 }
@@ -1371,11 +1385,12 @@ impl Driver {
 			max: Some(MAX_DELAY),
 		};
 		let mut consumer = moq_video::decode::Consumer::new(broadcast, &config, name, options).await?;
+		let mut offsets = self.offset.clone();
 		let mut queue = VecDeque::<moq_video::Frame>::new();
 		let mut ended = false;
 		loop {
 			let now = kio::clock::now();
-			let offset = self.offset.load(Ordering::Relaxed);
+			let offset = *offsets.borrow_and_update();
 			// A picture moved off the clock's timeline never plays.
 			while queue
 				.front()
@@ -1410,6 +1425,8 @@ impl Driver {
 					None => ended = true,
 				},
 				() = kio::clock::sleep_until(wake.unwrap_or(now)), if wake.is_some() => {}
+				// A new offset moves every moment, so the wake is found again.
+				Ok(()) = offsets.changed() => {}
 			}
 		}
 	}
@@ -1440,13 +1457,14 @@ impl Driver {
 		options.output.layout = Some(bus.layout);
 		let mut consumer = moq_audio::decode::Consumer::new(broadcast, &config, name, options).await?;
 		let mut writer = self.writer(strip)?;
+		let mut offsets = self.offset.clone();
 
 		// Each frame waits here until its lead before it sounds.
 		let mut queue = VecDeque::<moq_audio::Frame>::new();
 		let mut ended = false;
 		loop {
 			let now = kio::clock::now();
-			let offset = self.offset.load(Ordering::Relaxed);
+			let offset = *offsets.borrow_and_update();
 			let mut write = None;
 			while let Some(frame) = queue.front() {
 				// A sound moved off the clock's timeline never plays.
@@ -1477,7 +1495,7 @@ impl Driver {
 						// One due past the longest target would hold whatever a
 						// peer stamps.
 						let now = kio::clock::now();
-						let at = shift(frame.timestamp, self.offset.load(Ordering::Relaxed));
+						let at = shift(frame.timestamp, *offsets.borrow());
 						let placed = at.and_then(|at| schedule.due(at)).is_some_and(|sounds| {
 							sounds >= now && sounds <= now + MAX_DELAY + WRITE_LEAD
 						});
@@ -1490,6 +1508,7 @@ impl Driver {
 					None => ended = true,
 				},
 				() = kio::clock::sleep_until(write.unwrap_or(now)), if write.is_some() => {}
+				Ok(()) = offsets.changed() => {}
 			}
 		}
 	}
@@ -2466,10 +2485,10 @@ fn open(
 		_ => (None, None),
 	};
 	let silent = Arc::<AtomicBool>::default();
-	let offset = Arc::new(AtomicI64::new(match source {
+	let (offset, offsets) = watch::channel(match source {
 		Source::Layer { offset, .. } => *offset,
 		_ => 0,
-	}));
+	});
 	// Silent until a sync routes it into a mix.
 	let sound = matches!(source, Source::Layer { .. }).then(|| watch::channel(false));
 	let runs = Runs::new(Mutex::new(Latest {
@@ -2494,7 +2513,7 @@ fn open(
 			Some(schedule) => Some(schedule.clone()),
 			None => clock.as_ref().map(timeline::Producer::consume),
 		},
-		offset: offset.clone(),
+		offset,
 		sound: sound.as_ref().map(|(sender, _)| sender.clone()),
 	};
 	let driver = Driver {
@@ -2514,7 +2533,7 @@ fn open(
 		silent,
 		clock,
 		follows,
-		offset,
+		offset: offsets,
 		sound: sound.map(|(_, receiver)| receiver),
 	};
 	(feed, driver)
@@ -3516,7 +3535,8 @@ mod tests {
 	}
 
 	/// A video track replaced by one stamped earlier starts its own delay over,
-	/// rather than showing every picture on arrival against the old track's.
+	/// rather than showing every picture on arrival against the old track's,
+	/// and lands where the old one did until it shows a picture.
 	#[tokio::test(start_paused = true)]
 	async fn a_replacement_track_keeps_its_delay() {
 		local(async {
@@ -3533,6 +3553,7 @@ mod tests {
 			let due = until(|| clock.due(first)).await;
 			until_time(due).await;
 			assert_eq!(shown(feed).await, Duration::from(first));
+			let landed = feed.lands(Duration::from_secs(5), kio::clock::now()).unwrap();
 
 			// Its stamps sit half a second before the first track's clock reading.
 			let timebase = live.catalog.timebase();
@@ -3560,6 +3581,9 @@ mod tests {
 			assert!(moved > due, "the replacement re-anchored behind the first track");
 			until_time(arrived + VIDEO_DELAY - Duration::from_millis(1)).await;
 			assert!(feed.next_picture().is_none(), "shown before its delay");
+			// The first track's last picture stays meanwhile, so it lands
+			// where that did.
+			assert_eq!(feed.lands(Duration::ZERO, kio::clock::now()), Some(landed));
 			until_time(arrived + VIDEO_DELAY).await;
 			assert!(
 				shown(feed).await < Duration::from(first),

From 1a0107c5d2eb70bd6a04c2a0f28f490d6aea204f Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 14:45:13 -0800
Subject: [PATCH 09/10] feat(scene): the studio hears what is published
 independently

Each audio scene that reaches a published source gets a second mix, which
Listen and guests' return feeds read, with that source in at its gain,
mute, pan, and delay; the program, recordings, and published scenes still
encode the mix without it. This settles and deletes quest/m2/compose/hear.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                      |   7 +-
 quest/m2/compose/hear.md       |  31 --------
 rs/moq-scene/src/collection.rs |   3 +-
 rs/moq-scene/src/source.rs     | 130 +++++++++++++++++++++++++--------
 rs/moq-studio/src/engine.rs    |   3 +-
 rs/moq-studio/src/feed.rs      |   7 +-
 6 files changed, 113 insertions(+), 68 deletions(-)
 delete mode 100644 quest/m2/compose/hear.md

diff --git a/README.md b/README.md
index 900a6ac..991d43d 100644
--- a/README.md
+++ b/README.md
@@ -943,8 +943,11 @@ it as a broadcast of its own and place it over the program themselves, as the
   The studio publishes nothing more of it.
 
 The program leaves a published source out, wherever it or a clone of it is
-placed, and so does every audio scene's mix, guests' return feeds included.
-The studio draws it only as viewers will: over the program, in the Program
+placed, and so does every audio scene's mix the studio encodes: the
+program's audio, recordings, and published scenes. People in the studio
+still hear it as viewers do: **Listen** and guests' return feeds mix it in
+where its audio scene reaches it, at its gain, mute, pan, and delay. The
+studio draws it only as viewers will: over the program, in the Program
 panel and the program's virtual camera, and over the scene in preview, so
 both show what viewers see. It goes over every other item of its scene, and
 over the top layer, however the scene stacks it. Recordings hold the program
diff --git a/quest/m2/compose/hear.md b/quest/m2/compose/hear.md
deleted file mode 100644
index 8d6ed13..0000000
--- a/quest/m2/compose/hear.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# [M] The studio and its guests hear what is published independently
-
-## Goal
-
-A source published independently, such as a guest's camera and microphone,
-is heard where the studio's own people listen: in the audio scene **Listen**
-plays, and in every other guest's return feed, at the gain, mute, pan, and
-delay the composition gives viewers. The program's encoded audio, published
-scenes, and recordings still leave it out, since viewers mix it in from its
-own broadcast.
-
-## Plan
-
-Found while building [the composition](/quest/m2/compose/README.md): every
-audio scene's mix leaves a published source out, so a creator who publishes
-a guest independently no longer hears them on **Listen**, and the other
-guests lose them from their return feeds. That was already true of a local
-microphone published independently, where it mattered less.
-
-Recommended: route a published source into the mixes the studio plays to
-people (Listen and each return feed's mix-minus) while keeping it out of the
-mixes it encodes for viewers and recordings, rather than one mix per audio
-scene; the studio's preview then sounds as its pictures look.
-
-## Waiting
-
-- Maintainer: whether **Listen** and guests' return feeds hear published
-  sources (recommended), or only return feeds, or neither, as today. An
-  agent cannot take it: it reverses the Published independently rule that
-  every audio scene's mix leaves a published source out. Check: the answer
-  is recorded in this Plan.
diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index 572d301..328966b 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -45,7 +45,8 @@ pub struct Collection {
 	/// publishes and a broadcast source as its publisher's, and the
 	/// [composition](crate::composition) says where viewers show it over the
 	/// program and how they play its sound. The program and every audio
-	/// scene's mix leave it out. Only a broadcast or a source with a track of
+	/// scene's encoded mix leave it out, but the mix people in the studio
+	/// hear holds it ([`Sources::listened`](crate::source::Sources::listened)). Only a broadcast or a source with a track of
 	/// its own can be, and not one with its background removed, since its
 	/// track would show the background. Wherever it is placed, it takes only what every
 	/// player can reproduce, and no scene that another scene draws holds it.
diff --git a/rs/moq-scene/src/source.rs b/rs/moq-scene/src/source.rs
index 0327ffc..8d0ba4b 100644
--- a/rs/moq-scene/src/source.rs
+++ b/rs/moq-scene/src/source.rs
@@ -313,8 +313,12 @@ impl Mixed {
 pub struct Sources {
 	context: Context,
 	feeds: BTreeMap<String, Feed>,
-	/// Each audio scene's mix, by its name.
+	/// Each audio scene's mix, by its name, which leaves out the sources
+	/// published independently.
 	mixes: BTreeMap<String, Mix>,
+	/// The mix people in the studio hear of each audio scene that reaches a
+	/// source published independently, by its name: its mix with those in.
+	listened: BTreeMap<String, Mix>,
 	/// The sources on program, as last set.
 	on_program: BTreeSet<String>,
 }
@@ -326,6 +330,7 @@ impl Sources {
 			context,
 			feeds: BTreeMap::new(),
 			mixes: BTreeMap::new(),
+			listened: BTreeMap::new(),
 			on_program: BTreeSet::new(),
 		}
 	}
@@ -367,7 +372,7 @@ impl Sources {
 	/// replacement never plays over it. Panics on a gain, pan, or delay
 	/// [`Collection::validate`] refuses.
 	pub fn sync(&mut self, collection: &Collection) -> Vec<Driver> {
-		let mixes = &self.mixes;
+		let mixes = [&self.mixes, &self.listened];
 		self.feeds.retain(|name, feed| {
 			let keep = match collection.sources.get(name) {
 				// A layer moved onto its clock anew plays on, so a guest's offset
@@ -383,7 +388,7 @@ impl Sources {
 				_ => false,
 			};
 			if !keep {
-				leave(mixes, feed);
+				leave(&mixes, feed);
 			}
 			keep
 		});
@@ -397,14 +402,7 @@ impl Sources {
 			.collect();
 		for name in orphaned {
 			let feed = self.feeds.remove(&name).expect("listed above");
-			leave(&self.mixes, &feed);
-		}
-		// A mix ends once its last handle drops, which may be a reader's.
-		self.mixes.retain(|name, _| collection.audio_scene(name).is_some());
-		for scene in &collection.audio_scenes {
-			if !self.mixes.contains_key(&scene.name) {
-				self.mixes.insert(scene.name.clone(), self.context.bus.mix());
-			}
+			leave(&[&self.mixes, &self.listened], &feed);
 		}
 		// Nested audio scenes are flattened: a mix sums every source an audio
 		// scene reaches, each once, so a sound reached two ways is not doubled.
@@ -413,6 +411,24 @@ impl Sources {
 			.iter()
 			.map(|scene| (scene.name.as_str(), collection.heard(&scene.name)))
 			.collect();
+		// A mix ends once its last handle drops, which may be a reader's. Only
+		// an audio scene reaching a published source sounds otherwise to people
+		// in the studio, so only it costs a second mix.
+		let listened = |scene: &str| {
+			heard
+				.get(scene)
+				.is_some_and(|heard| heard.iter().any(|name| collection.published.contains(*name)))
+		};
+		self.mixes.retain(|name, _| collection.audio_scene(name).is_some());
+		self.listened.retain(|name, _| listened(name));
+		for scene in &collection.audio_scenes {
+			if !self.mixes.contains_key(&scene.name) {
+				self.mixes.insert(scene.name.clone(), self.context.bus.mix());
+			}
+			if listened(&scene.name) && !self.listened.contains_key(&scene.name) {
+				self.listened.insert(scene.name.clone(), self.context.bus.mix());
+			}
+		}
 
 		let mut drivers = Vec::new();
 		// Layers last, once the broadcast sources whose clocks they play on run.
@@ -444,21 +460,16 @@ impl Sources {
 				// The bus is stereo, the one layout that refuses no pan.
 				strip.set_pan(audio.pan).expect("stereo bus pans");
 				strip.set_delay(audio.delay);
+				let reached = |scene: &str| heard.get(scene).is_some_and(|heard| heard.contains(name.as_str()));
+				// A source published independently reaches viewers by its own
+				// track, never through a mix they get, but people in the studio
+				// hear it.
+				let published = collection.published.contains(name);
 				for (scene, mix) in &self.mixes {
-					// A source published independently reaches viewers by its own
-					// track, never through a mix.
-					let routed = !collection.published.contains(name)
-						&& heard
-							.get(scene.as_str())
-							.is_some_and(|heard| heard.contains(name.as_str()));
-					if mix.routes(strip) == routed {
-						continue;
-					}
-					if routed {
-						mix.route(strip);
-					} else {
-						mix.unroute(strip);
-					}
+					route(mix, strip, !published && reached(scene));
+				}
+				for (scene, mix) in &self.listened {
+					route(mix, strip, reached(scene));
 				}
 				if let Some(sound) = &self.feeds[name].sound {
 					let heard = self.mixes.values().any(|mix| mix.routes(strip));
@@ -474,7 +485,7 @@ impl Sources {
 	/// every mix at once, as an edited source does.
 	pub fn restart(&mut self, name: &str) {
 		if let Some(feed) = self.feeds.remove(name) {
-			leave(&self.mixes, &feed);
+			leave(&[&self.mixes, &self.listened], &feed);
 		}
 	}
 
@@ -483,7 +494,7 @@ impl Sources {
 	/// and the next [`sync`](Self::sync) starts the sources again.
 	pub fn stop(&mut self) {
 		for feed in std::mem::take(&mut self.feeds).into_values() {
-			leave(&self.mixes, &feed);
+			leave(&[&self.mixes, &self.listened], &feed);
 		}
 	}
 
@@ -493,11 +504,21 @@ impl Sources {
 	}
 
 	/// The mix of the audio scene called `scene`, as the collection last
-	/// synced had it.
+	/// synced had it, which the program, recordings, and published scenes
+	/// encode: without the sources published independently, which viewers
+	/// mix in from their own broadcasts.
 	pub fn mix(&self, scene: &str) -> Option<&Mix> {
 		self.mixes.get(scene)
 	}
 
+	/// The mix people in the studio hear of the audio scene called `scene`,
+	/// such as on **Listen** or in a guest's return feed: its
+	/// [`mix`](Self::mix) with the sources published independently it
+	/// reaches in too, as viewers hear them.
+	pub fn listened(&self, scene: &str) -> Option<&Mix> {
+		self.listened.get(scene).or_else(|| self.mixes.get(scene))
+	}
+
 	/// Whether the audio scene called `scene` plays the source called `name`:
 	/// it has sound, is not muted, and the audio scene reaches it.
 	pub fn plays(&self, scene: &str, name: &str) -> bool {
@@ -516,9 +537,21 @@ impl Sources {
 
 /// Take a stopping `feed` out of every one of `mixes`, so it leaves nothing
 /// behind in them, nor plays over a replacement.
-fn leave(mixes: &BTreeMap<String, Mix>, feed: &Feed) {
+fn leave(mixes: &[&BTreeMap<String, Mix>], feed: &Feed) {
 	let Some(strip) = &feed.strip else { return };
-	for mix in mixes.values() {
+	for mix in mixes.iter().flat_map(|mixes| mixes.values()) {
+		mix.unroute(strip);
+	}
+}
+
+/// Route `strip` into `mix` or out of it.
+fn route(mix: &Mix, strip: &Strip, routed: bool) {
+	if mix.routes(strip) == routed {
+		return;
+	}
+	if routed {
+		mix.route(strip);
+	} else {
 		mix.unroute(strip);
 	}
 }
@@ -3012,6 +3045,43 @@ mod tests {
 		.await;
 	}
 
+	/// A source published independently leaves the mix the studio encodes,
+	/// but people in the studio still hear it in the mix they listen to, and
+	/// leave that too once it stops.
+	#[tokio::test]
+	async fn a_published_source_is_heard_but_not_encoded() {
+		local(async {
+			let dir = tempfile::tempdir().unwrap();
+			let (context, _origin) = context(dir.path());
+			let mut collection = collection();
+			let program = collection.program_audio().unwrap().to_string();
+			let program = program.as_str();
+			let mut sources = Sources::new(context);
+			let drivers = sources.sync(&collection);
+			start(&sources, drivers).await;
+			let strip = sources.get("guest").unwrap().strip().unwrap().clone();
+			assert!(sources.mix(program).unwrap().routes(&strip));
+			assert!(sources.listened(program).unwrap().routes(&strip), "the mix itself");
+
+			collection.published.insert("guest".into());
+			assert!(sources.sync(&collection).is_empty());
+			assert!(!sources.mix(program).unwrap().routes(&strip), "encoded");
+			let listened = sources.listened(program).unwrap().clone();
+			assert!(listened.routes(&strip), "not heard in the studio");
+
+			sources.restart("guest");
+			assert!(!listened.routes(&strip), "kept the old strip");
+
+			collection.published.clear();
+			let drivers = sources.sync(&collection);
+			start(&sources, drivers).await;
+			let strip = sources.get("guest").unwrap().strip().unwrap().clone();
+			assert!(sources.mix(program).unwrap().routes(&strip));
+			assert!(sources.listened.is_empty(), "a second mix with nothing published");
+		})
+		.await;
+	}
+
 	/// Editing a source restarts it, removing one stops it, and an untouched one
 	/// keeps running. Gain, pan, delay, and routing changes reach the strip without
 	/// restarting anything, and a source plays in every audio scene holding it
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 7d62abc..2af45ec 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -1310,7 +1310,8 @@ impl Engine {
 			if collection.audio_scene(monitor.name()).is_none() {
 				monitor.set_name(program);
 			}
-			if let Some(mix) = state.sources.mix(monitor.name()) {
+			// What viewers hear, published sources included.
+			if let Some(mix) = state.sources.listened(monitor.name()) {
 				monitor.play(mix.clone());
 			}
 		}
diff --git a/rs/moq-studio/src/feed.rs b/rs/moq-studio/src/feed.rs
index e1d6cba..cdcc7c9 100644
--- a/rs/moq-studio/src/feed.rs
+++ b/rs/moq-studio/src/feed.rs
@@ -98,7 +98,9 @@ impl Feeds {
 			renewed.contains(&(identity.clone(), feed.generation)) && !feed.task.is_finished()
 		});
 		let on_program = collection.program_audio().unwrap_or_default();
-		let program = sources.mix(on_program);
+		// As the studio hears it, so a guest hears every other guest, even one
+		// published independently.
+		let program = sources.listened(on_program);
 		for (identity, generation) in renewed {
 			if !self.feeds.contains_key(&identity) {
 				match self.open(&identity, generation) {
@@ -117,8 +119,7 @@ impl Feeds {
 			let voices: Vec<&str> = self.room.voices(collection, &identity).collect();
 			let heard = voices.iter().find(|name| {
 				let strip = sources.get(name).and_then(|source| source.strip());
-				let audible = strip.is_some_and(|strip| strip.gain() > 0.0);
-				audible && sources.plays(on_program, name)
+				strip.is_some_and(|strip| strip.gain() > 0.0 && !strip.muted() && program.routes(strip))
 			});
 			let voice = heard.or(voices.first());
 			match voice.and_then(|name| sources.get(name)?.strip()) {

From da69368619607990adb1aa43ed9e32a9aa33022b Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Thu, 12 Nov 2026 14:48:50 -0800
Subject: [PATCH 10/10] fix(studio): an audio scene's meter reads what Listen
 plays

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                      | 5 +++--
 rs/moq-studio/src/ui/levels.rs | 5 ++++-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 991d43d..39f7747 100644
--- a/README.md
+++ b/README.md
@@ -332,8 +332,9 @@ tagged `audio` and listed after the scenes.
 
 The Audio panel is a mixer. Each sound has a strip, with its gain, pan, mute,
 delay, and meter, which apply in every audio scene holding it, and a send to
-each audio scene; each audio scene has a strip with its meter and a send to
-each other audio scene. A source added from the Sources or Devices panel, or
+each audio scene; each audio scene has a strip with its meter, which reads
+it as **Listen** plays it, published sources included, and a send to each
+other audio scene. A source added from the Sources or Devices panel, or
 pasted, is sent to the audio scene on program, so it is heard at once.
 **On program** picks the audio scene the broadcast carries, and switching
 it, or editing an audio scene, never drops or repeats audio. A recording holds
diff --git a/rs/moq-studio/src/ui/levels.rs b/rs/moq-studio/src/ui/levels.rs
index 38687ef..23982b3 100644
--- a/rs/moq-studio/src/ui/levels.rs
+++ b/rs/moq-studio/src/ui/levels.rs
@@ -77,7 +77,10 @@ impl Levels {
 
 		let mut mixes = BTreeMap::new();
 		for scene in &collection.audio_scenes {
-			let Some(mix) = sources.mix(&scene.name) else { continue };
+			// As Listen plays it and viewers hear it, published sources included.
+			let Some(mix) = sources.listened(&scene.name) else {
+				continue;
+			};
 			let mut history = self.mixes.remove(&scene.name).unwrap_or_default();
 			push(&mut history, mix.level(), steps);
 			mixes.insert(scene.name.clone(), history);