diff --git a/README.md b/README.md
index 599e07d..e91d0bf 100644
--- a/README.md
+++ b/README.md
@@ -76,9 +76,8 @@ canvas and no sources. The proposed scene is the first edit in the history, so
 undoing it leaves that empty scene.
 
 Setup writes an ordinary scene file. Change its sources and scenes in their
-panels, and its canvas in the file, which takes a restart. The Output panel
-shows the canvas in use, and the Health panel shows how the uplink holds up
-once you are live.
+panels, and its canvas in the Output panel. The Health panel shows how the
+uplink holds up once you are live.
 
 ## Panels
 
@@ -86,8 +85,8 @@ 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 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, 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. 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. |
@@ -95,7 +94,7 @@ Every panel is a tab you can drag, split, or stack.
 | Guests | Invite a guest, show their join link as a QR code, see who joined, and take a guest out of every scene. |
 | Filters | Crop the selected source or item, add, order, and set its filters, set an item's blend mode, and copy or paste filters. |
 | 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, the canvas, 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, relay by relay and track by track, and the cause of each problem. |
 
 A new source, from the Sources or Devices panel, is placed over whatever the
@@ -304,7 +303,7 @@ leaving half of it, and a collection that has not changed is not rewritten, so
 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. A new canvas size or frame rate takes a restart.
+last write.
 
 The file can be edited by hand, or by another studio, while the studio runs.
 The studio looks at it every second and before each write. With no edits of
@@ -333,6 +332,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 461ee6b..6caa376 100644
--- a/quest/m0/README.md
+++ b/quest/m0/README.md
@@ -83,7 +83,6 @@ repository.
 - [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
 - [The program encoder drains](/quest/m0/program-drain.md) - a hardware encoder never loses the program's last frames at exit or on pause
-- [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/program-drain.md b/quest/m0/program-drain.md
index f8efe16..e4df0f7 100644
--- a/quest/m0/program-drain.md
+++ b/quest/m0/program-drain.md
@@ -3,7 +3,8 @@
 ## Goal
 
 The program's encoder drains its buffered pictures before it stops at exit
-and before the studio publishes the gap marker of an on-demand pause, so a
+or when a new canvas ends its rendition, and before the studio publishes the
+gap marker of an on-demand pause, so a
 pipelined hardware encoder never loses the program's last frames.
 
 ## Plan
diff --git a/quest/m0/scene-editing.md b/quest/m0/scene-editing.md
deleted file mode 100644
index 52f98ec..0000000
--- a/quest/m0/scene-editing.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# [M] Scene editing
-
-## Goal
-
-In `moq-studio`, scenes can be renamed and reordered, the transition's
-settings (such as the fade time) can be edited as undoable steps, 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/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 07ab6fc..37d2b67 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::time::Duration;
 
 use kio::clock::Instant;
@@ -90,15 +90,10 @@ 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> {
-		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 effects = Effects::new(device, queue, canvas);
 		let target = |label| Target::new(device, &effects, canvas, label);
@@ -122,6 +117,26 @@ 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, 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 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);
+		if canvas.size() != self.canvas.size() {
+			let target = |label| Target::new(&self.device, &self.effects, 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
@@ -154,11 +169,51 @@ 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;
 	}
 
+	/// Follow each renamed scene to its new name, wherever it is: in preview,
+	/// 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>>) {
+		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;
@@ -284,6 +339,20 @@ impl Compositor {
 	}
 }
 
+/// 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!(
+			"canvas {}x{} exceeds this GPU's {limit}px texture limit",
+			canvas.width, canvas.height
+		)));
+	}
+	Ok(())
+}
+
 /// One render's draws onto its targets.
 struct Draw<'a> {
 	collection: &'a Collection,
@@ -1158,6 +1227,110 @@ mod tests {
 		.await;
 	}
 
+	/// A resize draws the next frame on textures of the new size, with items
+	/// where their pixels say, a blend mode and a blur reaching the canvas's
+	/// new width, 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 collection = collection();
+			collection.sources.insert(
+				"tint".into(),
+				Source::Color {
+					color: Rgba([0, 0, 255, 255]),
+				},
+			);
+			let mut studio = Studio::new(collection).await;
+			studio.compositor.set_preview(Some("red".into()));
+			studio.compositor.cut();
+			studio.render(Instant::now());
+			let old = studio.compositor.program().clone();
+
+			let wide = Canvas {
+				width: 16,
+				..studio.collection.canvas
+			};
+			studio.compositor.set_canvas(wide).unwrap();
+			assert_ne!(studio.compositor.program(), &old, "a new texture");
+			studio.collection.canvas = wide;
+			let fill = Rect::fill(&wide);
+			studio.collection.scenes[0].items = vec![
+				Item::new("red", Rect { width: 8.0, ..fill }),
+				Item {
+					blend: Blend::Screen,
+					filters: vec![Filter::Blur { radius: 1.0 }],
+					..Item::new("tint", fill)
+				},
+			];
+			studio.render(Instant::now());
+			let program = studio.program();
+			assert_eq!(program.len(), 16 * 8 * 4);
+			let pixel = |x: usize, y: usize| -> [u8; 4] {
+				let at = (y * 16 + x) * 4;
+				program[at..at + 4].try_into().unwrap()
+			};
+			assert!(
+				near(pixel(4, 4), [255, 0, 255, 255]),
+				"screened over red: {:?}",
+				pixel(4, 4)
+			);
+			assert!(
+				near(pixel(12, 4), BLUE),
+				"screened past the old width: {:?}",
+				pixel(12, 4)
+			);
+
+			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(_))));
+			let empty = Canvas { width: 0, ..wide };
+			assert!(matches!(studio.compositor.set_canvas(empty), Err(Error::Invalid(_))));
+			assert_eq!(studio.compositor.canvas(), wide);
+		})
+		.await;
+	}
+
+	/// 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, 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() {
+		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);
+
+			// `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:?}");
+
+			// 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;
+	}
+
 	/// A blend mode mixes an item with what is under it by the CSS formula,
 	/// weighted by the item's opacity.
 	#[tokio::test]
diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs
index e7bd3c6..44d6d40 100644
--- a/rs/moq-scene/src/edit.rs
+++ b/rs/moq-scene/src/edit.rs
@@ -9,12 +9,12 @@
 //! 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};
 
 use crate::Error;
-use crate::collection::{Audio, Collection, Filter, Item, Layer, Scene, Source, Transition, Video};
+use crate::collection::{Audio, Canvas, Collection, Filter, 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,
+			},
 		}
 	}
 
@@ -115,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,
 		}
 	}
 
@@ -128,6 +135,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,
 		}
 	}
 
@@ -210,6 +218,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)
@@ -243,6 +254,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(())
+			}
 		}
 	}
 }
@@ -321,6 +339,51 @@ impl Collection {
 		Ok(())
 	}
 
+	/// 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() => {
+					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,
+				_ => {}
+			}
+		}
+		let kept = scenes
+			.into_iter()
+			.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()
+	}
+
 	/// Start an edit labelled `label` against this collection.
 	pub fn draft(&self, label: impl Into<String>) -> Draft {
 		Draft {
@@ -470,7 +533,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 {
@@ -480,6 +543,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}")))
@@ -538,6 +617,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> {
@@ -985,6 +1071,127 @@ mod tests {
 		assert_eq!(history.entries().len(), 2, "a drag back to the start is no edit");
 	}
 
+	fn renamed(pairs: &[(&str, Option<&str>)]) -> BTreeMap<String, Option<String>> {
+		pairs
+			.iter()
+			.map(|(was, now)| (was.to_string(), now.map(str::to_string)))
+			.collect()
+	}
+
+	/// A rename keeps the scene's items and place, a move keeps its name, and
+	/// 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();
+		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 = collection.renames(&edit);
+		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");
+		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!(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();
+		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);
+
+		// 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", Some("Other")), ("Other", Some("Next"))]),
+			"an added scene renames nothing"
+		);
+		collection.apply(&edit).unwrap();
+		assert_eq!(
+			collection.renames(&edit.inverse()),
+			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.
+		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-scene/src/effect.rs b/rs/moq-scene/src/effect.rs
index 169aae6..9ad98a6 100644
--- a/rs/moq-scene/src/effect.rs
+++ b/rs/moq-scene/src/effect.rs
@@ -483,6 +483,24 @@ pub(crate) struct Effects {
 	used: Vec<Raster>,
 }
 
+/// What a blend mode mixes with, as large as the canvas.
+fn backdrop(device: &wgpu::Device, canvas: Canvas) -> wgpu::Texture {
+	device.create_texture(&wgpu::TextureDescriptor {
+		label: Some("moq-scene backdrop"),
+		size: wgpu::Extent3d {
+			width: canvas.width,
+			height: canvas.height,
+			depth_or_array_layers: 1,
+		},
+		mip_level_count: 1,
+		sample_count: 1,
+		dimension: wgpu::TextureDimension::D2,
+		format: FORMAT,
+		usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+		view_formats: &[],
+	})
+}
+
 impl Effects {
 	pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, canvas: Canvas) -> Self {
 		let texture = |binding, sample_type, view_dimension| wgpu::BindGroupLayoutEntry {
@@ -602,20 +620,7 @@ impl Effects {
 		};
 		let empty_2d = empty(wgpu::TextureDimension::D2, FORMAT);
 		let empty_3d = empty(wgpu::TextureDimension::D3, wgpu::TextureFormat::Rgba32Float);
-		let backdrop = device.create_texture(&wgpu::TextureDescriptor {
-			label: Some("moq-scene backdrop"),
-			size: wgpu::Extent3d {
-				width: canvas.width,
-				height: canvas.height,
-				depth_or_array_layers: 1,
-			},
-			mip_level_count: 1,
-			sample_count: 1,
-			dimension: wgpu::TextureDimension::D2,
-			format: FORMAT,
-			usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
-			view_formats: &[],
-		});
+		let backdrop = backdrop(device, canvas);
 
 		let alignment = u64::from(device.limits().min_uniform_buffer_offset_alignment);
 		let stride = (size_of::<Uniform>() as u64).next_multiple_of(alignment);
@@ -643,6 +648,16 @@ impl Effects {
 		}
 	}
 
+	/// Draw onto `canvas` from the next frame on, reallocating what is sized
+	/// from it.
+	pub fn set_canvas(&mut self, canvas: Canvas) {
+		if canvas.width != self.canvas.width || canvas.height != self.canvas.height {
+			self.backdrop = backdrop(&self.device, canvas);
+			self.backdrop_view = self.backdrop.create_view(&Default::default());
+		}
+		self.canvas = canvas;
+	}
+
 	/// `texture`, a source's picture or a canvas-sized target, bound to sample.
 	pub fn picture(&self, texture: &wgpu::Texture) -> Picture {
 		let view = texture.create_view(&Default::default());
diff --git a/rs/moq-studio/src/autosave.rs b/rs/moq-studio/src/autosave.rs
index 6b39846..8157206 100644
--- a/rs/moq-studio/src/autosave.rs
+++ b/rs/moq-studio/src/autosave.rs
@@ -646,7 +646,7 @@ mod tests {
 	}
 
 	/// A collection and its history as the studio holds them, which can be
-	/// told to refuse a reload as the studio refuses a new canvas.
+	/// told to refuse a reload as the studio refuses a canvas the GPU cannot hold.
 	struct Doc {
 		collection: Collection,
 		history: History,
@@ -978,7 +978,8 @@ mod tests {
 		assert_eq!(running.text(), created);
 		assert_eq!(read(&path), "not a scene file");
 
-		// One the studio refuses, as it does a new canvas, is held the same way.
+		// One the studio refuses, as it does a canvas the GPU cannot hold, is held
+		// the same way.
 		running.doc.lock().unwrap().refuse = true;
 		std::fs::write(&path, HAND_WRITTEN).unwrap();
 		kio::clock::sleep(POLL + Duration::from_millis(100)).await;
diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs
index 51d4922..d0e1e51 100644
--- a/rs/moq-studio/src/engine.rs
+++ b/rs/moq-studio/src/engine.rs
@@ -6,13 +6,15 @@
 //! - **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
 //!   edits to them settle, and takes or holds an outside edit to the scene file.
 //! - 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};
@@ -22,7 +24,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};
@@ -100,7 +102,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(())
@@ -118,29 +122,75 @@ 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 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, and any
+	/// `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());
+		for edit in made {
+			renames.push(before.renames(edit));
+			before.apply(edit)?;
+		}
+		keep_on_air(self.compositor.on_air(), &renames)?;
+		self.compositor.set_canvas(collection.canvas)?;
+		for renames in &renames {
+			self.compositor.rename(renames);
+		}
+		self.compositor.retain(&collection);
+		self.collection = collection;
+		Ok(())
+	}
+
 	/// After any change to the collection or its history, which the autosave
 	/// writes once they settle.
 	fn edited(&mut self) {
@@ -162,16 +212,9 @@ impl autosave::Document for 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, leaves it until another is picked.
+		self.adopt(collection, &[])?;
 		self.history = history;
 		self.dropped = dropped;
 		self.reloads += 1;
@@ -180,6 +223,25 @@ impl autosave::Document for State {
 	}
 }
 
+/// 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(())
+}
+
 /// How the output is doing, for the stream panel.
 #[derive(Default)]
 pub struct Stats {
@@ -203,16 +265,72 @@ pub struct Stats {
 	pub encode_us: AtomicU64,
 	/// Whether any viewer is subscribed to the video.
 	pub watched: AtomicBool,
-	/// The encoder backend, once one opened.
-	pub encoder: Mutex<Option<String>>,
-	/// Why the output stopped, if it did.
-	pub error: Mutex<Option<String>>,
+	/// 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 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 {
-	fn fail(&self, err: impl std::fmt::Display) {
-		tracing::error!(%err, "output stopped");
-		*self.error.lock().unwrap() = Some(err.to_string());
+	/// 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();
+		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) {
+		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}"));
 	}
 }
 
@@ -246,7 +364,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,
@@ -317,11 +435,12 @@ impl Engine {
 			dropped,
 		} = loaded;
 		let canvas = collection.canvas;
+		let stats = Arc::new(Stats::default());
 
 		let (output, origin, publish) = if relays.is_empty() {
 			(None, Some(subscribe), None)
 		} else {
-			let (output, publish) = publish(&gpu, relays, subscribe, &broadcast, canvas, on_demand).await?;
+			let (output, publish) = publish(&gpu, &stats, relays, subscribe, &broadcast, canvas, on_demand).await?;
 			(Some(output), None, Some(publish))
 		};
 
@@ -351,7 +470,7 @@ impl Engine {
 				edits: autosave.edits(),
 			}),
 			autosave,
-			stats: Stats::default(),
+			stats,
 			health: Mutex::default(),
 			bus,
 			output,
@@ -360,30 +479,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),
 		};
 
@@ -444,8 +546,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
@@ -472,10 +572,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,
-			encoder: stats.encoder.lock().unwrap().clone(),
-			failed: stats.error.lock().unwrap().clone(),
+			encoding: stats.encoding.load(Ordering::Relaxed),
+			watched: stats.watched.load(Ordering::Relaxed),
+			encoder: stats.encoder(),
+			failed: stats.error(),
 			stalled,
 		}
 	}
@@ -484,24 +584,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 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.
+		let mut settled = true;
+		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) {
@@ -513,30 +620,76 @@ 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;
+				settled = false;
+				// Ended before the next opens, so the two never hold encode
+				// sessions at once.
+				ending.extend(rendition.take().map(Rendition::end));
+				self.stats.retire_encoder();
+			}
+			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 = true;
+						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 {
+					let ending = std::mem::take(&mut ending);
+					match Probe::spawn(renditions.gpu.clone(), canvas, ending) {
+						Ok(probe) => probing = Some((canvas, probe)),
+						Err(err) => {
+							settled = true;
+							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() {
+					ending.extend(rendition.take().map(Rendition::end));
 				}
 				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() {
+						ending.extend(rendition.take().map(Rendition::end));
 					}
 				}
 				Ok(None) => {
@@ -545,8 +698,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));
+					ending.extend(rendition.take().map(Rendition::end));
 				}
 			}
 		}
@@ -583,7 +736,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());
@@ -595,9 +748,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.
@@ -613,10 +767,11 @@ struct Publish {
 /// `subscribe`'s broadcast sources.
 async fn publish(
 	gpu: &Gpu,
+	stats: &Arc<Stats>,
 	relays: Vec<Relay>,
 	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();
@@ -638,29 +793,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);
@@ -669,8 +832,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);
 
 	// One epoch on every relay, so a viewer moving between them resumes
 	// mid-group rather than restarting.
@@ -688,7 +852,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(),
 		relays: links,
 		feedback,
@@ -705,9 +869,8 @@ async fn publish(
 	Ok((
 		output,
 		Publish {
-			video,
-			config,
-			exporter,
+			renditions,
+			rendition,
 			audio,
 			clock,
 			health,
@@ -716,6 +879,137 @@ 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 number = stats.rendition();
+		let thread = std::thread::Builder::new()
+			.name("encode".into())
+			.spawn(move || encode(&stats, number, 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
+}
+
 /// Connect to every relay, publishing `origin` to each and feeding `subscribe`
 /// the broadcast sources of each, and watch each connection for the Health
 /// panel.
@@ -761,19 +1055,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.
@@ -787,13 +1076,15 @@ 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,
+	rendition: u64,
 	opened: tokio::sync::oneshot::Sender<anyhow::Result<()>>,
 	video: mpsc::Receiver<Video>,
 	mut producer: moq_video::encode::Producer,
@@ -804,19 +1095,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.opened_encoder(rendition, encoder.name());
 	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());
 	}
 }
@@ -925,6 +1218,95 @@ 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"));
+	}
+
+	/// 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 a_scene_on_air_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())
+		};
+		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_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(
+		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")]
@@ -978,7 +1360,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"
 		);
 
@@ -996,34 +1378,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;
+		let shown = 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.
@@ -1070,6 +1428,65 @@ mod tests {
 		.await
 		.expect("sound arrives");
 
+		// A resize while live ends the old track and lists a rendition of the
+		// 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: 15,
+			};
+			draft.set_canvas(canvas).unwrap();
+			state.commit(draft, None).unwrap();
+		}
+		let ended = kio::clock::timeout(TIMEOUT, async {
+			let mut last = shown;
+			while let Some(read) = pictures.read().await.expect("decode") {
+				if let moq_video::decode::Read::Frame(frame) = read {
+					last = 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 < 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.
 		let path = dir.path().join("show.toml");
diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs
index 8a24348..bd02ae4 100644
--- a/rs/moq-studio/src/ui.rs
+++ b/rs/moq-studio/src/ui.rs
@@ -9,7 +9,8 @@ use egui::{Color32, Ui};
 use egui_dock::{DockArea, DockState, NodeIndex, Style, TabViewer};
 use moq_scene::source::{Feed, Status};
 use moq_scene::{
-	Blend, Canvas, Clip, Collection, Crop, Draft, Filter, Item, Layer, MaskMode, Rect, Scene, Source, Video, wgpu,
+	Blend, Canvas, Clip, Collection, Crop, Draft, Filter, Item, Layer, MaskMode, Rect, Scene, Source, Transition,
+	Video, wgpu,
 };
 
 use crate::autosave::Conflict;
@@ -62,18 +63,13 @@ pub struct Studio {
 
 impl Studio {
 	pub fn new(render: &eframe::egui_wgpu::RenderState, engine: Arc<Engine>, runtime: tokio::runtime::Handle) -> Self {
-		// 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()),
+				Registered::new(render, state.compositor.preview()),
+				Registered::new(render, state.compositor.program()),
 				state.dropped,
 			)
 		};
@@ -99,6 +95,8 @@ impl Studio {
 				snapping: Snapping::default(),
 				drag: None,
 				new_scene: String::new(),
+				renaming: None,
+				canvas: None,
 				new_item: None,
 				add: AddSource::default(),
 				devices: Devices::default(),
@@ -112,11 +110,15 @@ impl Studio {
 }
 
 impl eframe::App for Studio {
-	fn ui(&mut self, ui: &mut Ui, _frame: &mut eframe::Frame) {
-		// Redraw at the canvas rate, so preview and program are live.
+	fn ui(&mut self, ui: &mut Ui, frame: &mut eframe::Frame) {
 		let engine = self.panels.engine.clone();
 		let state = engine.state.lock().unwrap();
-		let framerate = state.collection().canvas.framerate;
+		if let Some(render) = frame.wgpu_render_state() {
+			self.panels.preview.follow(render, state.compositor.preview());
+			self.panels.program.follow(render, state.compositor.program());
+		}
+		// Redraw at the canvas rate, so preview and program are live.
+		let framerate = state.compositor.canvas().framerate;
 		ui.ctx().request_repaint_after(Duration::from_secs(1) / framerate);
 		self.panels.follow_reloads(&state);
 		drop(state);
@@ -133,12 +135,47 @@ impl eframe::App for Studio {
 	}
 }
 
+/// A compositor texture as egui shows it.
+struct Registered {
+	id: egui::TextureId,
+	texture: wgpu::Texture,
+}
+
+impl Registered {
+	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: Registered,
+	program: Registered,
 	/// Whether the Items panel shows the top layer rather than the scene in
 	/// preview.
 	top: bool,
@@ -149,6 +186,11 @@ struct Panels {
 	/// The item a drag in the preview holds.
 	drag: Option<Drag>,
 	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,
@@ -379,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;
@@ -481,12 +523,13 @@ impl Panels {
 	}
 
 	/// Deselect an item, after an edit that may have moved any of them, and
-	/// let go of any drag.
+	/// let go of any drag and any scene rename under way.
 	fn deselect_item(&mut self) {
 		if matches!(self.selection, Some(Selection::Item(..))) {
 			self.selection = None;
 		}
 		self.drag = None;
+		self.renaming = None;
 	}
 
 	/// The layer the Items panel shows, and new sources are placed in.
@@ -587,7 +630,7 @@ impl Panels {
 					.suffix(" px"),
 			);
 		});
-		let response = picture(ui, self.preview, canvas, egui::Sense::click_and_drag());
+		let response = picture(ui, self.preview.id, canvas, egui::Sense::click_and_drag());
 		let result = self.arrange(ui, &mut state, &response, canvas);
 		drop(state);
 		self.check(result);
@@ -713,16 +756,29 @@ impl Panels {
 	}
 
 	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")
@@ -732,29 +788,66 @@ impl Panels {
 			}
 		});
 		drop(state);
-		picture(ui, self.program, canvas, egui::Sense::hover());
+		self.check(result);
+		picture(ui, self.program.id, canvas, egui::Sense::hover());
 	}
 
 	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();
 		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.small_button("Remove").clicked() {
-						remove = Some((index, scene.name.clone()));
+					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
+						.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));
 					}
 				});
 			}
@@ -782,12 +875,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();
 		}
 	}
 
@@ -1457,6 +1573,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);
@@ -1481,13 +1600,6 @@ impl Panels {
 					ui.end_row();
 				}
 			}
-			let canvas = self.engine.state.lock().unwrap().collection().canvas;
-			ui.label("Canvas");
-			ui.label(format!(
-				"{}x{} at {} fps, set in the scene file and read at startup",
-				canvas.width, canvas.height, canvas.framerate
-			));
-			ui.end_row();
 			ui.label("Drawn");
 			ui.label(format!("{} frames", count(&stats.rendered)));
 			ui.end_row();
@@ -1509,14 +1621,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!(
@@ -1526,11 +1631,52 @@ 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, each relay, the
 	/// uplink, each track, and each viewer that reports.
 	fn health(&mut self, ui: &mut Ui) {
@@ -1706,6 +1852,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.