From c1d6a588a45c7c6c764b3c721e033deb389d6cea Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Mon, 2 Nov 2026 19:58:16 -0800
Subject: [PATCH 01/12] chore(quest): claim quest/m0/scene-editing.md

Quest-Claim: 49e7e38ca46f1223

From 0bdab6da89e977d51f8d391b5cd7ed4863e39ee2 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Mon, 2 Nov 2026 21:58:03 -0800
Subject: [PATCH 02/12] wip: canvas edits, scene renames, and a rendition per
 canvas

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-scene/src/compositor.rs | 111 +++++++-
 rs/moq-scene/src/edit.rs       | 147 ++++++++++-
 rs/moq-studio/src/engine.rs    | 456 ++++++++++++++++++++++++---------
 rs/moq-studio/src/ui.rs        | 221 ++++++++++++++--
 4 files changed, 773 insertions(+), 162 deletions(-)

diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index a147625..8782d7d 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -145,13 +145,7 @@ impl Compositor {
 	///
 	/// Fails if the device cannot hold a texture that large.
 	pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, canvas: Canvas) -> Result<Self, Error> {
-		let limit = device.limits().max_texture_dimension_2d;
-		if canvas.width > limit || canvas.height > limit {
-			return Err(Error::Invalid(format!(
-				"canvas {}x{} exceeds this GPU's {limit}px texture limit",
-				canvas.width, canvas.height
-			)));
-		}
+		fits(device, canvas)?;
 
 		let image_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
 			label: Some("moq-scene image"),
@@ -272,6 +266,24 @@ impl Compositor {
 		self.canvas
 	}
 
+	/// Draw `canvas` from the next [`render`](Self::render) on. A new size
+	/// replaces the [`preview`](Self::preview) and [`program`](Self::program)
+	/// textures with ones of that size, blank until drawn; a fade under way
+	/// carries on.
+	///
+	/// Fails, changing nothing, if the device cannot hold a texture that large.
+	pub fn set_canvas(&mut self, canvas: Canvas) -> Result<(), Error> {
+		fits(&self.device, canvas)?;
+		if canvas.size() != self.canvas.size() {
+			let target = |label| Target::new(&self.device, &self.image_layout, &self.sampler, canvas, label);
+			self.preview = target("moq-scene preview");
+			self.program = target("moq-scene program");
+			self.incoming = target("moq-scene incoming");
+		}
+		self.canvas = canvas;
+		Ok(())
+	}
+
 	/// The scene in preview, as of the last [`render`](Self::render).
 	pub fn preview(&self) -> &wgpu::Texture {
 		&self.preview.texture
@@ -309,6 +321,17 @@ impl Compositor {
 		self.preview_scene = scene;
 	}
 
+	/// Follow the scene called `from` to its new name `to`, wherever it is: in
+	/// preview, on program, or fading out. See [`Edit::renames`](crate::Edit::renames).
+	pub fn rename(&mut self, from: &str, to: &str) {
+		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
+		for scene in [&mut self.preview_scene, &mut self.program_scene].into_iter().chain(fading) {
+			if scene.as_deref() == Some(from) {
+				*scene = Some(to.to_string());
+			}
+		}
+	}
+
 	/// Put the preview on program at once, ending any fade.
 	pub fn cut(&mut self) {
 		self.fade = None;
@@ -500,6 +523,18 @@ impl Compositor {
 	}
 }
 
+/// Refuse a canvas larger than `device` can hold as a texture.
+fn fits(device: &wgpu::Device, canvas: Canvas) -> Result<(), Error> {
+	let limit = device.limits().max_texture_dimension_2d;
+	if canvas.width > limit || canvas.height > limit {
+		return Err(Error::Invalid(format!(
+			"canvas {}x{} exceeds this GPU's {limit}px texture limit",
+			canvas.width, canvas.height
+		)));
+	}
+	Ok(())
+}
+
 /// Place `rect` (canvas pixels) in clip space.
 fn uniform(rect: Rect, canvas: Canvas, opacity: f32) -> Uniform {
 	let (width, height) = (canvas.width as f32, canvas.height as f32);
@@ -1003,6 +1038,68 @@ mod tests {
 		.await;
 	}
 
+	/// A resize draws the next frame on textures of the new size, with items
+	/// where their pixels say, and a canvas the GPU cannot hold changes nothing.
+	#[tokio::test]
+	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
+	async fn a_resize_draws_the_new_canvas() {
+		local(async {
+			let mut studio = Studio::new(collection()).await;
+			studio.compositor.set_preview(Some("blue".into()));
+			studio.compositor.cut();
+			studio.render(Instant::now());
+			let old = studio.compositor.program().clone();
+
+			let wide = Canvas {
+				width: 16,
+				..studio.collection.canvas
+			};
+			studio.collection.canvas = wide;
+			studio.compositor.set_canvas(wide).unwrap();
+			assert_ne!(studio.compositor.program(), &old, "a new texture");
+			studio.render(Instant::now());
+			let program = studio.program();
+			assert_eq!(program.len(), 16 * 8 * 4);
+			let pixel = |x: usize| -> [u8; 4] { program[x * 4..x * 4 + 4].try_into().unwrap() };
+			assert_eq!(pixel(1), BLUE);
+			assert_eq!(pixel(12), BLACK, "items keep their pixels");
+
+			let limit = studio.compositor.device.limits().max_texture_dimension_2d;
+			let huge = Canvas {
+				width: limit + 2,
+				..wide
+			};
+			assert!(matches!(studio.compositor.set_canvas(huge), Err(Error::Invalid(_))));
+			assert_eq!(studio.compositor.canvas(), wide);
+		})
+		.await;
+	}
+
+	/// A renamed scene stays in preview, on program, and in the fade under way.
+	#[tokio::test]
+	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
+	async fn a_renamed_scene_stays_where_it_is() {
+		local(async {
+			let mut studio = Studio::new(collection()).await;
+			let start = Instant::now();
+			studio.compositor.set_preview(Some("red".into()));
+			studio.compositor.cut();
+			studio.compositor.set_preview(Some("blue".into()));
+			studio.compositor.fade(Duration::from_secs(1), start);
+
+			for (from, to) in [("red", "crimson"), ("blue", "navy")] {
+				studio.collection.scenes.iter_mut().find(|scene| scene.name == from).unwrap().name = to.into();
+				studio.compositor.rename(from, to);
+			}
+			assert_eq!(studio.compositor.preview_scene(), Some("navy"));
+			assert_eq!(studio.compositor.program_scene(), Some("navy"));
+			studio.render(start + Duration::from_millis(500));
+			let actual = pixel(&studio.program(), 1, 1);
+			assert!(near(actual, [128, 0, 127, 255]), "still fading from red: {actual:?}");
+		})
+		.await;
+	}
+
 	/// A picture the GPU cannot hold says why, rather than leaving its source
 	/// live and missing from the canvas.
 	#[tokio::test]
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index 8674538..d338c43 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -14,7 +14,7 @@ use std::collections::VecDeque;
 use serde::{Deserialize, Serialize};
 
 use crate::Error;
-use crate::collection::{Audio, Collection, Item, Layer, Scene, Source, Transition, Video};
+use crate::collection::{Audio, Canvas, Collection, Item, Layer, Scene, Source, Transition, Video};
 
 /// One part of a collection, before and after an edit.
 ///
@@ -47,7 +47,8 @@ pub enum Change {
 		after: Option<Video>,
 	},
 	/// The scene at `index` of [`Collection::scenes`]. Adding one inserts it
-	/// there, shifting the later ones back.
+	/// there, shifting the later ones back, and replacing one with another
+	/// name renames it.
 	Scene {
 		index: usize,
 		#[serde(default, skip_serializing_if = "Option::is_none")]
@@ -67,6 +68,8 @@ pub enum Change {
 	},
 	/// [`Collection::transition`].
 	Transition { before: Transition, after: Transition },
+	/// [`Collection::canvas`].
+	Canvas { before: Canvas, after: Canvas },
 }
 
 impl Change {
@@ -108,6 +111,10 @@ impl Change {
 				before: after,
 				after: before,
 			},
+			Self::Canvas { before, after } => Self::Canvas {
+				before: after,
+				after: before,
+			},
 		}
 	}
 
@@ -120,6 +127,7 @@ impl Change {
 			Self::Scene { before, after, .. } => before == after,
 			Self::Item { before, after, .. } => before == after,
 			Self::Transition { before, after } => before == after,
+			Self::Canvas { before, after } => before == after,
 		}
 	}
 
@@ -202,6 +210,9 @@ impl Change {
 			(Self::Transition { before, after }, Self::Transition { before: b, after: a }) if after == *b => {
 				Self::Transition { before, after: *a }
 			}
+			(Self::Canvas { before, after }, Self::Canvas { before: b, after: a }) if after == *b => {
+				Self::Canvas { before, after: *a }
+			}
 			_ => return None,
 		};
 		Some(merged)
@@ -235,6 +246,13 @@ impl Change {
 				collection.transition = *after;
 				Ok(())
 			}
+			Self::Canvas { before, after } => {
+				if collection.canvas != *before {
+					return Err(conflict("the canvas changed".into()));
+				}
+				collection.canvas = *after;
+				Ok(())
+			}
 		}
 	}
 }
@@ -298,6 +316,20 @@ impl Edit {
 			changes: self.changes.iter().rev().map(Change::inverse).collect(),
 		}
 	}
+
+	/// The scenes this edit renames, as each old name and its new one, in the
+	/// order it renames them. Whatever follows a scene by name, such as the
+	/// one in preview, follows these in turn.
+	pub fn renames(&self) -> impl Iterator<Item = (&str, &str)> {
+		self.changes.iter().filter_map(|change| match change {
+			Change::Scene {
+				before: Some(before),
+				after: Some(after),
+				..
+			} if before.name != after.name => Some((before.name.as_str(), after.name.as_str())),
+			_ => None,
+		})
+	}
 }
 
 impl Collection {
@@ -431,7 +463,7 @@ impl Draft {
 		})
 	}
 
-	/// Replace the scene at `index`, such as to rename it.
+	/// Replace the scene at `index`.
 	pub fn set_scene(&mut self, index: usize, scene: Scene) -> Result<(), Error> {
 		let before = self.scene_at(index)?;
 		self.change(Change::Scene {
@@ -441,6 +473,22 @@ impl Draft {
 		})
 	}
 
+	/// Rename the scene at `index`, keeping what it shows.
+	pub fn rename_scene(&mut self, index: usize, name: impl Into<String>) -> Result<(), Error> {
+		let scene = Scene {
+			name: name.into(),
+			..self.scene_at(index)?
+		};
+		self.set_scene(index, scene)
+	}
+
+	/// Move the scene at `from` to `to`, counted after its removal.
+	pub fn move_scene(&mut self, from: usize, to: usize) -> Result<(), Error> {
+		let scene = self.scene_at(from)?;
+		self.remove_scene(from)?;
+		self.insert_scene(to, scene)
+	}
+
 	fn scene_at(&self, index: usize) -> Result<Scene, Error> {
 		let scene = self.collection.scenes.get(index).cloned();
 		scene.ok_or_else(|| conflict(format!("there is no scene {index}")))
@@ -499,6 +547,13 @@ impl Draft {
 		})
 	}
 
+	/// Set the canvas's size and frame rate. Items keep their place in canvas
+	/// pixels.
+	pub fn set_canvas(&mut self, canvas: Canvas) -> Result<(), Error> {
+		let before = self.collection.canvas;
+		self.change(Change::Canvas { before, after: canvas })
+	}
+
 	/// The edit, once the collection it leaves is valid. Changes that ended up
 	/// replacing something with itself are left out.
 	pub fn finish(mut self) -> Result<Edit, Error> {
@@ -851,6 +906,92 @@ mod tests {
 		assert_eq!(history.entries().len(), 2, "a drag back to the start is no edit");
 	}
 
+	/// A rename keeps the scene's items and place, a move keeps its name, and
+	/// the edit lists its renames in order, so two scenes can swap names
+	/// through a third.
+	#[test]
+	fn renames_and_reorders_scenes() {
+		let mut collection = collection();
+		collection.scenes.push(Scene::new("Other"));
+		let start = collection.clone();
+		let mut history = History::new();
+
+		let mut draft = collection.draft("Swap names");
+		draft.rename_scene(0, "swap").unwrap();
+		draft.rename_scene(1, "Scene").unwrap();
+		draft.rename_scene(0, "Other").unwrap();
+		let edit = draft.finish().unwrap();
+		let renames: Vec<_> = edit.renames().collect();
+		assert_eq!(renames, [("Scene", "swap"), ("Other", "Scene"), ("swap", "Other")]);
+		collection.apply(&edit).unwrap();
+		history.record(edit, None);
+		assert_eq!(collection.scenes[0].name, "Other");
+		assert_eq!(collection.scenes[0].items, start.scenes[0].items);
+
+		let mut draft = collection.draft("Move `Other` down");
+		draft.move_scene(0, 1).unwrap();
+		let edit = draft.finish().unwrap();
+		assert_eq!(edit.renames().count(), 0, "a move is no rename");
+		collection.apply(&edit).unwrap();
+		history.record(edit, None);
+		let names: Vec<_> = collection.scenes.iter().map(|scene| scene.name.as_str()).collect();
+		assert_eq!(names, ["Scene", "Other"]);
+		assert_eq!(collection.scenes[1].items, start.scenes[0].items);
+
+		history.seek(&mut collection, 0).unwrap();
+		assert_eq!(collection, start);
+
+		// Names stay unique and non-empty.
+		for name in ["Other", ""] {
+			let mut draft = collection.draft("Rename");
+			draft.rename_scene(0, name).unwrap();
+			assert!(matches!(draft.finish(), Err(Error::Invalid(_))), "{name:?}");
+		}
+	}
+
+	/// The canvas and the transition are edits like any other: a drag of one
+	/// undoes as one step, and a canvas the encoder cannot take is refused.
+	#[test]
+	fn the_canvas_and_transition_undo() {
+		let mut collection = collection();
+		let start = collection.clone();
+		let mut history = History::new();
+		for millis in [400, 500, 600] {
+			let mut draft = collection.draft("Set the fade time");
+			draft
+				.set_transition(Transition {
+					fade: std::time::Duration::from_millis(millis),
+				})
+				.unwrap();
+			commit(&mut collection, &mut history, draft, Some(1));
+		}
+		let canvas = Canvas {
+			width: 1280,
+			height: 720,
+			framerate: 60,
+		};
+		let mut draft = collection.draft("Resize the canvas");
+		draft.set_canvas(canvas).unwrap();
+		commit(&mut collection, &mut history, draft, None);
+		assert_eq!(history.entries().len(), 2);
+		assert_eq!(collection.canvas, canvas);
+		assert_eq!(collection.scenes[0].items[0].rect, Rect::fill(&start.canvas), "items keep their pixels");
+
+		history.undo(&mut collection).unwrap();
+		assert_eq!(collection.canvas, start.canvas);
+		history.undo(&mut collection).unwrap();
+		assert_eq!(collection, start);
+
+		let mut draft = collection.draft("Resize the canvas");
+		draft
+			.set_canvas(Canvas {
+				width: 1279,
+				..canvas
+			})
+			.unwrap();
+		assert!(matches!(draft.finish(), Err(Error::Invalid(_))));
+	}
+
 	#[test]
 	fn holds_at_most_the_limit() {
 		let mut collection = collection();
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index d4d466b..b05458a 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -6,7 +6,8 @@
 //! - **program** draws preview and program once per canvas frame and hands the
 //!   program to the encoder, stamped with the program clock.
 //! - **audio** reads the program bus on the same clock and publishes it.
-//! - **encode** waits for each program copy and encodes it.
+//! - **encode**: one per program rendition, which waits for each program copy
+//!   and encodes it. A new canvas size or frame rate starts a new rendition.
 //! - **source-***: one per running source, since a capture stream may not
 //!   leave the thread that opened it.
 //! - **autosave** writes the collection and its history to their files once
@@ -22,7 +23,7 @@ use anyhow::Context;
 use bytes::Bytes;
 use kio::clock::Instant;
 use moq_scene::source::{self, Driver, Sources};
-use moq_scene::{Collection, Compositor, Draft, History, wgpu};
+use moq_scene::{Canvas, Collection, Compositor, Draft, Edit, History, wgpu};
 use moq_video::render::export::{Exporter, Pending, Route};
 
 use crate::autosave::{self, Autosave};
@@ -97,7 +98,9 @@ impl State {
 	/// interaction that made it, so the steps of one drag undo together.
 	pub fn commit(&mut self, draft: Draft, gesture: Option<u64>) -> anyhow::Result<()> {
 		let edit = draft.finish()?;
-		self.collection.apply(&edit)?;
+		let mut collection = self.collection.clone();
+		collection.apply(&edit)?;
+		self.adopt(collection, std::slice::from_ref(&edit))?;
 		self.history.record(edit, gesture);
 		self.edited();
 		Ok(())
@@ -105,29 +108,60 @@ impl State {
 
 	/// Undo the newest edit, returning its label, or `None` with none left.
 	pub fn undo(&mut self) -> anyhow::Result<Option<String>> {
-		let label = self.history.undo(&mut self.collection)?.map(|edit| edit.label.clone());
-		if label.is_some() {
-			self.edited();
-		}
+		let Some(position) = self.history.position().checked_sub(1) else {
+			return Ok(None);
+		};
+		let label = self.label(position);
+		self.seek(position)?;
 		Ok(label)
 	}
 
 	/// Redo the oldest undone edit, returning its label, or `None` with none left.
 	pub fn redo(&mut self) -> anyhow::Result<Option<String>> {
-		let label = self.history.redo(&mut self.collection)?.map(|edit| edit.label.clone());
-		if label.is_some() {
-			self.edited();
-		}
-		Ok(label)
+		let position = self.history.position();
+		let Some(label) = self.label(position) else {
+			return Ok(None);
+		};
+		self.seek(position + 1)?;
+		Ok(Some(label))
+	}
+
+	fn label(&self, index: usize) -> Option<String> {
+		self.history.entries().nth(index).map(|edit| edit.label.clone())
 	}
 
 	/// Undo or redo to just after the history's `position`th entry.
 	pub fn seek(&mut self, position: usize) -> anyhow::Result<()> {
-		self.history.seek(&mut self.collection, position)?;
+		let mut history = self.history.clone();
+		let mut collection = self.collection.clone();
+		history.seek(&mut collection, position)?;
+		// What the seek did, in order: the entries it redid, or the inverse of
+		// those it undid, newest first.
+		let from = self.history.position();
+		let entries: Vec<&Edit> = self.history.entries().collect();
+		let made: Vec<Edit> = if position < from {
+			entries[position..from].iter().rev().map(|edit| edit.inverse()).collect()
+		} else {
+			entries[from..position].iter().map(|&edit| edit.clone()).collect()
+		};
+		self.adopt(collection, &made)?;
+		self.history = history;
 		self.edited();
 		Ok(())
 	}
 
+	/// Make `collection`, which `made` led to, the one drawn, once the
+	/// compositor takes its canvas. The scenes in preview and on program
+	/// follow the renames `made` holds.
+	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
+		self.compositor.set_canvas(collection.canvas)?;
+		for (from, to) in made.iter().flat_map(Edit::renames) {
+			self.compositor.rename(from, to);
+		}
+		self.collection = collection;
+		Ok(())
+	}
+
 	/// After any change to the collection or its history, which the autosave
 	/// writes once they settle.
 	fn edited(&mut self) {
@@ -142,16 +176,9 @@ impl State {
 			history,
 			dropped,
 		} = loaded;
-		anyhow::ensure!(
-			collection.canvas == self.collection.canvas,
-			"the canvas changed; restart the studio to use {}x{} at {} fps",
-			collection.canvas.width,
-			collection.canvas.height,
-			collection.canvas.framerate
-		);
-		// A scene in preview or on program that the file no longer has draws
-		// black until another is picked.
-		self.collection = collection;
+		// A scene in preview or on program that the file no longer has, such as
+		// one renamed by hand, draws black until another is picked.
+		self.adopt(collection, &[])?;
 		self.history = history;
 		self.dropped = dropped;
 		self.stale = true;
@@ -182,16 +209,32 @@ pub struct Stats {
 	pub encode_us: AtomicU64,
 	/// Whether any viewer is subscribed to the video.
 	pub watched: AtomicBool,
+	/// Whether the program is handed to an encoder now: not while on demand
+	/// and unwatched, nor while a new rendition opens.
+	pub encoding: AtomicBool,
 	/// The encoder backend, once one opened.
 	pub encoder: Mutex<Option<String>>,
-	/// Why the output stopped, if it did.
-	pub error: Mutex<Option<String>>,
+	/// Why the video stopped, if it did, until a new rendition starts.
+	video_error: Mutex<Option<String>>,
+	/// Why the audio stopped, if it did.
+	audio_error: Mutex<Option<String>>,
 }
 
 impl Stats {
-	fn fail(&self, err: impl std::fmt::Display) {
-		tracing::error!(%err, "output stopped");
-		*self.error.lock().unwrap() = Some(err.to_string());
+	/// Why the output stopped, if it did.
+	pub fn error(&self) -> Option<String> {
+		let video = self.video_error.lock().unwrap().clone();
+		video.or_else(|| self.audio_error.lock().unwrap().clone())
+	}
+
+	fn fail_video(&self, err: impl std::fmt::Display) {
+		tracing::error!(%err, "video stopped");
+		*self.video_error.lock().unwrap() = Some(format!("video: {err}"));
+	}
+
+	fn fail_audio(&self, err: impl std::fmt::Display) {
+		tracing::error!(%err, "audio stopped");
+		*self.audio_error.lock().unwrap() = Some(format!("audio: {err}"));
 	}
 }
 
@@ -218,7 +261,7 @@ impl Drop for Output {
 pub struct Engine {
 	pub state: Mutex<State>,
 	pub autosave: Autosave,
-	pub stats: Stats,
+	pub stats: Arc<Stats>,
 	/// How the stream is delivered, graded every [`health::INTERVAL`].
 	pub health: Mutex<health::Report>,
 	pub bus: moq_audio::bus::Bus,
@@ -259,10 +302,11 @@ impl Engine {
 			dropped,
 		} = loaded;
 		let canvas = collection.canvas;
+		let stats = Arc::new(Stats::default());
 
 		let (output, origin, publish) = match connect {
-			Some((client, url)) => {
-				let (output, publish) = publish(&gpu, client, url, subscribe, broadcast, canvas, on_demand).await?;
+			Some(connect) => {
+				let (output, publish) = publish(&gpu, &stats, connect, subscribe, broadcast, canvas, on_demand).await?;
 				(Some(output), None, Some(publish))
 			}
 			None => (None, Some(subscribe), None),
@@ -293,7 +337,7 @@ impl Engine {
 				edits: autosave.edits(),
 			}),
 			autosave,
-			stats: Stats::default(),
+			stats,
 			health: Mutex::default(),
 			bus,
 			output,
@@ -302,30 +346,13 @@ impl Engine {
 
 		let (video, audio, clock, publisher) = match publish {
 			Some(Publish {
-				video,
+				renditions,
+				rendition,
 				audio,
-				config,
-				exporter,
 				clock,
 				health,
 				sources: _,
-			}) => {
-				let zero_copy = exporter.route() == Route::Gpu;
-				engine.stats.zero_copy.store(zero_copy, Ordering::Relaxed);
-				// One more than the exporter's pool, for a pause behind a full pool.
-				let (frames, pending) = mpsc::sync_channel(Exporter::DEPTH + 1);
-				tokio::spawn(watch(video.demand(), engine.clone()));
-				let encoder = engine.clone();
-				let (opened, open) = tokio::sync::oneshot::channel();
-				std::thread::Builder::new()
-					.name("encode".into())
-					.spawn(move || encode(&encoder, opened, pending, video, config, zero_copy))?;
-				// Before the program clock starts the sources, so the program holds
-				// its encode session even while unwatched, and a source past the
-				// GPU's session cap is the one that fails.
-				open.await.context("the encode thread stopped")??;
-				(Some((frames, exporter)), Some(audio), Some(clock), Some(health))
-			}
+			}) => (Some((renditions, rendition)), Some(audio), Some(clock), Some(health)),
 			None => (None, None, None, None),
 		};
 
@@ -385,8 +412,6 @@ impl Engine {
 	/// What only the studio knows about its stream at `now`.
 	fn local(&self, now: Instant) -> health::Local {
 		let stats = &self.stats;
-		let watched = stats.watched.load(Ordering::Relaxed);
-		let on_demand = self.output.as_ref().is_some_and(|output| output.on_demand);
 		let stalled = {
 			let state = self.state.lock().unwrap();
 			let program = state
@@ -413,10 +438,10 @@ impl Engine {
 			rendered: stats.rendered.load(Ordering::Relaxed),
 			dropped: stats.dropped.load(Ordering::Relaxed),
 			encoded: stats.encoded.load(Ordering::Relaxed),
-			encoding: self.output.is_some() && (!on_demand || watched),
-			watched,
+			encoding: stats.encoding.load(Ordering::Relaxed),
+			watched: stats.watched.load(Ordering::Relaxed),
 			encoder: stats.encoder.lock().unwrap().clone(),
-			failed: stats.error.lock().unwrap().clone(),
+			failed: stats.error(),
 			stalled,
 		}
 	}
@@ -425,24 +450,31 @@ impl Engine {
 	/// to the encoder, stamped `epoch` past `start`: every frame, or only while
 	/// anyone watches when the output is on demand.
 	///
-	/// Drawing outlives the encoder: a failed output stops copying the program,
-	/// and the preview and program keep moving.
-	async fn run_program(
-		&self,
-		start: Instant,
-		epoch: Duration,
-		mut video: Option<(mpsc::SyncSender<Video>, Exporter)>,
-	) {
-		let canvas = self.state.lock().unwrap().collection().canvas;
-		let period = Duration::from_secs(1) / canvas.framerate;
-		let mut clock = kio::clock::interval_at(start, period);
-		clock.set_missed_tick_behavior(kio::clock::MissedTickBehavior::Skip);
+	/// A new canvas size or frame rate ends the rendition of `video` it was
+	/// drawn at and opens another, since a track never changes what it
+	/// carries. Drawing outlives the encoder: a failed output stops copying the
+	/// program, and the preview and program keep moving.
+	async fn run_program(&self, start: Instant, epoch: Duration, video: Option<(Renditions, Rendition)>) {
+		let (renditions, mut rendition) = video.unzip();
+		let mut canvas = self.state.lock().unwrap().compositor.canvas();
+		let mut clock = program_clock(start, canvas);
 		let on_demand = self.output.as_ref().is_some_and(|output| output.on_demand);
-		let mut encoding = false;
+		// One probe at a time, with the canvas it is for, since a GPU caps its
+		// encode sessions.
+		let mut probing: Option<(Canvas, std::thread::JoinHandle<anyhow::Result<Probe>>)> = None;
+		// The encode threads of renditions ended since, whose sessions the next
+		// probe waits to be closed.
+		let mut ending = Vec::new();
+		// The canvas the newest rendition, or the failure to open one, is for,
+		// so a failure is not retried until the canvas changes.
+		let mut settled = canvas;
+		if let Some(rendition) = &rendition {
+			rendition.adopted(&self.stats);
+		}
 
 		loop {
 			let tick = clock.tick().await;
-			let program = {
+			let (program, drawn) = {
 				let mut guard = self.state.lock().unwrap();
 				let state = &mut *guard;
 				if std::mem::take(&mut state.stale) {
@@ -454,30 +486,74 @@ impl Engine {
 					tracing::error!(%err, "cannot draw the canvas");
 					continue;
 				}
-				state.compositor.program().clone()
+				(state.compositor.program().clone(), state.compositor.canvas())
 			};
 			self.stats.rendered.fetch_add(1, Ordering::Relaxed);
 
-			let Some((sender, exporter)) = &mut video else { continue };
-			let wanted = !on_demand || self.stats.watched.load(Ordering::Relaxed);
-			let was = std::mem::replace(&mut encoding, wanted);
-			if !encoding {
+			if drawn != canvas {
+				if drawn.framerate != canvas.framerate {
+					clock = program_clock(tick + period(drawn), drawn);
+				}
+				canvas = drawn;
+				// Ended before the next opens, so the two never hold encode
+				// sessions at once.
+				ending.extend(rendition.take().map(Rendition::end));
+			}
+			if let Some(renditions) = &renditions {
+				// Probed beside the program clock, so drawing carries on.
+				if let Some((probed, probe)) = probing.take_if(|(_, probe)| probe.is_finished()) {
+					let probe = probe
+						.join()
+						.unwrap_or_else(|_| Err(anyhow::anyhow!("the encoder probe panicked")));
+					// One for a canvas since left is dropped unlisted.
+					if probed == canvas {
+						settled = canvas;
+						match probe.and_then(|probe| renditions.start(probe)) {
+							Ok((started, _)) => {
+								started.adopted(&self.stats);
+								rendition = Some(started);
+							}
+							Err(err) => self.stats.fail_video(format!("{err:#}")),
+						}
+					}
+				}
+				if probing.is_none() && settled != canvas {
+					let ending = std::mem::take(&mut ending);
+					match Probe::spawn(renditions.gpu.clone(), canvas, ending) {
+						Ok(probe) => probing = Some((canvas, probe)),
+						Err(err) => {
+							settled = canvas;
+							self.stats.fail_video(format!("cannot start an encoder probe: {err}"));
+						}
+					}
+				}
+			}
+
+			let watched = rendition
+				.as_ref()
+				.is_some_and(|rendition| rendition.watched.load(Ordering::Relaxed));
+			self.stats.watched.store(watched, Ordering::Relaxed);
+			let wanted = rendition.is_some() && (!on_demand || watched);
+			self.stats.encoding.store(wanted, Ordering::Relaxed);
+			let Some(current) = &mut rendition else { continue };
+			let was = std::mem::replace(&mut current.encoding, wanted);
+			if !wanted {
 				// Behind every frame already sent, so the break lands after them.
 				// A send fails only once the encoder stopped, having reported why.
-				if was && sender.send(Video::Pause).is_err() {
-					video = None;
+				if was && current.frames.send(Video::Pause).is_err() {
+					rendition = None;
 				}
 				continue;
 			}
 			let Ok(timestamp) = moq_net::Timestamp::try_from(epoch + tick.saturating_duration_since(start)) else {
 				continue;
 			};
-			match exporter.copy(&program, timestamp) {
+			match current.exporter.copy(&program, timestamp) {
 				// The pool bounds the frames in flight, so this waits only behind
 				// a pause the encoder has not reached yet.
 				Ok(Some(pending)) => {
-					if sender.send(Video::Frame(pending)).is_err() {
-						video = None;
+					if current.frames.send(Video::Frame(pending)).is_err() {
+						rendition = None;
 					}
 				}
 				Ok(None) => {
@@ -486,8 +562,8 @@ impl Engine {
 				// The canvas and the exporter share a size and format, so this is
 				// the GPU failing: the video stops, and the canvas keeps drawing.
 				Err(err) => {
-					let _ = sender.send(Video::Failed(err));
-					video = None;
+					let _ = current.frames.send(Video::Failed(err));
+					rendition = None;
 				}
 			}
 		}
@@ -524,7 +600,7 @@ impl Engine {
 			let Ok(timestamp) = timestamp else { continue };
 			let data: Vec<u8> = samples.iter().flat_map(|sample| sample.to_le_bytes()).collect();
 			if let Err(err) = publish.write(&moq_audio::Frame::new(Bytes::from(data), timestamp)) {
-				self.stats.fail(format!("audio: {err}"));
+				self.stats.fail_audio(err);
 				// Viewers see the audio fail rather than go away unfinished.
 				if let Some(producer) = producer.take() {
 					producer.abort(moq_net::StreamError::Internal.into());
@@ -536,9 +612,10 @@ impl Engine {
 
 /// The encoders behind an [`Output`], handed to their threads.
 struct Publish {
-	video: moq_video::encode::Producer,
-	config: moq_video::encode::Config,
-	exporter: Exporter,
+	/// Where the program video is published, a rendition at a time.
+	renditions: Renditions,
+	/// The rendition of the canvas the studio started with.
+	rendition: Rendition,
 	audio: moq_audio::encode::Producer,
 	/// The catalog's clock, which the codec producers write timestamps
 	/// against verbatim.
@@ -554,11 +631,11 @@ struct Publish {
 /// sources.
 async fn publish(
 	gpu: &Gpu,
-	client: moq_tokio::Client,
-	url: url::Url,
+	stats: &Arc<Stats>,
+	(client, url): (moq_tokio::Client, url::Url),
 	subscribe: moq_net::origin::Producer,
 	path: &str,
-	canvas: moq_scene::Canvas,
+	canvas: Canvas,
 	on_demand: bool,
 ) -> anyhow::Result<(Output, Publish)> {
 	let origin = moq_tokio::origin::spawn();
@@ -579,29 +656,37 @@ async fn publish(
 	let clock = catalog.clock();
 	let (echo, viewers) = health::echo(&path)?;
 
-	let mut config = moq_video::encode::Config::new(canvas.width, canvas.height, canvas.framerate());
-	// Opens a throwaway encoder now, so a machine that cannot encode the
-	// canvas fails at startup rather than once the encode thread starts. It
-	// also settles whether that encoder reads the program on the GPU.
-	let (exporter, rendition) = Exporter::new(&gpu.device, &gpu.queue, &mut config)
-		.await
-		.context("cannot encode the canvas")?;
+	// Probed now, so a machine that cannot encode the canvas fails at startup
+	// rather than once the program clock starts.
+	let probe = Probe::new(gpu, canvas).await?;
 	// Sources take the program's tier: hardware when the program found it, so a
 	// session the GPU refuses fails that source loudly instead of falling to
 	// software. When the program could not use hardware, such as NVENC beside an
 	// integrated GPU it cannot read, a source may still reach it from the CPU.
-	let kind = match &config.kind {
+	let kind = match &probe.config.kind {
 		moq_video::encode::Kind::Named(name) if name == "openh264" => moq_video::encode::Kind::Auto,
 		_ => moq_video::encode::Kind::Hardware,
 	};
 	let sources = moq_scene::publish::Publish::new(broadcast.clone(), catalog.clone(), bandwidth, kind);
-	let reserved = catalog.reserve().with_hls_hint(config.gop.duration(config.framerate));
-	// While the reservation holds, so the solicitation rides the first catalog.
+	// Held until the video and audio are listed, so the first catalog carries
+	// both and the solicitation.
+	let reserved = catalog.reserve();
 	let mut soliciting = catalog.clone();
 	let mut section = soliciting.modify()?;
 	section.echo = Some(hang::catalog::Echo::new(echo));
 	section.commit()?;
-	let video = moq_video::encode::Producer::new(broadcast.clone(), reserved, rendition)?;
+	let renditions = Renditions {
+		gpu: gpu.clone(),
+		broadcast: broadcast.clone(),
+		timebase: catalog.timebase(),
+		stats: stats.clone(),
+		runtime: tokio::runtime::Handle::current(),
+	};
+	let (rendition, opened) = renditions.start(probe)?;
+	// Before the program clock starts the sources, so the program holds its
+	// encode session even while unwatched, and a source past the GPU's session
+	// cap is the one that fails.
+	opened.await.context("the encode thread stopped")??;
 
 	let bus = moq_audio::bus::Config::default();
 	let mut input = moq_audio::encode::Input::new(bus.sample_rate, bus.layout);
@@ -610,8 +695,9 @@ async fn publish(
 	options.track = Some("audio".into());
 	options.config = moq_audio::encode::Config::from_input(moq_audio::encode::Codec::Opus, &input);
 	options.config.bitrate = Some(AUDIO_BITRATE);
-	let stats = catalog.clone();
+	let graded = catalog.clone();
 	let audio = moq_audio::encode::Producer::new(&mut broadcast, catalog, input, &options)?;
+	drop(reserved);
 
 	let epoch = moq_net::Epoch::mint();
 	publication
@@ -627,7 +713,7 @@ async fn publish(
 	tokio::spawn(log("relay stats", watching.clone().follow(reports, path.clone())));
 	let health = health::Publisher {
 		observer: hang::health::Observer::new(path.clone(), Some(epoch)),
-		catalog: stats,
+		catalog: graded,
 		clock: clock.clone(),
 		monitor: connection.monitor(),
 		feedback,
@@ -643,9 +729,8 @@ async fn publish(
 	Ok((
 		output,
 		Publish {
-			video,
-			config,
-			exporter,
+			renditions,
+			rendition,
 			audio,
 			clock,
 			health,
@@ -654,6 +739,129 @@ async fn publish(
 	))
 }
 
+/// Where a canvas's program video is published: one rendition at a time,
+/// each its own track, since a track never changes what it carries.
+#[derive(Clone)]
+struct Renditions {
+	gpu: Gpu,
+	broadcast: moq_net::broadcast::Producer,
+	/// Shared by every rendition, so each lands on the catalog's clock the same
+	/// way and a switch keeps the video in step with the audio.
+	timebase: moq_mux::catalog::Timebase<moq_scene::publish::Ext>,
+	stats: Arc<Stats>,
+	/// Where each rendition's viewers are followed.
+	runtime: tokio::runtime::Handle,
+}
+
+impl Renditions {
+	/// List `probe`'s rendition in the catalog under a new track, and start its
+	/// encode thread, which reports on the receiver once its encoder opens.
+	fn start(&self, probe: Probe) -> anyhow::Result<(Rendition, tokio::sync::oneshot::Receiver<anyhow::Result<()>>)> {
+		let Probe { exporter, config, video } = probe;
+		// Before its encode thread starts, which reports its own failure.
+		*self.stats.video_error.lock().unwrap() = None;
+		let reserved = self.timebase.reserve().with_hls_hint(config.gop.duration(config.framerate));
+		let producer = moq_video::encode::Producer::new(self.broadcast.clone(), reserved, video)?;
+		let watched = Arc::new(AtomicBool::new(false));
+		self.runtime.spawn(watch(producer.demand(), watched.clone()));
+
+		// One more than the exporter's pool, for a pause behind a full pool.
+		let (frames, pending) = mpsc::sync_channel(Exporter::DEPTH + 1);
+		let zero_copy = exporter.route() == Route::Gpu;
+		let stats = self.stats.clone();
+		let (opened, open) = tokio::sync::oneshot::channel();
+		let thread = std::thread::Builder::new()
+			.name("encode".into())
+			.spawn(move || encode(&stats, opened, pending, producer, config, zero_copy))?;
+		let rendition = Rendition {
+			exporter,
+			frames,
+			watched,
+			encoding: false,
+			thread,
+		};
+		Ok((rendition, open))
+	}
+}
+
+/// An encoder proven to take this GPU's export of a canvas, before its
+/// rendition is listed.
+struct Probe {
+	exporter: Exporter,
+	config: moq_video::encode::Config,
+	video: hang::catalog::VideoConfig,
+}
+
+impl Probe {
+	/// Open a throwaway encoder of `canvas` on what `gpu` exports, which also
+	/// settles whether the encoder reads the program on the GPU.
+	async fn new(gpu: &Gpu, canvas: Canvas) -> anyhow::Result<Self> {
+		let mut config = moq_video::encode::Config::new(canvas.width, canvas.height, canvas.framerate());
+		let (exporter, video) = Exporter::new(&gpu.device, &gpu.queue, &mut config)
+			.await
+			.with_context(|| format!("cannot encode a {}x{} canvas", canvas.width, canvas.height))?;
+		Ok(Self {
+			exporter,
+			config,
+			video,
+		})
+	}
+
+	/// [`new`](Self::new) on a thread of its own, off the program clock, once
+	/// the encode threads `ending` have closed their sessions.
+	fn spawn(
+		gpu: Gpu,
+		canvas: Canvas,
+		ending: Vec<std::thread::JoinHandle<()>>,
+	) -> std::io::Result<std::thread::JoinHandle<anyhow::Result<Self>>> {
+		std::thread::Builder::new().name("probe".into()).spawn(move || {
+			for thread in ending {
+				// One that panicked has closed its session all the same.
+				let _ = thread.join();
+			}
+			let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build()?;
+			runtime.block_on(Self::new(&gpu, canvas))
+		})
+	}
+}
+
+/// One rendition of the program video: the exporter the program clock copies
+/// into, and the encode thread behind it.
+struct Rendition {
+	exporter: Exporter,
+	frames: mpsc::SyncSender<Video>,
+	/// Whether anyone subscribes to the rendition's track.
+	watched: Arc<AtomicBool>,
+	/// Whether the program clock is handing it frames.
+	encoding: bool,
+	thread: std::thread::JoinHandle<()>,
+}
+
+impl Rendition {
+	/// Report this rendition as the program's from now on.
+	fn adopted(&self, stats: &Stats) {
+		let zero_copy = self.exporter.route() == Route::Gpu;
+		stats.zero_copy.store(zero_copy, Ordering::Relaxed);
+	}
+
+	/// Stop handing it frames, so its encode thread encodes those it holds,
+	/// finishes its track, and returns.
+	fn end(self) -> std::thread::JoinHandle<()> {
+		self.thread
+	}
+}
+
+/// How often the program is drawn at `canvas`'s frame rate, from `start`.
+fn program_clock(start: Instant, canvas: Canvas) -> kio::clock::Interval {
+	let mut clock = kio::clock::interval_at(start, period(canvas));
+	clock.set_missed_tick_behavior(kio::clock::MissedTickBehavior::Skip);
+	clock
+}
+
+fn period(canvas: Canvas) -> Duration {
+	Duration::from_secs(1) / canvas.framerate
+}
+
 /// Run a background reader, logging why it stopped.
 async fn log(what: &'static str, task: impl Future<Output = anyhow::Result<()>>) {
 	if let Err(err) = task.await {
@@ -661,19 +869,14 @@ async fn log(what: &'static str, task: impl Future<Output = anyhow::Result<()>>)
 	}
 }
 
-/// Track whether anyone watches the video, for the Output panel, and so an
-/// on-demand program is only copied and encoded while someone does.
-async fn watch(mut demand: moq_net::track::Demand, engine: Arc<Engine>) {
-	loop {
-		match demand.wanted_changed().await {
-			Ok(wanted) => engine.stats.watched.store(wanted.is_some(), Ordering::Relaxed),
-			Err(err) => {
-				engine.stats.watched.store(false, Ordering::Relaxed);
-				engine.stats.fail(format!("video: {err}"));
-				return;
-			}
-		}
+/// Follow whether anyone watches a rendition's track until the track ends,
+/// so an on-demand program is only copied and encoded while someone does.
+/// The track ends only through its encode thread, which reports why.
+async fn watch(mut demand: moq_net::track::Demand, watched: Arc<AtomicBool>) {
+	while let Ok(wanted) = demand.wanted_changed().await {
+		watched.store(wanted.is_some(), Ordering::Relaxed);
 	}
+	watched.store(false, Ordering::Relaxed);
 }
 
 /// What the program clock hands the encoder.
@@ -687,13 +890,14 @@ enum Video {
 	Failed(moq_video::Error),
 }
 
-/// Open the program's encoder, reporting how that went on `opened`, then
-/// encode program frames until the program clock stops.
+/// Open a rendition's encoder, reporting how that went on `opened`, then
+/// encode program frames until the program clock ends the rendition, and
+/// finish its track.
 ///
 /// A failure aborts the video track, so viewers see that it failed rather
 /// than a track that went away unfinished.
 fn encode(
-	engine: &Engine,
+	stats: &Stats,
 	opened: tokio::sync::oneshot::Sender<anyhow::Result<()>>,
 	video: mpsc::Receiver<Video>,
 	mut producer: moq_video::encode::Producer,
@@ -704,19 +908,21 @@ fn encode(
 		Ok(encoder) => encoder,
 		Err(err) => {
 			producer.abort(moq_net::StreamError::Internal.into());
-			let _ = opened.send(Err(anyhow::Error::new(err).context("video encoder")));
+			let err = anyhow::Error::new(err).context("video encoder");
+			stats.fail_video(format!("{err:#}"));
+			let _ = opened.send(Err(err));
 			return;
 		}
 	};
-	*engine.stats.encoder.lock().unwrap() = Some(encoder.name().to_string());
+	*stats.encoder.lock().unwrap() = Some(encoder.name().to_string());
 	let _ = opened.send(Ok(()));
 
-	let result = encode_frames(&engine.stats, video, &mut producer, &mut encoder, zero_copy).and_then(|()| {
+	let result = encode_frames(stats, video, &mut producer, &mut encoder, zero_copy).and_then(|()| {
 		producer.finish()?;
 		Ok(())
 	});
 	if let Err(err) = result {
-		engine.stats.fail(format!("{err:#}"));
+		stats.fail_video(format!("{err:#}"));
 		producer.abort(moq_net::StreamError::Internal.into());
 	}
 }
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 7233fcb..d651ede 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -8,7 +8,7 @@ use anyhow::Context;
 use egui::{Color32, Ui};
 use egui_dock::{DockArea, DockState, NodeIndex, Style, TabViewer};
 use moq_scene::source::{Feed, Status};
-use moq_scene::{Clip, Collection, Draft, Filter, Item, Layer, Rect, Scene, Source, Video, wgpu};
+use moq_scene::{Canvas, Clip, Collection, Draft, Filter, Item, Layer, Rect, Scene, Source, Transition, Video, wgpu};
 
 use crate::engine::{Engine, State};
 use crate::health::{self, Verdict};
@@ -64,18 +64,13 @@ impl Studio {
 			.as_ref()
 			.context("the window is not drawn with wgpu")?;
 
-		// The compositor's textures live as long as the engine, so registering
-		// them once is enough: egui samples whatever they hold each frame.
+		// egui samples whatever the compositor's textures hold each frame, so
+		// they are registered again only when a resize replaces them.
 		let (preview, program, dropped) = {
 			let state = engine.state.lock().unwrap();
-			let mut renderer = render.renderer.write();
-			let mut register = |texture: &wgpu::Texture| {
-				let view = texture.create_view(&Default::default());
-				renderer.register_native_texture(&render.device, &view, wgpu::FilterMode::Linear)
-			};
 			(
-				register(state.compositor.preview()),
-				register(state.compositor.program()),
+				Shown::new(render, state.compositor.preview()),
+				Shown::new(render, state.compositor.program()),
 				state.dropped,
 			)
 		};
@@ -99,6 +94,8 @@ impl Studio {
 				selection: None,
 				gestures: Gestures::default(),
 				new_scene: String::new(),
+				renaming: None,
+				canvas: None,
 				new_item: None,
 				add: AddSource::default(),
 				devices: Devices::default(),
@@ -109,9 +106,16 @@ impl Studio {
 }
 
 impl eframe::App for Studio {
-	fn ui(&mut self, ui: &mut Ui, _frame: &mut eframe::Frame) {
+	fn ui(&mut self, ui: &mut Ui, frame: &mut eframe::Frame) {
+		let framerate = {
+			let state = self.panels.engine.state.lock().unwrap();
+			if let Some(render) = frame.wgpu_render_state() {
+				self.panels.preview.follow(render, state.compositor.preview());
+				self.panels.program.follow(render, state.compositor.program());
+			}
+			state.compositor.canvas().framerate
+		};
 		// Redraw at the canvas rate, so preview and program are live.
-		let framerate = self.panels.engine.state.lock().unwrap().collection().canvas.framerate;
 		ui.ctx().request_repaint_after(Duration::from_secs(1) / framerate);
 
 		self.panels.shortcuts(ui.ctx());
@@ -123,12 +127,47 @@ impl eframe::App for Studio {
 	}
 }
 
+/// A compositor texture as egui shows it.
+struct Shown {
+	id: egui::TextureId,
+	texture: wgpu::Texture,
+}
+
+impl Shown {
+	fn new(render: &eframe::egui_wgpu::RenderState, texture: &wgpu::Texture) -> Self {
+		let view = texture.create_view(&Default::default());
+		let id = render
+			.renderer
+			.write()
+			.register_native_texture(&render.device, &view, wgpu::FilterMode::Linear);
+		Self {
+			id,
+			texture: texture.clone(),
+		}
+	}
+
+	/// Show `texture` from now on, if a resize replaced the one shown.
+	fn follow(&mut self, render: &eframe::egui_wgpu::RenderState, texture: &wgpu::Texture) {
+		if self.texture == *texture {
+			return;
+		}
+		let view = texture.create_view(&Default::default());
+		render.renderer.write().update_egui_texture_from_wgpu_texture(
+			&render.device,
+			&view,
+			wgpu::FilterMode::Linear,
+			self.id,
+		);
+		self.texture = texture.clone();
+	}
+}
+
 /// What every panel draws from, plus the half-typed forms.
 struct Panels {
 	engine: Arc<Engine>,
 	runtime: tokio::runtime::Handle,
-	preview: egui::TextureId,
-	program: egui::TextureId,
+	preview: Shown,
+	program: Shown,
 	/// Whether the Items panel shows the top layer rather than the scene in
 	/// preview.
 	top: bool,
@@ -136,6 +175,11 @@ struct Panels {
 	selection: Option<Selection>,
 	gestures: Gestures,
 	new_scene: String,
+	/// The scene being renamed, by index, and the name typed so far.
+	renaming: Option<(usize, String)>,
+	/// The canvas the Output panel's form holds until it is applied, or
+	/// `None` while it shows the collection's.
+	canvas: Option<Canvas>,
 	new_item: Option<String>,
 	add: AddSource,
 	devices: Devices,
@@ -466,20 +510,33 @@ impl Panels {
 			state.compositor.preview_scene().unwrap_or("nothing")
 		));
 		drop(state);
-		picture(ui, self.preview, canvas);
+		picture(ui, self.preview.id, canvas);
 	}
 
 	fn program(&mut self, ui: &mut Ui) {
-		let mut state = self.engine.state.lock().unwrap();
+		let engine = self.engine.clone();
+		let mut state = engine.state.lock().unwrap();
 		let canvas = state.collection().canvas;
 		let fade = state.collection().transition.fade;
+		let mut result = Ok(());
 		ui.horizontal(|ui| {
 			if ui.button("Cut").clicked() {
 				state.compositor.cut();
 			}
-			if ui.button(format!("Fade ({} ms)", fade.as_millis())).clicked() {
+			if ui.button("Fade").clicked() {
 				state.compositor.fade(fade, kio::clock::Instant::now());
 			}
+			let mut millis = fade.as_millis() as u64;
+			let response = ui
+				.add(egui::DragValue::new(&mut millis).suffix(" ms"))
+				.on_hover_text("How long a fade takes");
+			let gesture = self.gestures.of(&response);
+			if response.changed() {
+				let fade = Duration::from_millis(millis);
+				result = edit(&mut state, "Set the fade time", gesture, |draft| {
+					draft.set_transition(Transition { fade })
+				});
+			}
 			ui.label(format!(
 				"Program: {}",
 				state.compositor.program_scene().unwrap_or("nothing")
@@ -489,7 +546,8 @@ impl Panels {
 			}
 		});
 		drop(state);
-		picture(ui, self.program, canvas);
+		self.check(result);
+		picture(ui, self.program.id, canvas);
 	}
 
 	fn scenes(&mut self, ui: &mut Ui) {
@@ -498,20 +556,50 @@ impl Panels {
 		let preview = state.compositor.preview_scene().map(str::to_owned);
 		let program = state.compositor.program_scene().map(str::to_owned);
 		let mut pick = None;
-		let mut remove = None;
+		let mut action = None;
+		let count = state.collection().scenes.len();
 
 		egui::ScrollArea::vertical().show(ui, |ui| {
 			for (index, scene) in state.collection().scenes.iter().enumerate() {
 				ui.horizontal(|ui| {
+					if let Some((renaming, name)) = &mut self.renaming
+						&& *renaming == index
+					{
+						let response = ui.text_edit_singleline(name);
+						if !response.has_focus() && !response.lost_focus() {
+							response.request_focus();
+						}
+						if response.lost_focus() {
+							// Escape cancels; Enter or a click away renames.
+							if !ui.input(|input| input.key_pressed(egui::Key::Escape)) {
+								action = Some(SceneAction::Rename(index, name.trim().to_string()));
+							}
+							self.renaming = None;
+						}
+						return;
+					}
 					let selected = preview.as_deref() == Some(scene.name.as_str());
-					if ui.selectable_label(selected, &scene.name).clicked() {
+					let label = ui.selectable_label(selected, &scene.name);
+					if label.clicked() {
 						pick = Some(scene.name.clone());
 					}
+					if label.double_clicked() || ui.small_button("Rename").clicked() {
+						self.renaming = Some((index, scene.name.clone()));
+					}
 					if program.as_deref() == Some(scene.name.as_str()) {
 						ui.colored_label(Color32::RED, "on program");
 					}
+					if ui.add_enabled(index > 0, egui::Button::new("Up").small()).clicked() {
+						action = Some(SceneAction::Move(index, index - 1));
+					}
+					if ui
+						.add_enabled(index + 1 < count, egui::Button::new("Down").small())
+						.clicked()
+					{
+						action = Some(SceneAction::Move(index, index + 1));
+					}
 					if ui.small_button("Remove").clicked() {
-						remove = Some((index, scene.name.clone()));
+						action = Some(SceneAction::Remove(index));
 					}
 				});
 			}
@@ -539,12 +627,35 @@ impl Panels {
 		if let Some(pick) = pick {
 			state.compositor.set_preview(Some(pick));
 		}
-		if let Some((index, name)) = remove {
-			let result = edit(&mut state, format!("Remove scene `{name}`"), None, |draft| {
+		let Some(action) = action else { return };
+		let name = state.collection().scenes[action.index()].name.clone();
+		let result = match action {
+			SceneAction::Rename(index, to) => {
+				let result = edit(&mut state, format!("Rename scene `{name}` to `{to}`"), None, |draft| {
+					draft.rename_scene(index, to.clone())
+				});
+				if result.is_ok() {
+					self.renamed(&name, &to);
+				}
+				result
+			}
+			SceneAction::Move(from, to) => edit(&mut state, format!("Reorder scene `{name}`"), None, |draft| {
+				draft.move_scene(from, to)
+			}),
+			SceneAction::Remove(index) => edit(&mut state, format!("Remove scene `{name}`"), None, |draft| {
 				draft.remove_scene(index)
-			});
-			drop(state);
-			self.check(result);
+			}),
+		};
+		drop(state);
+		self.check(result);
+	}
+
+	/// Keep a selected item of the scene renamed from `from` selected.
+	fn renamed(&mut self, from: &str, to: &str) {
+		if let Some(Selection::Item(Layer::Scene(scene), _)) = &mut self.selection
+			&& scene == from
+		{
+			*scene = to.to_string();
 		}
 	}
 
@@ -1020,6 +1131,9 @@ impl Panels {
 	}
 
 	fn output(&mut self, ui: &mut Ui) {
+		self.canvas_form(ui);
+		ui.separator();
+
 		let stats = &self.engine.stats;
 		let count = |value: &std::sync::atomic::AtomicU64| value.load(Ordering::Relaxed);
 		let millis = |value: &std::sync::atomic::AtomicU64| format!("{:.1} ms", count(value) as f64 / 1000.0);
@@ -1082,11 +1196,48 @@ impl Panels {
 			));
 			ui.end_row();
 		});
-		if let Some(error) = stats.error.lock().unwrap().as_ref() {
+		if let Some(error) = stats.error() {
 			ui.colored_label(ui.visuals().error_fg_color, error);
 		}
 	}
 
+	/// The canvas's size and frame rate, applied at once rather than as each
+	/// field changes, since a new canvas starts a new rendition.
+	fn canvas_form(&mut self, ui: &mut Ui) {
+		let engine = self.engine.clone();
+		let mut state = engine.state.lock().unwrap();
+		let current = state.collection().canvas;
+		let mut canvas = self.canvas.unwrap_or(current);
+		let mut apply = false;
+		ui.horizontal(|ui| {
+			ui.strong("Canvas");
+			ui.add(egui::DragValue::new(&mut canvas.width).range(2..=u32::MAX));
+			ui.label("x");
+			ui.add(egui::DragValue::new(&mut canvas.height).range(2..=u32::MAX));
+			ui.label("at");
+			ui.add(egui::DragValue::new(&mut canvas.framerate).range(1..=u32::MAX).suffix(" fps"));
+			let edited = canvas != current;
+			apply = ui.add_enabled(edited, egui::Button::new("Apply")).clicked();
+			if ui.add_enabled(edited, egui::Button::new("Reset")).clicked() {
+				canvas = current;
+			}
+		});
+		self.canvas = (canvas != current).then_some(canvas);
+		if !apply {
+			return;
+		}
+		let label = format!(
+			"Set the canvas to {}x{} at {} fps",
+			canvas.width, canvas.height, canvas.framerate
+		);
+		let result = edit(&mut state, label, None, |draft| draft.set_canvas(canvas));
+		if result.is_ok() {
+			self.canvas = None;
+		}
+		drop(state);
+		self.check(result);
+	}
+
 	/// How the stream reaches viewers: what is wrong and why, the uplink, each
 	/// track, and each viewer that reports.
 	fn health(&mut self, ui: &mut Ui) {
@@ -1233,6 +1384,22 @@ fn millis(duration: Duration) -> String {
 	format!("{} ms", duration.as_millis())
 }
 
+/// An edit the Scenes panel makes to the scene at an index.
+enum SceneAction {
+	Rename(usize, String),
+	/// From one index to the other, counted after the removal.
+	Move(usize, usize),
+	Remove(usize),
+}
+
+impl SceneAction {
+	fn index(&self) -> usize {
+		match self {
+			Self::Rename(index, _) | Self::Move(index, _) | Self::Remove(index) => *index,
+		}
+	}
+}
+
 /// An edit the Items panel makes.
 enum ItemAction {
 	/// Replace the item at an index, labelled, as part of a gesture.

From defa6c5e18e45bbe7eb78f2ac6af7c6d236685ae Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Mon, 2 Nov 2026 22:22:02 -0800
Subject: [PATCH 03/12] feat(studio): rename and reorder scenes, set the fade
 time, and resize the canvas live

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                      |  17 +++--
 quest/m0/README.md             |   1 -
 quest/m0/encode-control.md     |   1 -
 quest/m0/multi-canvas.md       |   4 +-
 quest/m0/scene-editing.md      |  22 ------
 rs/moq-scene/src/compositor.rs |  13 +++-
 rs/moq-scene/src/edit.rs       |  13 ++--
 rs/moq-studio/src/engine.rs    | 133 +++++++++++++++++++++++++--------
 rs/moq-studio/src/ui.rs        |   6 +-
 9 files changed, 140 insertions(+), 70 deletions(-)
 delete mode 100644 quest/m0/scene-editing.md

diff --git a/README.md b/README.md
index 36d3391..d007c77 100644
--- a/README.md
+++ b/README.md
@@ -31,15 +31,15 @@ Every panel is a tab you can drag, split, or stack.
 
 | Panel | Use it to |
 | --- | --- |
-| Preview, Program | See the scene you are editing and the one that is live. **Cut** puts the preview on program at once; **Fade** blends over the collection's fade time. |
-| Scenes | Pick the scene in preview, add one, or remove one. |
+| Preview, Program | See the scene you are editing and the one that is live. **Cut** puts the preview on program at once; **Fade** blends over the fade time set beside it. |
+| Scenes | Pick the scene in preview, and add, rename (double-click), reorder, or remove one. |
 | History | See every edit, and undo or redo back to any of them. |
 | Items | Place, show, hide, and order what the preview scene or the top layer draws, back to front. Select an item to filter or copy it. |
 | Sources | Add a source by hand, see whether each and its own track are live and where it is shown, clone one, and remove one. Select a source to filter it. |
 | Devices | List this machine's cameras, displays, windows, and audio inputs, and add one as a source. |
 | Filters | Add, order, and set the filters of the selected source or item, and copy or paste them. |
 | Audio | Set each audio source's gain and mute, and watch its meter and the program's. |
-| Output | See the broadcast path, whether the program is encoding, and the encoder's work. |
+| Output | Set the canvas size and frame rate, and see the broadcast path, whether the program is encoding, and the encoder's work. |
 | Health | See how the stream reaches viewers, track by track, and the cause of each problem. |
 
 A new source, from the Sources or Devices panel, is placed over whatever the
@@ -142,8 +142,7 @@ a hand-written file keeps its comments and layout until the next edit in the
 studio. A failed write shows in the status bar and
 is retried every second; until one succeeds, a crash loses every edit since the
 last write. To edit the file by hand while the studio runs, save it and pick
-**File > Reload**; an edit in the studio before that overwrites it. A new
-canvas size or frame rate takes a restart.
+**File > Reload**; an edit in the studio before that overwrites it.
 
 The last 100 edits are written the same way beside the scene file, as
 `show.history.toml` for `show.toml`, after the scene file, and opening the
@@ -162,6 +161,14 @@ with Opus stereo audio, under the `--broadcast` path. Timestamps come from the
 studio's own clock, so a source that stalls repeats its last picture instead of
 holding up the stream.
 
+A new canvas size or frame rate, from the Output panel, an undo, or a reload,
+takes effect live. A track never changes what it carries, so the old
+rendition's track ends and a new one is listed in its place in a catalog
+update, on the same timeline, and viewers switch to it; the video pauses while
+the new encoder opens. Items keep their place in canvas pixels. A canvas the
+encoder cannot take stops the video, saying why, until the canvas changes
+again.
+
 The program encodes whether or not anyone watches, so a viewer who arrives
 late can fetch the recent past. `--on-demand` copies and encodes the video only
 while someone watches it, which saves that work but leaves nothing from before
diff --git a/quest/m0/README.md b/quest/m0/README.md
index e39b046..cf8c44c 100644
--- a/quest/m0/README.md
+++ b/quest/m0/README.md
@@ -82,7 +82,6 @@ repository.
 - [Studio on macOS](/quest/m0/app-macos.md) - the studio runs on macOS, not only Linux
 - [Studio on Windows](/quest/m0/app-windows.md) - the studio runs on Windows, not only Linux
 - [Viewer-side composition](/quest/m0/compose/README.md) - sources as their own tracks plus a layout track, composed by viewers, with a server-composed program as the fallback
-- [Scene editing](/quest/m0/scene-editing.md) - rename and reorder scenes, and resize the canvas while live through a new rendition
 - [Broadcast sources play in sync](/quest/m0/broadcast-sync.md) - subscribed broadcasts and guests play audio and video on the publisher's timestamps, with `moq play`'s delay
 - [Wayland display and window sources](/quest/m0/wayland-sources.md) - portal-picked sources that reopen without the picker
 - [Live encode control](/quest/m0/encode-control.md) - simulcast rungs that follow the bandwidth grant, live bitrate and resolution, keyframes on request
diff --git a/quest/m0/encode-control.md b/quest/m0/encode-control.md
index 53ade6b..dfc71f6 100644
--- a/quest/m0/encode-control.md
+++ b/quest/m0/encode-control.md
@@ -26,4 +26,3 @@ track's share of the allocator.
 
 - [Simulcast rung disable](https://github.com/moq-dev/moq/blob/main/quest/m1/simulcast-rung-disable.md) - grant-driven rung disable this builds on
 - [moq-audio follows the grant](https://github.com/moq-dev/moq/blob/main/quest/m2/2848-follow-the-bandwidth-grant-in-moq-audio-instead-of.md) - the audio half
-- [Scene editing](/quest/m0/scene-editing.md) - canvas resize through a new rendition
diff --git a/quest/m0/multi-canvas.md b/quest/m0/multi-canvas.md
index c63e4eb..86c4080 100644
--- a/quest/m0/multi-canvas.md
+++ b/quest/m0/multi-canvas.md
@@ -12,7 +12,9 @@ captures or decodes once however many canvases use it.
 Each canvas publishes its own broadcast, because different content needs a
 different name. Each canvas has its own top layer, which the collection's
 `top` holds for the one canvas today. Transitions are per canvas, so a scene change cuts every
-canvas together unless the creator unlinks one.
+canvas together unless the creator unlinks one. Reuse the one canvas's resize
+path per canvas: the compositor reallocates on a new canvas, and the program
+video publishes a rendition at a time, ending one and listing the next.
 
 Benchmark source count against canvas count, including sparse reuse. Per-canvas
 cost must grow only with the sources that canvas uses, never with the whole
diff --git a/quest/m0/scene-editing.md b/quest/m0/scene-editing.md
deleted file mode 100644
index 53f6d10..0000000
--- a/quest/m0/scene-editing.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# [M] Scene editing
-
-## Goal
-
-In `moq-studio`, scenes can be renamed and reordered, and the canvas can be
-resized while live, with no restart.
-
-## Plan
-
-Decided 2026-10-26 (maintainer): a resize while publishing adds a new video
-rendition under a new track name in a catalog update, and viewers switch to
-it. A track name never changes what it means (AGENTS.md), so the old track
-ends rather than changing resolution mid-stream. The compositor reallocates
-its canvas textures and the program encoder restarts on the new size.
-
-A rename updates every reference to the scene in the collection. Reordering
-is the order of the scene file's list. Update
-`README.md`.
-
-## Related
-
-- [Multiple canvases](/quest/m0/multi-canvas.md) - canvases of different sizes at once, sharing the resize path
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 8782d7d..e4fbcf8 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -325,7 +325,10 @@ impl Compositor {
 	/// preview, on program, or fading out. See [`Edit::renames`](crate::Edit::renames).
 	pub fn rename(&mut self, from: &str, to: &str) {
 		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
-		for scene in [&mut self.preview_scene, &mut self.program_scene].into_iter().chain(fading) {
+		for scene in [&mut self.preview_scene, &mut self.program_scene]
+			.into_iter()
+			.chain(fading)
+		{
 			if scene.as_deref() == Some(from) {
 				*scene = Some(to.to_string());
 			}
@@ -1088,7 +1091,13 @@ mod tests {
 			studio.compositor.fade(Duration::from_secs(1), start);
 
 			for (from, to) in [("red", "crimson"), ("blue", "navy")] {
-				studio.collection.scenes.iter_mut().find(|scene| scene.name == from).unwrap().name = to.into();
+				studio
+					.collection
+					.scenes
+					.iter_mut()
+					.find(|scene| scene.name == from)
+					.unwrap()
+					.name = to.into();
 				studio.compositor.rename(from, to);
 			}
 			assert_eq!(studio.compositor.preview_scene(), Some("navy"));
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index d338c43..9d7a719 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -975,7 +975,11 @@ mod tests {
 		commit(&mut collection, &mut history, draft, None);
 		assert_eq!(history.entries().len(), 2);
 		assert_eq!(collection.canvas, canvas);
-		assert_eq!(collection.scenes[0].items[0].rect, Rect::fill(&start.canvas), "items keep their pixels");
+		assert_eq!(
+			collection.scenes[0].items[0].rect,
+			Rect::fill(&start.canvas),
+			"items keep their pixels"
+		);
 
 		history.undo(&mut collection).unwrap();
 		assert_eq!(collection.canvas, start.canvas);
@@ -983,12 +987,7 @@ mod tests {
 		assert_eq!(collection, start);
 
 		let mut draft = collection.draft("Resize the canvas");
-		draft
-			.set_canvas(Canvas {
-				width: 1279,
-				..canvas
-			})
-			.unwrap();
+		draft.set_canvas(Canvas { width: 1279, ..canvas }).unwrap();
 		assert!(matches!(draft.finish(), Err(Error::Invalid(_))));
 	}
 
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index b05458a..1df0886 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -140,7 +140,11 @@ impl State {
 		let from = self.history.position();
 		let entries: Vec<&Edit> = self.history.entries().collect();
 		let made: Vec<Edit> = if position < from {
-			entries[position..from].iter().rev().map(|edit| edit.inverse()).collect()
+			entries[position..from]
+				.iter()
+				.rev()
+				.map(|edit| edit.inverse())
+				.collect()
 		} else {
 			entries[from..position].iter().map(|&edit| edit.clone()).collect()
 		};
@@ -757,10 +761,17 @@ impl Renditions {
 	/// List `probe`'s rendition in the catalog under a new track, and start its
 	/// encode thread, which reports on the receiver once its encoder opens.
 	fn start(&self, probe: Probe) -> anyhow::Result<(Rendition, tokio::sync::oneshot::Receiver<anyhow::Result<()>>)> {
-		let Probe { exporter, config, video } = probe;
+		let Probe {
+			exporter,
+			config,
+			video,
+		} = probe;
 		// Before its encode thread starts, which reports its own failure.
 		*self.stats.video_error.lock().unwrap() = None;
-		let reserved = self.timebase.reserve().with_hls_hint(config.gop.duration(config.framerate));
+		let reserved = self
+			.timebase
+			.reserve()
+			.with_hls_hint(config.gop.duration(config.framerate));
 		let producer = moq_video::encode::Producer::new(self.broadcast.clone(), reserved, video)?;
 		let watched = Arc::new(AtomicBool::new(false));
 		self.runtime.spawn(watch(producer.demand(), watched.clone()));
@@ -1003,6 +1014,47 @@ mod tests {
 	/// Bounds each step, so a stall fails rather than hangs.
 	const TIMEOUT: Duration = Duration::from_secs(30);
 
+	async fn subscribe(
+		broadcast: &moq_net::broadcast::Consumer,
+		name: &str,
+		config: &hang::catalog::VideoConfig,
+	) -> moq_video::decode::Consumer {
+		let mut options = moq_video::decode::Options::new();
+		options.start = moq_video::decode::Start::Latest;
+		moq_video::decode::Consumer::new(broadcast, config, name.to_string(), options)
+			.await
+			.expect("video decoder")
+	}
+
+	/// Wait for `pictures` to show the red canvas at `size`, returning when it
+	/// is shown. The canvas is black until the color source delivers its first
+	/// picture, so this waits for the composed one rather than take the first.
+	async fn red(
+		pictures: &mut moq_video::decode::Consumer,
+		size: moq_video::Size,
+	) -> Result<moq_net::Timestamp, kio::clock::Elapsed> {
+		kio::clock::timeout(TIMEOUT, async {
+			loop {
+				let frame = match pictures.read().await.expect("decode") {
+					Some(moq_video::decode::Read::Frame(frame)) => frame,
+					Some(_) => continue,
+					None => panic!("the video ended"),
+				};
+				assert_eq!(frame.size(), size);
+				let rgba = frame.surface.to_rgba(&Default::default()).expect("rgba");
+				let center = ((size.height / 2 * size.width + size.width / 2) * 4) as usize;
+				let [r, g, b, _] = rgba.data()[center..center + 4] else {
+					unreachable!()
+				};
+				// H.264 and its 4:2:0 round trip shift a primary a little.
+				if r > 200 && g < 60 && b < 60 {
+					return frame.timestamp;
+				}
+			}
+		})
+		.await
+	}
+
 	/// The program a studio publishes reaches a relay as the picture it composed,
 	/// with its audio alongside.
 	#[tokio::test(flavor = "multi_thread")]
@@ -1070,34 +1122,10 @@ mod tests {
 		let echo = catalog.echo.as_ref().expect("the catalog solicits feedback");
 		assert_eq!(echo.path.as_str(), "studio/viewers");
 		let (video, config) = catalog.video.enabled().next().expect("a video rendition");
-		let mut options = moq_video::decode::Options::new();
-		options.start = moq_video::decode::Start::Latest;
-		let mut decoder = moq_video::decode::Consumer::new(&broadcast, config, video.clone(), options)
+		let mut pictures = subscribe(&broadcast, video, config).await;
+		red(&mut pictures, moq_video::Size::new(320, 180))
 			.await
-			.expect("video decoder");
-		// The canvas is black until the color source delivers its first
-		// picture, so wait for the composed one rather than take the first.
-		kio::clock::timeout(TIMEOUT, async {
-			loop {
-				let frame = match decoder.read().await.expect("decode") {
-					Some(moq_video::decode::Read::Frame(frame)) => frame,
-					Some(_) => continue,
-					None => panic!("the video ended"),
-				};
-				assert_eq!(frame.size(), moq_video::Size::new(320, 180));
-				let rgba = frame.surface.to_rgba(&Default::default()).expect("rgba");
-				let center = (90 * 320 + 160) * 4;
-				let [r, g, b, _] = rgba.data()[center..center + 4] else {
-					unreachable!()
-				};
-				// H.264 and its 4:2:0 round trip shift a primary a little.
-				if r > 200 && g < 60 && b < 60 {
-					return;
-				}
-			}
-		})
-		.await
-		.expect("the composed picture arrives");
+			.expect("the composed picture arrives");
 
 		// The program reaches the encoder as a GPU surface when the encoder
 		// reads one, and is read back frame by frame only when it does not.
@@ -1144,6 +1172,51 @@ mod tests {
 		.await
 		.expect("sound arrives");
 
+		// A resize while live ends the old track and lists a rendition of the
+		// new size under a new one, on the same timeline.
+		{
+			let mut state = engine.state.lock().unwrap();
+			let mut draft = state.collection().draft("Resize the canvas");
+			let canvas = moq_scene::Canvas {
+				width: 160,
+				height: 90,
+				framerate: 30,
+			};
+			draft.set_canvas(canvas).unwrap();
+			state.commit(draft, None).unwrap();
+		}
+		let ended = kio::clock::timeout(TIMEOUT, async {
+			let mut last = None;
+			while let Some(read) = pictures.read().await.expect("decode") {
+				if let moq_video::decode::Read::Frame(frame) = read {
+					last = Some(frame.timestamp);
+				}
+			}
+			last
+		})
+		.await
+		.expect("the old track ends");
+		let (resized, config) = kio::clock::timeout(TIMEOUT, async {
+			loop {
+				let catalog = catalogs.next().await.expect("catalog").expect("a catalog");
+				if let [(name, config)] = catalog.video.enabled().collect::<Vec<_>>().as_slice()
+					&& *name != video
+				{
+					return ((*name).clone(), (*config).clone());
+				}
+			}
+		})
+		.await
+		.expect("the catalog lists the new rendition alone");
+		let mut pictures = subscribe(&broadcast, &resized, &config).await;
+		let first = red(&mut pictures, moq_video::Size::new(160, 90))
+			.await
+			.expect("the resized picture arrives");
+		assert!(
+			ended.is_none_or(|ended| ended < first),
+			"the new rendition continues the old one's timeline"
+		);
+
 		// An edit, and then its undo, reach the scene file and the history
 		// beside it through the autosave the studio runs.
 		let path = dir.path().join("show.toml");
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index d651ede..9f5c127 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -1215,7 +1215,11 @@ impl Panels {
 			ui.label("x");
 			ui.add(egui::DragValue::new(&mut canvas.height).range(2..=u32::MAX));
 			ui.label("at");
-			ui.add(egui::DragValue::new(&mut canvas.framerate).range(1..=u32::MAX).suffix(" fps"));
+			ui.add(
+				egui::DragValue::new(&mut canvas.framerate)
+					.range(1..=u32::MAX)
+					.suffix(" fps"),
+			);
 			let edited = canvas != current;
 			apply = ui.add_enabled(edited, egui::Button::new("Apply")).clicked();
 			if ui.add_enabled(edited, egui::Button::new("Reset")).clicked() {

From 3e6d9e1aa41d1d55f0cd36314e3646fb087e9c34 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Mon, 2 Nov 2026 22:39:22 -0800
Subject: [PATCH 04/12] fix(studio): reopen a rendition for a canvas returned
 to mid-probe

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-studio/src/engine.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 1df0886..5c4e3af 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -469,9 +469,9 @@ impl Engine {
 		// The encode threads of renditions ended since, whose sessions the next
 		// probe waits to be closed.
 		let mut ending = Vec::new();
-		// The canvas the newest rendition, or the failure to open one, is for,
-		// so a failure is not retried until the canvas changes.
-		let mut settled = canvas;
+		// Whether the canvas drawn has its rendition, or failed to open one, so
+		// a failure is not retried until the canvas changes.
+		let mut settled = true;
 		if let Some(rendition) = &rendition {
 			rendition.adopted(&self.stats);
 		}
@@ -499,6 +499,7 @@ impl Engine {
 					clock = program_clock(tick + period(drawn), drawn);
 				}
 				canvas = drawn;
+				settled = false;
 				// Ended before the next opens, so the two never hold encode
 				// sessions at once.
 				ending.extend(rendition.take().map(Rendition::end));
@@ -511,7 +512,7 @@ impl Engine {
 						.unwrap_or_else(|_| Err(anyhow::anyhow!("the encoder probe panicked")));
 					// One for a canvas since left is dropped unlisted.
 					if probed == canvas {
-						settled = canvas;
+						settled = true;
 						match probe.and_then(|probe| renditions.start(probe)) {
 							Ok((started, _)) => {
 								started.adopted(&self.stats);
@@ -521,12 +522,12 @@ impl Engine {
 						}
 					}
 				}
-				if probing.is_none() && settled != canvas {
+				if probing.is_none() && !settled {
 					let ending = std::mem::take(&mut ending);
 					match Probe::spawn(renditions.gpu.clone(), canvas, ending) {
 						Ok(probe) => probing = Some((canvas, probe)),
 						Err(err) => {
-							settled = canvas;
+							settled = true;
 							self.stats.fail_video(format!("cannot start an encoder probe: {err}"));
 						}
 					}

From f0f01f1a3075fde96fd6cf594b7914408dce1a31 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 12:19:03 -0800
Subject: [PATCH 05/12] fix(studio): follow chained scene renames by place, and
 address review findings

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-scene/src/compositor.rs | 38 +++++++--------
 rs/moq-scene/src/edit.rs       | 86 ++++++++++++++++++++++++++--------
 rs/moq-studio/src/engine.rs    | 48 +++++++++++--------
 rs/moq-studio/src/ui.rs        |  4 +-
 4 files changed, 117 insertions(+), 59 deletions(-)

diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index e4fbcf8..488f105 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -1,7 +1,7 @@
 //! Draw scenes onto the canvas on the GPU: a preview, a program, and the fade
 //! between them.
 
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::num::NonZeroU64;
 use std::time::Duration;
 
@@ -321,16 +321,18 @@ impl Compositor {
 		self.preview_scene = scene;
 	}
 
-	/// Follow the scene called `from` to its new name `to`, wherever it is: in
-	/// preview, on program, or fading out. See [`Edit::renames`](crate::Edit::renames).
-	pub fn rename(&mut self, from: &str, to: &str) {
+	/// Follow each renamed scene to its new name, wherever it is: in preview,
+	/// on program, or fading out. `renames` maps each old name to its new one,
+	/// as [`Collection::renames`] reads them, and each scene is looked up once,
+	/// so a name one scene gave up and another took is not followed twice.
+	pub fn rename(&mut self, renames: &BTreeMap<String, String>) {
 		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
 		for scene in [&mut self.preview_scene, &mut self.program_scene]
 			.into_iter()
 			.chain(fading)
 		{
-			if scene.as_deref() == Some(from) {
-				*scene = Some(to.to_string());
+			if let Some(to) = scene.as_ref().and_then(|name| renames.get(name)) {
+				*scene = Some(to.clone());
 			}
 		}
 	}
@@ -1078,7 +1080,8 @@ mod tests {
 		.await;
 	}
 
-	/// A renamed scene stays in preview, on program, and in the fade under way.
+	/// A renamed scene stays in preview, on program, and in the fade under way,
+	/// even when another scene takes its old name in the same edit.
 	#[tokio::test]
 	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
 	async fn a_renamed_scene_stays_where_it_is() {
@@ -1090,18 +1093,15 @@ mod tests {
 			studio.compositor.set_preview(Some("blue".into()));
 			studio.compositor.fade(Duration::from_secs(1), start);
 
-			for (from, to) in [("red", "crimson"), ("blue", "navy")] {
-				studio
-					.collection
-					.scenes
-					.iter_mut()
-					.find(|scene| scene.name == from)
-					.unwrap()
-					.name = to.into();
-				studio.compositor.rename(from, to);
-			}
-			assert_eq!(studio.compositor.preview_scene(), Some("navy"));
-			assert_eq!(studio.compositor.program_scene(), Some("navy"));
+			// `blue` takes the name `red` gives up, which is followed once.
+			let mut draft = studio.collection.draft("Rename");
+			draft.rename_scene(0, "crimson").unwrap();
+			draft.rename_scene(1, "red").unwrap();
+			let edit = draft.finish().unwrap();
+			studio.compositor.rename(&studio.collection.renames(&edit));
+			studio.collection.apply(&edit).unwrap();
+			assert_eq!(studio.compositor.preview_scene(), Some("red"));
+			assert_eq!(studio.compositor.program_scene(), Some("red"));
 			studio.render(start + Duration::from_millis(500));
 			let actual = pixel(&studio.program(), 1, 1);
 			assert!(near(actual, [128, 0, 127, 255]), "still fading from red: {actual:?}");
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index 9d7a719..49cd25a 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -9,7 +9,7 @@
 //! Build an edit with a [`Draft`], which reads what each change replaces from
 //! the collection as the earlier changes left it.
 
-use std::collections::VecDeque;
+use std::collections::{BTreeMap, VecDeque};
 
 use serde::{Deserialize, Serialize};
 
@@ -316,20 +316,6 @@ impl Edit {
 			changes: self.changes.iter().rev().map(Change::inverse).collect(),
 		}
 	}
-
-	/// The scenes this edit renames, as each old name and its new one, in the
-	/// order it renames them. Whatever follows a scene by name, such as the
-	/// one in preview, follows these in turn.
-	pub fn renames(&self) -> impl Iterator<Item = (&str, &str)> {
-		self.changes.iter().filter_map(|change| match change {
-			Change::Scene {
-				before: Some(before),
-				after: Some(after),
-				..
-			} if before.name != after.name => Some((before.name.as_str(), after.name.as_str())),
-			_ => None,
-		})
-	}
 }
 
 impl Collection {
@@ -345,6 +331,40 @@ impl Collection {
 		Ok(())
 	}
 
+	/// The new name of each scene `edit` renames, by its name here, before the
+	/// edit. A scene is followed by its place in the list rather than by name,
+	/// so an edit that reuses a name it just freed, such as renaming `A` to
+	/// `B` and the old `B` to `C`, maps each scene to its own new name.
+	/// Whatever follows a scene by name, such as the one in preview, looks its
+	/// name up here once.
+	pub fn renames(&self, edit: &Edit) -> BTreeMap<String, String> {
+		// Each place's scene: its name here, or `None` for one the edit added.
+		let mut scenes: Vec<(Option<&str>, &str)> = self
+			.scenes
+			.iter()
+			.map(|scene| (Some(scene.name.as_str()), scene.name.as_str()))
+			.collect();
+		for change in &edit.changes {
+			let Change::Scene { index, before, after } = change else {
+				continue;
+			};
+			match (before, after) {
+				(None, Some(after)) if *index <= scenes.len() => scenes.insert(*index, (None, &after.name)),
+				(Some(_), None) if *index < scenes.len() => {
+					scenes.remove(*index);
+				}
+				(Some(_), Some(after)) if *index < scenes.len() => scenes[*index].1 = &after.name,
+				_ => {}
+			}
+		}
+		scenes
+			.into_iter()
+			.filter_map(|(was, now)| Some((was?, now)))
+			.filter(|(was, now)| was != now)
+			.map(|(was, now)| (was.to_string(), now.to_string()))
+			.collect()
+	}
+
 	/// Start an edit labelled `label` against this collection.
 	pub fn draft(&self, label: impl Into<String>) -> Draft {
 		Draft {
@@ -906,9 +926,16 @@ mod tests {
 		assert_eq!(history.entries().len(), 2, "a drag back to the start is no edit");
 	}
 
+	fn renamed(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
+		pairs
+			.iter()
+			.map(|(was, now)| (was.to_string(), now.to_string()))
+			.collect()
+	}
+
 	/// A rename keeps the scene's items and place, a move keeps its name, and
-	/// the edit lists its renames in order, so two scenes can swap names
-	/// through a third.
+	/// each scene maps to its own new name, even through names the edit
+	/// frees and reuses.
 	#[test]
 	fn renames_and_reorders_scenes() {
 		let mut collection = collection();
@@ -921,8 +948,8 @@ mod tests {
 		draft.rename_scene(1, "Scene").unwrap();
 		draft.rename_scene(0, "Other").unwrap();
 		let edit = draft.finish().unwrap();
-		let renames: Vec<_> = edit.renames().collect();
-		assert_eq!(renames, [("Scene", "swap"), ("Other", "Scene"), ("swap", "Other")]);
+		let renames = collection.renames(&edit);
+		assert_eq!(renames, renamed(&[("Scene", "Other"), ("Other", "Scene")]));
 		collection.apply(&edit).unwrap();
 		history.record(edit, None);
 		assert_eq!(collection.scenes[0].name, "Other");
@@ -931,7 +958,7 @@ mod tests {
 		let mut draft = collection.draft("Move `Other` down");
 		draft.move_scene(0, 1).unwrap();
 		let edit = draft.finish().unwrap();
-		assert_eq!(edit.renames().count(), 0, "a move is no rename");
+		assert!(collection.renames(&edit).is_empty(), "a move is no rename");
 		collection.apply(&edit).unwrap();
 		history.record(edit, None);
 		let names: Vec<_> = collection.scenes.iter().map(|scene| scene.name.as_str()).collect();
@@ -941,6 +968,25 @@ mod tests {
 		history.seek(&mut collection, 0).unwrap();
 		assert_eq!(collection, start);
 
+		// The second rename takes the name the first freed, so read one after
+		// the other, `Scene` would land on `Next`, the other scene.
+		let mut draft = collection.draft("Chain");
+		draft.rename_scene(0, "Other").unwrap();
+		draft.rename_scene(1, "Next").unwrap();
+		draft.insert_scene(0, Scene::new("New")).unwrap();
+		let edit = draft.finish().unwrap();
+		assert_eq!(
+			collection.renames(&edit),
+			renamed(&[("Scene", "Other"), ("Other", "Next")]),
+			"an added scene renames nothing"
+		);
+		collection.apply(&edit).unwrap();
+		assert_eq!(
+			collection.renames(&edit.inverse()),
+			renamed(&[("Other", "Scene"), ("Next", "Other")]),
+			"the undo maps each back"
+		);
+
 		// Names stay unique and non-empty.
 		for name in ["Other", ""] {
 			let mut draft = collection.draft("Rename");
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index a2cc413..9c5fc8e 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -154,13 +154,20 @@ impl State {
 		Ok(())
 	}
 
-	/// Make `collection`, which `made` led to, the one drawn, once the
-	/// compositor takes its canvas. The scenes in preview and on program
-	/// follow the renames `made` holds.
+	/// Make `collection`, which the edits `made` led to from the current one,
+	/// the one drawn, once the compositor takes its canvas. The scenes in
+	/// preview and on program follow the renames `made` holds, each edit read
+	/// against the collection it was made to.
 	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
+		let mut before = self.collection.clone();
+		let mut renames = Vec::with_capacity(made.len());
+		for edit in made {
+			renames.push(before.renames(edit));
+			before.apply(edit)?;
+		}
 		self.compositor.set_canvas(collection.canvas)?;
-		for (from, to) in made.iter().flat_map(Edit::renames) {
-			self.compositor.rename(from, to);
+		for renames in &renames {
+			self.compositor.rename(renames);
 		}
 		self.collection = collection;
 		Ok(())
@@ -228,7 +235,11 @@ impl Stats {
 	/// Why the output stopped, if it did.
 	pub fn error(&self) -> Option<String> {
 		let video = self.video_error.lock().unwrap().clone();
-		video.or_else(|| self.audio_error.lock().unwrap().clone())
+		let audio = self.audio_error.lock().unwrap().clone();
+		match (video, audio) {
+			(Some(video), Some(audio)) => Some(format!("{video}; {audio}")),
+			(video, audio) => video.or(audio),
+		}
 	}
 
 	fn fail_video(&self, err: impl std::fmt::Display) {
@@ -324,7 +335,8 @@ impl Engine {
 
 		let (output, origin, publish) = match connect {
 			Some(connect) => {
-				let (output, publish) = publish(&gpu, &stats, connect, subscribe, &broadcast, canvas, on_demand).await?;
+				let (output, publish) =
+					publish(&gpu, &stats, connect, subscribe, &broadcast, canvas, on_demand).await?;
 				(Some(output), None, Some(publish))
 			}
 			None => (None, Some(subscribe), None),
@@ -478,8 +490,8 @@ impl Engine {
 		// One probe at a time, with the canvas it is for, since a GPU caps its
 		// encode sessions.
 		let mut probing: Option<(Canvas, std::thread::JoinHandle<anyhow::Result<Probe>>)> = None;
-		// The encode threads of renditions ended since, whose sessions the next
-		// probe waits to be closed.
+		// The encode threads of renditions ended or failed since, whose
+		// sessions the next probe waits to be closed.
 		let mut ending = Vec::new();
 		// Whether the canvas drawn has its rendition, or failed to open one, so
 		// a failure is not retried until the canvas changes.
@@ -515,6 +527,7 @@ impl Engine {
 				// Ended before the next opens, so the two never hold encode
 				// sessions at once.
 				ending.extend(rendition.take().map(Rendition::end));
+				*self.stats.encoder.lock().unwrap() = None;
 			}
 			if let Some(renditions) = &renditions {
 				// Probed beside the program clock, so drawing carries on.
@@ -558,7 +571,7 @@ impl Engine {
 				// Behind every frame already sent, so the break lands after them.
 				// A send fails only once the encoder stopped, having reported why.
 				if was && current.frames.send(Video::Pause).is_err() {
-					rendition = None;
+					ending.extend(rendition.take().map(Rendition::end));
 				}
 				continue;
 			}
@@ -570,7 +583,7 @@ impl Engine {
 				// a pause the encoder has not reached yet.
 				Ok(Some(pending)) => {
 					if current.frames.send(Video::Frame(pending)).is_err() {
-						rendition = None;
+						ending.extend(rendition.take().map(Rendition::end));
 					}
 				}
 				Ok(None) => {
@@ -580,7 +593,7 @@ impl Engine {
 				// the GPU failing: the video stops, and the canvas keeps drawing.
 				Err(err) => {
 					let _ = current.frames.send(Video::Failed(err));
-					rendition = None;
+					ending.extend(rendition.take().map(Rendition::end));
 				}
 			}
 		}
@@ -1167,7 +1180,7 @@ mod tests {
 		assert_eq!(echo.path.as_str(), "studio/viewers");
 		let (video, config) = catalog.video.enabled().next().expect("a video rendition");
 		let mut pictures = subscribe(&broadcast, video, config).await;
-		red(&mut pictures, moq_video::Size::new(320, 180))
+		let shown = red(&mut pictures, moq_video::Size::new(320, 180))
 			.await
 			.expect("the composed picture arrives");
 
@@ -1230,10 +1243,10 @@ mod tests {
 			state.commit(draft, None).unwrap();
 		}
 		let ended = kio::clock::timeout(TIMEOUT, async {
-			let mut last = None;
+			let mut last = shown;
 			while let Some(read) = pictures.read().await.expect("decode") {
 				if let moq_video::decode::Read::Frame(frame) = read {
-					last = Some(frame.timestamp);
+					last = frame.timestamp;
 				}
 			}
 			last
@@ -1256,10 +1269,7 @@ mod tests {
 		let first = red(&mut pictures, moq_video::Size::new(160, 90))
 			.await
 			.expect("the resized picture arrives");
-		assert!(
-			ended.is_none_or(|ended| ended < first),
-			"the new rendition continues the old one's timeline"
-		);
+		assert!(ended < first, "the new rendition continues the old one's timeline");
 
 		// An edit, and then its undo, reach the scene file and the history
 		// beside it through the autosave the studio runs.
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index cb907fc..8235cbd 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -416,11 +416,13 @@ impl Panels {
 		}
 	}
 
-	/// Deselect an item, after an edit that may have moved any of them.
+	/// Deselect an item and drop a scene rename under way, after an edit that
+	/// may have moved any of them.
 	fn deselect_item(&mut self) {
 		if matches!(self.selection, Some(Selection::Item(..))) {
 			self.selection = None;
 		}
+		self.renaming = None;
 	}
 
 	/// The layer the Items panel shows, and new sources are placed in.

From 66c4566a97f3933026c99ed1f854cf39f4df4b42 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 16:39:29 -0800
Subject: [PATCH 06/12] fix(studio): keep a retired rendition's encoder out of
 Output

A resize clears the encoder name, but an encoder still opening for the
retired rendition could put its name back, showing it during the next
probe and for good if that probe failed. Renditions are numbered under
the encoder-name lock, and an encoder reports its name only while its
rendition is current.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-studio/src/engine.rs | 66 +++++++++++++++++++++++++++++++++----
 rs/moq-studio/src/ui.rs     |  9 +----
 2 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 23505ea..7dfdf69 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -223,15 +223,51 @@ pub struct Stats {
 	/// Whether the program is handed to an encoder now: not while on demand
 	/// and unwatched, nor while a new rendition opens.
 	pub encoding: AtomicBool,
-	/// The encoder backend, once one opened.
-	pub encoder: Mutex<Option<String>>,
+	/// The encoder backend, once the program's current rendition opened one.
+	encoder: Mutex<EncoderName>,
 	/// Why the video stopped, if it did, until a new rendition starts.
 	video_error: Mutex<Option<String>>,
 	/// Why the audio stopped, if it did.
 	audio_error: Mutex<Option<String>>,
 }
 
+/// The encoder backend the program's current rendition opened, if it has.
+#[derive(Default)]
+struct EncoderName {
+	/// Counts the program's renditions, so one a resize retired while its
+	/// encoder was still opening cannot report that encoder afterwards.
+	rendition: u64,
+	name: Option<String>,
+}
+
 impl Stats {
+	/// The encoder backend, once the program's current rendition opened one.
+	pub fn encoder(&self) -> Option<String> {
+		self.encoder.lock().unwrap().name.clone()
+	}
+
+	/// The number of the program's current rendition, which its encode thread
+	/// reports its encoder under.
+	fn rendition(&self) -> u64 {
+		self.encoder.lock().unwrap().rendition
+	}
+
+	/// Retire the current rendition, so its encoder is no longer reported, even
+	/// one that opens afterwards.
+	fn retire_encoder(&self) {
+		let mut encoder = self.encoder.lock().unwrap();
+		encoder.rendition += 1;
+		encoder.name = None;
+	}
+
+	/// Report `name` as the program's encoder, unless `rendition` was retired.
+	fn opened_encoder(&self, rendition: u64, name: &str) {
+		let mut encoder = self.encoder.lock().unwrap();
+		if encoder.rendition == rendition {
+			encoder.name = Some(name.to_string());
+		}
+	}
+
 	/// Why the output stopped, if it did.
 	pub fn error(&self) -> Option<String> {
 		let video = self.video_error.lock().unwrap().clone();
@@ -473,7 +509,7 @@ impl Engine {
 			encoded: stats.encoded.load(Ordering::Relaxed),
 			encoding: stats.encoding.load(Ordering::Relaxed),
 			watched: stats.watched.load(Ordering::Relaxed),
-			encoder: stats.encoder.lock().unwrap().clone(),
+			encoder: stats.encoder(),
 			failed: stats.error(),
 			stalled,
 		}
@@ -532,7 +568,7 @@ impl Engine {
 				// Ended before the next opens, so the two never hold encode
 				// sessions at once.
 				ending.extend(rendition.take().map(Rendition::end));
-				*self.stats.encoder.lock().unwrap() = None;
+				self.stats.retire_encoder();
 			}
 			if let Some(renditions) = &renditions {
 				// Probed beside the program clock, so drawing carries on.
@@ -815,9 +851,10 @@ impl Renditions {
 		let zero_copy = exporter.route() == Route::Gpu;
 		let stats = self.stats.clone();
 		let (opened, open) = tokio::sync::oneshot::channel();
+		let number = stats.rendition();
 		let thread = std::thread::Builder::new()
 			.name("encode".into())
-			.spawn(move || encode(&stats, opened, pending, producer, config, zero_copy))?;
+			.spawn(move || encode(&stats, number, opened, pending, producer, config, zero_copy))?;
 		let rendition = Rendition {
 			exporter,
 			frames,
@@ -981,6 +1018,7 @@ enum Video {
 /// than a track that went away unfinished.
 fn encode(
 	stats: &Stats,
+	rendition: u64,
 	opened: tokio::sync::oneshot::Sender<anyhow::Result<()>>,
 	video: mpsc::Receiver<Video>,
 	mut producer: moq_video::encode::Producer,
@@ -997,7 +1035,7 @@ fn encode(
 			return;
 		}
 	};
-	*stats.encoder.lock().unwrap() = Some(encoder.name().to_string());
+	stats.opened_encoder(rendition, encoder.name());
 	let _ = opened.send(Ok(()));
 
 	let result = encode_frames(stats, video, &mut producer, &mut encoder, zero_copy).and_then(|()| {
@@ -1114,6 +1152,20 @@ mod tests {
 	/// Bounds each step, so a stall fails rather than hangs.
 	const TIMEOUT: Duration = Duration::from_secs(30);
 
+	/// A rendition a resize retired while its encoder was still opening must
+	/// not report that encoder over the next rendition's.
+	#[test]
+	fn a_retired_rendition_reports_no_encoder() {
+		let stats = Stats::default();
+		let retired = stats.rendition();
+		stats.retire_encoder();
+		let next = stats.rendition();
+		stats.opened_encoder(retired, "old");
+		assert_eq!(stats.encoder(), None, "the retired encoder opened after the resize");
+		stats.opened_encoder(next, "new");
+		assert_eq!(stats.encoder().as_deref(), Some("new"));
+	}
+
 	async fn subscribe(
 		broadcast: &moq_net::broadcast::Consumer,
 		name: &str,
@@ -1207,7 +1259,7 @@ mod tests {
 			.await
 			.expect("the studio starts");
 		assert!(
-			engine.stats.encoder.lock().unwrap().is_some(),
+			engine.stats.encoder().is_some(),
 			"the program holds its encoder before any source opens one"
 		);
 
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 3442a61..1b9770f 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -1419,14 +1419,7 @@ impl Panels {
 			ui.label(format!("{} frames", count(&stats.dropped)));
 			ui.end_row();
 			ui.label("Encoder");
-			ui.label(
-				stats
-					.encoder
-					.lock()
-					.unwrap()
-					.clone()
-					.unwrap_or_else(|| "not open".into()),
-			);
+			ui.label(stats.encoder().unwrap_or_else(|| "not open".into()));
 			ui.end_row();
 			ui.label("Encoded");
 			ui.label(format!(

From 7e5ce9e9fd0c62a3c30513eb0333170a42cf3df1 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 16:52:29 -0800
Subject: [PATCH 07/12] fix(scene): drop a removed scene from preview and
 program, and refuse an invalid canvas

A removed scene's name stayed in preview and on program, so a scene that
later took the name, by a rename or an add, went live without a cut.
`Collection::renames` now maps each removed scene to `None`, following a
scene removed and put back unchanged as the same one moved.

`Compositor::new` and `set_canvas` now validate the canvas, so a zero
size is refused rather than reaching wgpu. The live resize test also
changes the frame rate and checks the program clock follows it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-scene/src/collection.rs |  2 +-
 rs/moq-scene/src/compositor.rs | 24 ++++++++-----
 rs/moq-scene/src/edit.rs       | 61 +++++++++++++++++++++++-----------
 rs/moq-studio/src/engine.rs    | 25 +++++++++++---
 4 files changed, 79 insertions(+), 33 deletions(-)

diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs
index 93f5aea..296ea80 100644
--- a/rs/moq-scene/src/collection.rs
+++ b/rs/moq-scene/src/collection.rs
@@ -298,7 +298,7 @@ impl Canvas {
 		moq_video::FrameRate::new(self.framerate, 1).expect("validated canvas framerate")
 	}
 
-	fn validate(&self) -> Result<(), Error> {
+	pub(crate) fn validate(&self) -> Result<(), Error> {
 		if self.width == 0 || self.height == 0 || !self.width.is_multiple_of(2) || !self.height.is_multiple_of(2) {
 			return Err(Error::Invalid(format!(
 				"canvas {}x{} must be non-zero and even",
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 3d8d79e..b034b8d 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -90,7 +90,8 @@ impl effect::Library for Library<'_> {
 impl Compositor {
 	/// A compositor drawing `canvas`-sized pictures on `device`.
 	///
-	/// Fails if the device cannot hold a texture that large.
+	/// Fails if the canvas is invalid or the device cannot hold a texture that
+	/// large.
 	pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, canvas: Canvas) -> Result<Self, Error> {
 		fits(device, canvas)?;
 
@@ -121,7 +122,8 @@ impl Compositor {
 	/// textures, and every other texture sized from the canvas, with ones of
 	/// that size, blank until drawn; a fade under way carries on.
 	///
-	/// Fails, changing nothing, if the device cannot hold a texture that large.
+	/// Fails, changing nothing, if the canvas is invalid or the device cannot
+	/// hold a texture that large.
 	pub fn set_canvas(&mut self, canvas: Canvas) -> Result<(), Error> {
 		fits(&self.device, canvas)?;
 		self.effects.set_canvas(canvas);
@@ -173,17 +175,19 @@ impl Compositor {
 	}
 
 	/// Follow each renamed scene to its new name, wherever it is: in preview,
-	/// on program, or fading out. `renames` maps each old name to its new one,
-	/// as [`Collection::renames`] reads them, and each scene is looked up once,
-	/// so a name one scene gave up and another took is not followed twice.
-	pub fn rename(&mut self, renames: &BTreeMap<String, String>) {
+	/// on program, or fading out, and drop each removed one, so a scene that
+	/// later takes its name does not go on program without a cut. `renames`
+	/// maps each old name to its new one, or `None`, as
+	/// [`Collection::renames`] reads them, and each scene is looked up once, so
+	/// a name one scene gave up and another took is not followed twice.
+	pub fn rename(&mut self, renames: &BTreeMap<String, Option<String>>) {
 		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
 		for scene in [&mut self.preview_scene, &mut self.program_scene]
 			.into_iter()
 			.chain(fading)
 		{
 			if let Some(to) = scene.as_ref().and_then(|name| renames.get(name)) {
-				*scene = Some(to.clone());
+				*scene = to.clone();
 			}
 		}
 	}
@@ -313,8 +317,10 @@ impl Compositor {
 	}
 }
 
-/// Refuse a canvas larger than `device` can hold as a texture.
+/// Refuse an invalid canvas, or one larger than `device` can hold as a
+/// texture.
 fn fits(device: &wgpu::Device, canvas: Canvas) -> Result<(), Error> {
+	canvas.validate()?;
 	let limit = device.limits().max_texture_dimension_2d;
 	if canvas.width > limit || canvas.height > limit {
 		return Err(Error::Invalid(format!(
@@ -1259,6 +1265,8 @@ mod tests {
 				..wide
 			};
 			assert!(matches!(studio.compositor.set_canvas(huge), Err(Error::Invalid(_))));
+			let empty = Canvas { width: 0, ..wide };
+			assert!(matches!(studio.compositor.set_canvas(empty), Err(Error::Invalid(_))));
 			assert_eq!(studio.compositor.canvas(), wide);
 		})
 		.await;
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index 75bf41f..7b84856 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -331,37 +331,48 @@ impl Collection {
 		Ok(())
 	}
 
-	/// The new name of each scene `edit` renames, by its name here, before the
-	/// edit. A scene is followed by its place in the list rather than by name,
-	/// so an edit that reuses a name it just freed, such as renaming `A` to
-	/// `B` and the old `B` to `C`, maps each scene to its own new name.
-	/// Whatever follows a scene by name, such as the one in preview, looks its
-	/// name up here once.
-	pub fn renames(&self, edit: &Edit) -> BTreeMap<String, String> {
+	/// What becomes of each scene `edit` renames or removes, by its name here,
+	/// before the edit: its new name, or `None` once removed. A scene is
+	/// followed by its place in the list rather than by name, so an edit that
+	/// reuses a name it just freed, such as renaming `A` to `B` and the old `B`
+	/// to `C`, maps each scene to its own new name, and a scene taking a removed
+	/// one's name is not mistaken for it. A scene removed and put back unchanged
+	/// is the same one moved. Whatever follows a scene by name, such as the one
+	/// in preview, looks its name up here once.
+	pub fn renames(&self, edit: &Edit) -> BTreeMap<String, Option<String>> {
 		// Each place's scene: its name here, or `None` for one the edit added.
 		let mut scenes: Vec<(Option<&str>, &str)> = self
 			.scenes
 			.iter()
 			.map(|scene| (Some(scene.name.as_str()), scene.name.as_str()))
 			.collect();
+		// Scenes the edit removed, with what each was, until one is put back.
+		let mut removed: Vec<(Option<&str>, &Scene)> = Vec::new();
 		for change in &edit.changes {
 			let Change::Scene { index, before, after } = change else {
 				continue;
 			};
 			match (before, after) {
-				(None, Some(after)) if *index <= scenes.len() => scenes.insert(*index, (None, &after.name)),
-				(Some(_), None) if *index < scenes.len() => {
-					scenes.remove(*index);
+				(None, Some(after)) if *index <= scenes.len() => {
+					let back = removed.iter().position(|(_, scene)| *scene == after);
+					let was = back.and_then(|back| removed.remove(back).0);
+					scenes.insert(*index, (was, &after.name));
+				}
+				(Some(before), None) if *index < scenes.len() => {
+					let (was, _) = scenes.remove(*index);
+					removed.push((was, before));
 				}
 				(Some(_), Some(after)) if *index < scenes.len() => scenes[*index].1 = &after.name,
 				_ => {}
 			}
 		}
-		scenes
+		let kept = scenes
 			.into_iter()
-			.filter_map(|(was, now)| Some((was?, now)))
-			.filter(|(was, now)| was != now)
-			.map(|(was, now)| (was.to_string(), now.to_string()))
+			.filter_map(|(was, now)| Some((was?, Some(now))))
+			.filter(|(was, now)| Some(*was) != *now);
+		let gone = removed.into_iter().filter_map(|(was, _)| Some((was?, None)));
+		kept.chain(gone)
+			.map(|(was, now)| (was.to_string(), now.map(str::to_string)))
 			.collect()
 	}
 
@@ -995,10 +1006,10 @@ mod tests {
 		assert_eq!(history.entries().len(), 2, "a drag back to the start is no edit");
 	}
 
-	fn renamed(pairs: &[(&str, &str)]) -> BTreeMap<String, String> {
+	fn renamed(pairs: &[(&str, Option<&str>)]) -> BTreeMap<String, Option<String>> {
 		pairs
 			.iter()
-			.map(|(was, now)| (was.to_string(), now.to_string()))
+			.map(|(was, now)| (was.to_string(), now.map(str::to_string)))
 			.collect()
 	}
 
@@ -1018,7 +1029,7 @@ mod tests {
 		draft.rename_scene(0, "Other").unwrap();
 		let edit = draft.finish().unwrap();
 		let renames = collection.renames(&edit);
-		assert_eq!(renames, renamed(&[("Scene", "Other"), ("Other", "Scene")]));
+		assert_eq!(renames, renamed(&[("Scene", Some("Other")), ("Other", Some("Scene"))]));
 		collection.apply(&edit).unwrap();
 		history.record(edit, None);
 		assert_eq!(collection.scenes[0].name, "Other");
@@ -1046,14 +1057,24 @@ mod tests {
 		let edit = draft.finish().unwrap();
 		assert_eq!(
 			collection.renames(&edit),
-			renamed(&[("Scene", "Other"), ("Other", "Next")]),
+			renamed(&[("Scene", Some("Other")), ("Other", Some("Next"))]),
 			"an added scene renames nothing"
 		);
 		collection.apply(&edit).unwrap();
 		assert_eq!(
 			collection.renames(&edit.inverse()),
-			renamed(&[("Other", "Scene"), ("Next", "Other")]),
-			"the undo maps each back"
+			renamed(&[("Other", Some("Scene")), ("Next", Some("Other")), ("New", None)]),
+			"the undo maps each back and removes the added scene"
+		);
+
+		// A removed scene maps to nothing, even when another takes its name.
+		let mut draft = collection.draft("Replace");
+		draft.remove_scene(1).unwrap();
+		draft.rename_scene(1, "Other").unwrap();
+		let edit = draft.finish().unwrap();
+		assert_eq!(
+			collection.renames(&edit),
+			renamed(&[("Other", None), ("Next", Some("Other"))])
 		);
 
 		// Names stay unique and non-empty.
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 7dfdf69..e06a9a1 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -156,8 +156,8 @@ impl State {
 
 	/// Make `collection`, which the edits `made` led to from the current one,
 	/// the one drawn, once the compositor takes its canvas. The scenes in
-	/// preview and on program follow the renames `made` holds, each edit read
-	/// against the collection it was made to.
+	/// preview and on program follow the renames and removals `made` holds,
+	/// each edit read against the collection it was made to.
 	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
 		let mut before = self.collection.clone();
 		let mut renames = Vec::with_capacity(made.len());
@@ -1328,14 +1328,14 @@ mod tests {
 		.expect("sound arrives");
 
 		// A resize while live ends the old track and lists a rendition of the
-		// new size under a new one, on the same timeline.
+		// new size and frame rate under a new one, on the same timeline.
 		{
 			let mut state = engine.state.lock().unwrap();
 			let mut draft = state.collection().draft("Resize the canvas");
 			let canvas = moq_scene::Canvas {
 				width: 160,
 				height: 90,
-				framerate: 30,
+				framerate: 15,
 			};
 			draft.set_canvas(canvas).unwrap();
 			state.commit(draft, None).unwrap();
@@ -1368,6 +1368,23 @@ mod tests {
 			.await
 			.expect("the resized picture arrives");
 		assert!(ended < first, "the new rendition continues the old one's timeline");
+		let next = kio::clock::timeout(TIMEOUT, async {
+			loop {
+				match pictures.read().await.expect("decode") {
+					Some(moq_video::decode::Read::Frame(frame)) => return frame.timestamp,
+					Some(_) => continue,
+					None => panic!("the video ended"),
+				}
+			}
+		})
+		.await
+		.expect("a second resized picture arrives");
+		// At least 1/15 s apart, as the old 30 fps clock would not be.
+		let gap = Duration::from(next) - Duration::from(first);
+		assert!(
+			gap > Duration::from_millis(50),
+			"the program clock follows the frame rate: {gap:?}"
+		);
 
 		// An edit, and then its undo, reach the scene file and the history
 		// beside it through the autosave the studio runs.

From 1091496dcf654041bffa205d14b669e2199dbcf9 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 16:53:59 -0800
Subject: [PATCH 08/12] fix(studio): drop scenes a reload left out from preview
 and program

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-scene/src/compositor.rs | 35 ++++++++++++++++++++++++++++------
 rs/moq-studio/src/engine.rs    |  6 ++++--
 2 files changed, 33 insertions(+), 8 deletions(-)

diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index b034b8d..6e3c535 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -181,17 +181,32 @@ impl Compositor {
 	/// [`Collection::renames`] reads them, and each scene is looked up once, so
 	/// a name one scene gave up and another took is not followed twice.
 	pub fn rename(&mut self, renames: &BTreeMap<String, Option<String>>) {
-		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
-		for scene in [&mut self.preview_scene, &mut self.program_scene]
-			.into_iter()
-			.chain(fading)
-		{
+		for scene in self.scenes() {
 			if let Some(to) = scene.as_ref().and_then(|name| renames.get(name)) {
 				*scene = to.clone();
 			}
 		}
 	}
 
+	/// Drop each scene `collection` does not have from preview, program, and a
+	/// fade under way, such as one a reloaded file left out, so a scene that
+	/// later takes its name does not go on program without a cut.
+	pub fn retain(&mut self, collection: &Collection) {
+		for scene in self.scenes() {
+			if scene.as_deref().is_some_and(|name| collection.scene(name).is_none()) {
+				*scene = None;
+			}
+		}
+	}
+
+	/// The scenes followed by name: in preview, on program, and fading out.
+	fn scenes(&mut self) -> impl Iterator<Item = &mut Option<String>> {
+		let fading = self.fade.as_mut().map(|fade| &mut fade.from);
+		[&mut self.preview_scene, &mut self.program_scene]
+			.into_iter()
+			.chain(fading)
+	}
+
 	/// Put the preview on program at once, ending any fade.
 	pub fn cut(&mut self) {
 		self.fade = None;
@@ -1273,7 +1288,8 @@ mod tests {
 	}
 
 	/// A renamed scene stays in preview, on program, and in the fade under way,
-	/// even when another scene takes its old name in the same edit.
+	/// even when another scene takes its old name in the same edit, and a scene
+	/// the collection lost leaves them.
 	#[tokio::test]
 	#[ignore = "needs a Vulkan device; run by just rs render-sw"]
 	async fn a_renamed_scene_stays_where_it_is() {
@@ -1297,6 +1313,13 @@ mod tests {
 			studio.render(start + Duration::from_millis(500));
 			let actual = pixel(&studio.program(), 1, 1);
 			assert!(near(actual, [128, 0, 127, 255]), "still fading from red: {actual:?}");
+
+			// A scene the collection no longer has, as a reload can leave, is
+			// dropped, so one that later takes its name is not drawn unasked.
+			studio.collection.scenes.retain(|scene| scene.name != "red");
+			studio.compositor.retain(&studio.collection);
+			assert_eq!(studio.compositor.preview_scene(), None);
+			assert_eq!(studio.compositor.program_scene(), None);
 		})
 		.await;
 	}
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index e06a9a1..deaa677 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -157,7 +157,8 @@ impl State {
 	/// Make `collection`, which the edits `made` led to from the current one,
 	/// the one drawn, once the compositor takes its canvas. The scenes in
 	/// preview and on program follow the renames and removals `made` holds,
-	/// each edit read against the collection it was made to.
+	/// each edit read against the collection it was made to, and any
+	/// `collection` lacks is dropped.
 	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
 		let mut before = self.collection.clone();
 		let mut renames = Vec::with_capacity(made.len());
@@ -169,6 +170,7 @@ impl State {
 		for renames in &renames {
 			self.compositor.rename(renames);
 		}
+		self.compositor.retain(&collection);
 		self.collection = collection;
 		Ok(())
 	}
@@ -188,7 +190,7 @@ impl State {
 			dropped,
 		} = loaded;
 		// A scene in preview or on program that the file no longer has, such as
-		// one renamed by hand, draws black until another is picked.
+		// one renamed by hand, leaves it until another is picked.
 		self.adopt(collection, &[])?;
 		self.history = history;
 		self.dropped = dropped;

From e424058417934750b58fd1bbd683e60da99144d2 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 17:10:07 -0800
Subject: [PATCH 09/12] Merge origin/main: build on guests (#10)

Change::entry covers the canvas change, and the texture egui shows is
Registered, since #10's Shown is the invite on screen.

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

diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index 03add69..44d6d40 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -122,7 +122,7 @@ impl Change {
 	fn entry(&self) -> Option<&str> {
 		match self {
 			Self::Source { name, .. } | Self::Audio { name, .. } | Self::Video { name, .. } => Some(name),
-			Self::Scene { .. } | Self::Item { .. } | Self::Transition { .. } => None,
+			Self::Scene { .. } | Self::Item { .. } | Self::Transition { .. } | Self::Canvas { .. } => None,
 		}
 	}
 
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 979f4a2..64eb5ed 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -67,8 +67,8 @@ impl Studio {
 		let (preview, program, dropped) = {
 			let state = engine.state.lock().unwrap();
 			(
-				Shown::new(render, state.compositor.preview()),
-				Shown::new(render, state.compositor.program()),
+				Registered::new(render, state.compositor.preview()),
+				Registered::new(render, state.compositor.program()),
 				state.dropped,
 			)
 		};
@@ -130,12 +130,12 @@ impl eframe::App for Studio {
 }
 
 /// A compositor texture as egui shows it.
-struct Shown {
+struct Registered {
 	id: egui::TextureId,
 	texture: wgpu::Texture,
 }
 
-impl Shown {
+impl Registered {
 	fn new(render: &eframe::egui_wgpu::RenderState, texture: &wgpu::Texture) -> Self {
 		let view = texture.create_view(&Default::default());
 		let id = render
@@ -168,8 +168,8 @@ impl Shown {
 struct Panels {
 	engine: Arc<Engine>,
 	runtime: tokio::runtime::Handle,
-	preview: Shown,
-	program: Shown,
+	preview: Registered,
+	program: Registered,
 	/// Whether the Items panel shows the top layer rather than the scene in
 	/// preview.
 	top: bool,

From f2da3356c67272c956f96f714c79c6539169631f Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 17:48:05 -0800
Subject: [PATCH 10/12] feat(studio): refuse removing the scene on program

An accidental Remove, or an undo of the scene's add, could put black on
air. Every edit, undo, redo, and seek now refuses, changing nothing, one
that removes the scene on program, and the Scenes panel disables its
Remove. A reload of a file without it still empties program, since
there is nothing else to show. The preview scene stays removable: it is
not on air, and picking a scene puts it in preview.

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

diff --git a/README.md b/README.md
index 04fe132..164ebde 100644
--- a/README.md
+++ b/README.md
@@ -86,7 +86,7 @@ Every panel is a tab you can drag, split, or stack.
 | Panel | Use it to |
 | --- | --- |
 | Preview, Program | See the scene you are editing and the one that is live, and drag items in the preview to place them. **Cut** puts the preview on program at once; **Fade** blends over the fade time set beside it. |
-| Scenes | Pick the scene in preview, and add, rename (double-click), reorder, or remove one. |
+| Scenes | Pick the scene in preview, and add, rename (double-click), reorder, or remove one. The scene on program cannot be removed, even by an undo, until program cuts to another. |
 | History | See every edit, and undo or redo back to any of them. |
 | Items | Place, show, hide, and order what the preview scene or the top layer draws, back to front. Select an item to filter or copy it. |
 | Sources | Add a source by hand, see whether each and its own track are live and where it is shown, clone one, and remove one. Select a source to filter it. |
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index cd7293c..58161ec 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -14,6 +14,7 @@
 //!   edits to them settle.
 //! - The UI runs on the main thread and edits [`State`] under its lock.
 
+use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, mpsc};
@@ -168,7 +169,8 @@ impl State {
 	/// the one drawn, once the compositor takes its canvas. The scenes in
 	/// preview and on program follow the renames and removals `made` holds,
 	/// each edit read against the collection it was made to, and any
-	/// `collection` lacks is dropped.
+	/// `collection` lacks is dropped. Edits that remove the scene on program
+	/// are refused, changing nothing.
 	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
 		let mut before = self.collection.clone();
 		let mut renames = Vec::with_capacity(made.len());
@@ -176,6 +178,7 @@ impl State {
 			renames.push(before.renames(edit));
 			before.apply(edit)?;
 		}
+		keep_program(self.compositor.program_scene(), &renames)?;
 		self.compositor.set_canvas(collection.canvas)?;
 		for renames in &renames {
 			self.compositor.rename(renames);
@@ -209,6 +212,21 @@ impl State {
 	}
 }
 
+/// Refuse edits, each read as its [`Collection::renames`], that remove
+/// `program`, the scene on program, so a slip cannot put black on air. A
+/// reload that leaves it out still empties program, having nothing to show.
+fn keep_program(program: Option<&str>, renames: &[BTreeMap<String, Option<String>>]) -> anyhow::Result<()> {
+	let Some(mut program) = program else { return Ok(()) };
+	for renames in renames {
+		match renames.get(program) {
+			Some(Some(to)) => program = to,
+			Some(None) => anyhow::bail!("`{program}` is on program; cut to another scene before removing it"),
+			None => {}
+		}
+	}
+	Ok(())
+}
+
 /// How the output is doing, for the stream panel.
 #[derive(Default)]
 pub struct Stats {
@@ -1200,6 +1218,38 @@ mod tests {
 		assert_eq!(stats.encoder().as_deref(), Some("new"));
 	}
 
+	/// No edit removes the scene on program: not a remove, nor an undo of the
+	/// add that made it, even after a rename, while any other scene can go.
+	#[test]
+	fn the_scene_on_program_stays() {
+		let mut collection = Collection::new();
+		let live = collection.scenes[0].name.clone();
+		let mut draft = collection.draft("Add `Other`");
+		draft.insert_scene(1, moq_scene::Scene::new("Other")).unwrap();
+		let add = draft.finish().unwrap();
+		collection.apply(&add).unwrap();
+		let mut draft = collection.draft("Rename `Other`");
+		draft.rename_scene(1, "Renamed").unwrap();
+		let rename = draft.finish().unwrap();
+		let added = collection.clone();
+		collection.apply(&rename).unwrap();
+
+		let remove = |collection: &Collection, index| {
+			let mut draft = collection.draft("Remove");
+			draft.remove_scene(index).unwrap();
+			collection.renames(&draft.finish().unwrap())
+		};
+		assert!(keep_program(Some(&live), &[remove(&collection, 0)]).is_err());
+		keep_program(Some(&live), &[remove(&collection, 1)]).unwrap();
+		keep_program(None, &[remove(&collection, 0)]).unwrap();
+
+		// Undoing both edits, newest first, removes `Other` once renamed.
+		let undo = [collection.renames(&rename.inverse()), added.renames(&add.inverse())];
+		let err = keep_program(Some("Renamed"), &undo).unwrap_err();
+		assert!(err.to_string().contains("`Other` is on program"), "{err}");
+		keep_program(Some(&live), &undo).unwrap();
+	}
+
 	async fn subscribe(
 		broadcast: &moq_net::broadcast::Consumer,
 		name: &str,
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 64eb5ed..84dfdbf 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -780,7 +780,8 @@ impl Panels {
 					if label.double_clicked() || ui.small_button("Rename").clicked() {
 						self.renaming = Some((index, scene.name.clone()));
 					}
-					if program.as_deref() == Some(scene.name.as_str()) {
+					let live = program.as_deref() == Some(scene.name.as_str());
+					if live {
 						ui.colored_label(Color32::RED, "on program");
 					}
 					if ui.add_enabled(index > 0, egui::Button::new("Up").small()).clicked() {
@@ -792,7 +793,11 @@ impl Panels {
 					{
 						action = Some(SceneAction::Move(index, index + 1));
 					}
-					if ui.small_button("Remove").clicked() {
+					if ui
+						.add_enabled(!live, egui::Button::new("Remove").small())
+						.on_disabled_hover_text("On program; cut to another scene first")
+						.clicked()
+					{
 						action = Some(SceneAction::Remove(index));
 					}
 				});

From 7ae5bf971123fbbbe5f8d37dbbe6927627663741 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 17:53:32 -0800
Subject: [PATCH 11/12] fix(studio): keep the scene a fade leaves on air too

Removing it mid-fade blended the incoming scene over black.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                      |  2 +-
 rs/moq-scene/src/compositor.rs |  7 +++++
 rs/moq-studio/src/engine.rs    | 50 +++++++++++++++++++---------------
 rs/moq-studio/src/ui.rs        |  8 +++---
 4 files changed, 40 insertions(+), 27 deletions(-)

diff --git a/README.md b/README.md
index 164ebde..34a87bb 100644
--- a/README.md
+++ b/README.md
@@ -86,7 +86,7 @@ Every panel is a tab you can drag, split, or stack.
 | Panel | Use it to |
 | --- | --- |
 | Preview, Program | See the scene you are editing and the one that is live, and drag items in the preview to place them. **Cut** puts the preview on program at once; **Fade** blends over the fade time set beside it. |
-| Scenes | Pick the scene in preview, and add, rename (double-click), reorder, or remove one. The scene on program cannot be removed, even by an undo, until program cuts to another. |
+| Scenes | Pick the scene in preview, and add, rename (double-click), reorder, or remove one. A scene on program, or still fading out, cannot be removed, even by an undo, until program cuts away from it. |
 | History | See every edit, and undo or redo back to any of them. |
 | Items | Place, show, hide, and order what the preview scene or the top layer draws, back to front. Select an item to filter or copy it. |
 | Sources | Add a source by hand, see whether each and its own track are live and where it is shown, clone one, and remove one. Select a source to filter it. |
diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs
index 6e3c535..37d2b67 100644
--- a/rs/moq-scene/src/compositor.rs
+++ b/rs/moq-scene/src/compositor.rs
@@ -169,6 +169,13 @@ impl Compositor {
 		self.fade.is_some()
 	}
 
+	/// The scenes program draws: the one on program, and the one a fade under
+	/// way leaves.
+	pub fn on_air(&self) -> impl Iterator<Item = &str> {
+		let leaving = self.fade.as_ref().and_then(|fade| fade.from.as_deref());
+		self.program_scene.as_deref().into_iter().chain(leaving)
+	}
+
 	/// Put the scene called `scene` in preview, or nothing.
 	pub fn set_preview(&mut self, scene: Option<String>) {
 		self.preview_scene = scene;
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 58161ec..d3c79b2 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -169,8 +169,8 @@ impl State {
 	/// the one drawn, once the compositor takes its canvas. The scenes in
 	/// preview and on program follow the renames and removals `made` holds,
 	/// each edit read against the collection it was made to, and any
-	/// `collection` lacks is dropped. Edits that remove the scene on program
-	/// are refused, changing nothing.
+	/// `collection` lacks is dropped. Edits that remove a scene on air are
+	/// refused, changing nothing.
 	fn adopt(&mut self, collection: Collection, made: &[Edit]) -> anyhow::Result<()> {
 		let mut before = self.collection.clone();
 		let mut renames = Vec::with_capacity(made.len());
@@ -178,7 +178,7 @@ impl State {
 			renames.push(before.renames(edit));
 			before.apply(edit)?;
 		}
-		keep_program(self.compositor.program_scene(), &renames)?;
+		keep_on_air(self.compositor.on_air(), &renames)?;
 		self.compositor.set_canvas(collection.canvas)?;
 		for renames in &renames {
 			self.compositor.rename(renames);
@@ -212,16 +212,20 @@ impl State {
 	}
 }
 
-/// Refuse edits, each read as its [`Collection::renames`], that remove
-/// `program`, the scene on program, so a slip cannot put black on air. A
-/// reload that leaves it out still empties program, having nothing to show.
-fn keep_program(program: Option<&str>, renames: &[BTreeMap<String, Option<String>>]) -> anyhow::Result<()> {
-	let Some(mut program) = program else { return Ok(()) };
-	for renames in renames {
-		match renames.get(program) {
-			Some(Some(to)) => program = to,
-			Some(None) => anyhow::bail!("`{program}` is on program; cut to another scene before removing it"),
-			None => {}
+/// Refuse edits, each read as its [`Collection::renames`], that remove a
+/// scene `on_air` program draws, so a slip cannot put black on air. A reload
+/// that leaves one out still drops it, having nothing to show instead.
+fn keep_on_air<'a>(
+	on_air: impl IntoIterator<Item = &'a str>,
+	renames: &'a [BTreeMap<String, Option<String>>],
+) -> anyhow::Result<()> {
+	for mut scene in on_air {
+		for renames in renames {
+			match renames.get(scene) {
+				Some(Some(to)) => scene = to,
+				Some(None) => anyhow::bail!("`{scene}` is on air; cut to another scene before removing it"),
+				None => {}
+			}
 		}
 	}
 	Ok(())
@@ -1218,10 +1222,10 @@ mod tests {
 		assert_eq!(stats.encoder().as_deref(), Some("new"));
 	}
 
-	/// No edit removes the scene on program: not a remove, nor an undo of the
-	/// add that made it, even after a rename, while any other scene can go.
+	/// No edit removes a scene on air: not a remove, nor an undo of the add
+	/// that made it, even after a rename, while any other scene can go.
 	#[test]
-	fn the_scene_on_program_stays() {
+	fn a_scene_on_air_stays() {
 		let mut collection = Collection::new();
 		let live = collection.scenes[0].name.clone();
 		let mut draft = collection.draft("Add `Other`");
@@ -1239,15 +1243,17 @@ mod tests {
 			draft.remove_scene(index).unwrap();
 			collection.renames(&draft.finish().unwrap())
 		};
-		assert!(keep_program(Some(&live), &[remove(&collection, 0)]).is_err());
-		keep_program(Some(&live), &[remove(&collection, 1)]).unwrap();
-		keep_program(None, &[remove(&collection, 0)]).unwrap();
+		let removed = [remove(&collection, 0)];
+		assert!(keep_on_air([live.as_str()], &removed).is_err());
+		assert!(keep_on_air(["Renamed", live.as_str()], &removed).is_err(), "fading out");
+		keep_on_air([live.as_str()], &[remove(&collection, 1)]).unwrap();
+		keep_on_air([], &removed).unwrap();
 
 		// Undoing both edits, newest first, removes `Other` once renamed.
 		let undo = [collection.renames(&rename.inverse()), added.renames(&add.inverse())];
-		let err = keep_program(Some("Renamed"), &undo).unwrap_err();
-		assert!(err.to_string().contains("`Other` is on program"), "{err}");
-		keep_program(Some(&live), &undo).unwrap();
+		let err = keep_on_air(["Renamed"], &undo).unwrap_err();
+		assert!(err.to_string().contains("`Other` is on air"), "{err}");
+		keep_on_air([live.as_str()], &undo).unwrap();
 	}
 
 	async fn subscribe(
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 84dfdbf..2dcb911 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -749,6 +749,7 @@ impl Panels {
 		let mut state = engine.state.lock().unwrap();
 		let preview = state.compositor.preview_scene().map(str::to_owned);
 		let program = state.compositor.program_scene().map(str::to_owned);
+		let on_air: Vec<String> = state.compositor.on_air().map(str::to_owned).collect();
 		let mut pick = None;
 		let mut action = None;
 		let count = state.collection().scenes.len();
@@ -780,8 +781,7 @@ impl Panels {
 					if label.double_clicked() || ui.small_button("Rename").clicked() {
 						self.renaming = Some((index, scene.name.clone()));
 					}
-					let live = program.as_deref() == Some(scene.name.as_str());
-					if live {
+					if program.as_deref() == Some(scene.name.as_str()) {
 						ui.colored_label(Color32::RED, "on program");
 					}
 					if ui.add_enabled(index > 0, egui::Button::new("Up").small()).clicked() {
@@ -794,8 +794,8 @@ impl Panels {
 						action = Some(SceneAction::Move(index, index + 1));
 					}
 					if ui
-						.add_enabled(!live, egui::Button::new("Remove").small())
-						.on_disabled_hover_text("On program; cut to another scene first")
+						.add_enabled(!on_air.contains(&scene.name), egui::Button::new("Remove").small())
+						.on_disabled_hover_text("On air; cut to another scene first")
 						.clicked()
 					{
 						action = Some(SceneAction::Remove(index));

From 443673b670992f0d40efd8697ba628a99f821fd6 Mon Sep 17 00:00:00 2001
From: Luke Curley <kixelated@gmail.com>
Date: Tue, 3 Nov 2026 18:29:27 -0800
Subject: [PATCH 12/12] fix(studio): drop a pending scene rename on a reload
 the Scenes panel sees

The rename names its scene by place, and the autosave can reload and
reorder the scenes between the frame's first reload check and the Scenes
panel's lock, so committing it then renamed whichever scene took that
place. The panel now follows reloads under its own lock, as the other
index-based panels do.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rs/moq-studio/src/ui.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 6fd9569..bd02ae4 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -421,9 +421,9 @@ impl Panels {
 	}
 
 	/// Report a reload, from File > Reload or an outside edit the autosave
-	/// took, and let go of a selected item and a drag whose index it may have
-	/// given to another item. Called under every lock that uses either, since
-	/// the autosave can reload between two.
+	/// took, and let go of a selected item, a drag, and a scene rename under
+	/// way, whose index it may have given to another. Called under every lock
+	/// that uses one, since the autosave can reload between two.
 	fn follow_reloads(&mut self, state: &State) {
 		if state.reloads == self.reloads {
 			return;
@@ -795,6 +795,7 @@ impl Panels {
 	fn scenes(&mut self, ui: &mut Ui) {
 		let engine = self.engine.clone();
 		let mut state = engine.state.lock().unwrap();
+		self.follow_reloads(&state);
 		let preview = state.compositor.preview_scene().map(str::to_owned);
 		let program = state.compositor.program_scene().map(str::to_owned);
 		let on_air: Vec<String> = state.compositor.on_air().map(str::to_owned).collect();