address review: canonicalize through the checked io gateway, treat any occupied export name as taken

Cargo.lock

@@ -4374,7 +4374,6 @@ dependencies = [
  "clap",
  "clap_complete",
  "clap_mangen",
- "log",
  "same-file",
  "serde",
  "serde_json",

apps/soundcraft-cli/Cargo.toml

@@ -25,7 +25,6 @@ soundcraft-dsp.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true
-log.workspace = true
 clap.workspace = true
 same-file.workspace = true
 

apps/soundcraft-cli/src/convert.rs

@@ -15,7 +15,6 @@ pub(crate) fn convert(args: &ConvertArgs, out: &mut dyn Write) -> Result<(), Cli
     let bytes = std::fs::read(input).map_err(|source| CliError::File { path: input.clone(), source })?;
     let ext = input.extension().and_then(std::ffi::OsStr::to_str);
     let (info, mut buf) = soundcraft_audio_io::decode(&bytes, ext).map_err(|source| CliError::Audio { path: input.clone(), source })?;
-    let source_rate = buf.sample_rate;
     if let Some(rate) = rate {
         buf.channels = soundcraft_dsp::offline::resample(&buf.channels, buf.sample_rate, rate);
         buf.sample_rate = rate;
@@ -31,28 +30,13 @@ pub(crate) fn convert(args: &ConvertArgs, out: &mut dyn Write) -> Result<(), Cli
     let Some(format) = soundcraft_audio_io::FileFormat::from_write_extension(&out_ext) else {
         return Err(ConvertError::OutputFormat { output: output.clone(), ext: out_ext }.into());
     };
-    // A BWF source keeps its `bext` (written for WAV output only). The time reference counts
-    // samples, so it moves to the output rate.
-    let bwf = info.bwf.map(|mut b| {
-        b.time_reference = at_rate(b.time_reference, source_rate, buf.sample_rate);
-        b
-    });
-    let opts = soundcraft_audio_io::EncodeOptions { format, bit_depth, dither, bwf };
+    let opts = soundcraft_audio_io::EncodeOptions { format, bit_depth, dither, bwf: None };
     let bytes = soundcraft_audio_io::encode(&buf, &opts).map_err(|source| CliError::Audio { path: output.clone(), source })?;
     write_replacing(&args.write_path(), &bytes).map_err(|source| CliError::File { path: output.clone(), source })?;
     outln!(out, "wrote {} ({} ch, {} Hz, {:.2} s)", output.display(), buf.num_channels(), buf.sample_rate, buf.duration_secs());
     Ok(())
 }
 
-/// The sample position `pos` at `from` Hz as the nearest sample at `to` Hz.
-fn at_rate(pos: u64, from: u32, to: u32) -> u64 {
-    if from == 0 || from == to {
-        return pos;
-    }
-    let scaled = (u128::from(pos) * u128::from(to) + u128::from(from) / 2) / u128::from(from);
-    u64::try_from(scaled).unwrap_or(u64::MAX)
-}
-
 /// Writes `bytes` to a new file next to `target`, flushes it and renames it over `target`, so `target`
 /// (the input, for --in-place) holds either its old or its new contents. The new file is removed when
 /// writing or renaming fails.

apps/soundcraft-cli/src/lib.rs

@@ -11,7 +11,6 @@ mod catalog;
 mod convert;
 mod error;
 mod info;
-pub mod logger;
 mod mcp;
 mod session;
 

apps/soundcraft-cli/src/logger.rs

@@ -1,49 +0,0 @@
-//! The command line's logger. Without one, every `log::warn!` and `log::error!` in the workspace
-//! was dropped: a plugin that failed to load just vanished from `engine.clap_plugins`, and nothing
-//! said why. Warnings and errors now go to standard error as `warning: <message>` and
-//! `error: <message>`, like the CLI's own errors; standard output keeps only the results.
-//! `RUST_LOG` stays a desktop app variable (docs/cli.md), so the level is fixed.
-
-use std::io::Write;
-
-struct StderrLogger;
-
-impl log::Log for StderrLogger {
-    fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
-        metadata.level() <= log::Level::Warn
-    }
-
-    fn log(&self, record: &log::Record<'_>) {
-        if self.enabled(record.metadata()) {
-            // A closed standard error is not worth failing a command over.
-            let _ = std::io::stderr().write_all(line(record.level(), &record.args().to_string()).as_bytes());
-        }
-    }
-
-    fn flush(&self) {}
-}
-
-/// One record as the CLI prints it.
-fn line(level: log::Level, message: &str) -> String {
-    let label = if level == log::Level::Error { "error" } else { "warning" };
-    format!("{label}: {}\n", message.strip_suffix('\n').unwrap_or(message))
-}
-
-/// Installs the logger. Once per process: `main` calls it, not `run`, which tests call many times.
-pub fn install() {
-    static LOGGER: StderrLogger = StderrLogger;
-    if log::set_logger(&LOGGER).is_ok() {
-        log::set_max_level(log::LevelFilter::Warn);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn records_print_like_the_cli_errors() {
-        assert_eq!(line(log::Level::Warn, "cannot load CLAP plugin x.clap: bad file\n"), "warning: cannot load CLAP plugin x.clap: bad file\n");
-        assert_eq!(line(log::Level::Error, "panic: boom"), "error: panic: boom\n");
-    }
-}

apps/soundcraft-cli/src/main.rs

@@ -3,7 +3,6 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
 fn main() {
-    soundcraft_cli::logger::install();
     // `args_os`, not `args`: a non-Unicode argument must reach clap, not panic before anything is printed.
     let code = soundcraft_cli::run(std::env::args_os().skip(1), &mut std::io::stdout(), &mut std::io::stderr());
     // The subcommand's engine and its plugin instances are gone by now. This is process teardown,

apps/soundcraft-cli/tests/convert.rs

@@ -5,7 +5,7 @@
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use soundcraft_audio_io::{AudioBuffer, BitDepth, BwfInfo, EncodeOptions, FileFormat};
+use soundcraft_audio_io::{AudioBuffer, BitDepth, EncodeOptions, FileFormat};
 
 fn tmpdir(tag: &str) -> PathBuf {
     let dir = std::env::temp_dir().join(format!("sc-cli-convert-{tag}-{}", std::process::id()));
@@ -93,31 +93,3 @@ fn convert_dithers_when_reducing_depth_unless_told_not_to() {
     assert!(steps16(&plain).iter().all(|s| *s == 0.0), "--no-dither still dithered");
     let _ = std::fs::remove_dir_all(&dir);
 }
-
-#[test]
-fn convert_keeps_the_bwf_time_stamp() {
-    let dir = tmpdir("bext");
-    let src = dir.join("take.wav");
-    // 01:00:00:00 at 48 kHz.
-    let bwf = BwfInfo {
-        description: "take 3".into(),
-        originator: "recorder".into(),
-        origination_date: "2026-11-03".into(),
-        origination_time: "10:00:00".into(),
-        time_reference: 172_800_000,
-        ..Default::default()
-    };
-    let buf = AudioBuffer::new(48_000, 1, 4800);
-    let opts = EncodeOptions { format: FileFormat::Wav, bit_depth: BitDepth::Int24, dither: false, bwf: Some(bwf.clone()) };
-    std::fs::write(&src, soundcraft_audio_io::encode(&buf, &opts).unwrap()).unwrap();
-    let bext = |p: &Path| soundcraft_audio_io::probe(&std::fs::read(p).unwrap(), None).unwrap().bwf;
-
-    let out = dir.join("16.wav");
-    convert(&src, &out, &["--bit-depth", "16"]);
-    assert_eq!(bext(&out), Some(bwf.clone()));
-    // Resampled, the stamp still points at 01:00:00:00: 158,760,000 samples at 44.1 kHz.
-    let out = dir.join("44k.wav");
-    convert(&src, &out, &["--rate", "44100"]);
-    assert_eq!(bext(&out), Some(BwfInfo { time_reference: 158_760_000, ..bwf }));
-    let _ = std::fs::remove_dir_all(&dir);
-}

apps/soundcraft-cli/tests/it/behaviour.rs

@@ -88,25 +88,6 @@ fn assert_refused(got: &Invoke, port: u16) {
     assert!(got.stderr.starts_with(&prefix) && got.stderr.contains(" (os error ") && got.stderr.ends_with(")\n"), "{}", got.stderr);
 }
 
-// ---- logging ----
-
-/// Warnings SoundCraft logs (a plugin that fails to load, a backup it can't write) go to standard
-/// error. Without a logger they were dropped.
-#[test]
-fn logged_warnings_reach_standard_error() {
-    let dir = sandbox("log");
-    let first = invoke(&dir, &["run", "--save", "s.scraft"]);
-    assert_eq!(first.code, 0, "{}", first.stderr);
-    // A file where the backups folder should go: the next save that changes the session can't
-    // back the old one up.
-    std::fs::write(dir.join("Backups"), b"not a folder").unwrap();
-    let again = invoke(&dir, &["run", "--in", "s.scraft", "--cmd", r#"track.new={"count":1}"#, "--save", "s.scraft", "--in-place"]);
-    assert_eq!(again.code, 0, "{}", again.stderr);
-    assert!(again.stderr.contains("warning: no backup of"), "{}", again.stderr);
-    assert!(!again.stdout.contains("no backup"), "results only on standard output: {}", again.stdout);
-    let _ = std::fs::remove_dir_all(&dir);
-}
-
 // ---- unknown flags ----
 
 #[test]

crates/clap-host/src/ffi.rs

@@ -27,7 +27,6 @@ use clap_sys::ext::note_ports::{CLAP_EXT_NOTE_PORTS, clap_note_port_info, clap_p
 use clap_sys::ext::params::{
     CLAP_EXT_PARAMS, clap_host_params, clap_param_clear_flags, clap_param_info, clap_param_rescan_flags, clap_plugin_params,
 };
-use clap_sys::ext::render::{CLAP_EXT_RENDER, CLAP_RENDER_OFFLINE, CLAP_RENDER_REALTIME, clap_plugin_render};
 use clap_sys::ext::state::{CLAP_EXT_STATE, clap_host_state, clap_plugin_state};
 use clap_sys::factory::plugin_factory::{CLAP_PLUGIN_FACTORY_ID, clap_plugin_factory};
 use clap_sys::fixedpoint::{CLAP_BEATTIME_FACTOR, CLAP_SECTIME_FACTOR};

crates/clap-host/src/ffi/bundle.rs

@@ -7,7 +7,6 @@ use super::{
     clap_host, clap_plugin_audio_ports, clap_plugin_entry, clap_plugin_factory, clap_plugin_gui, clap_plugin_latency, clap_plugin_note_ports,
     clap_plugin_params, clap_plugin_state, clap_version_is_compatible, read_cstr, scan,
 };
-use super::{CLAP_EXT_RENDER, clap_plugin_render};
 
 // ---- loaded binaries -----------------------------------------------------------------------
 
@@ -43,16 +42,6 @@ fn loaded() -> &'static Mutex<HashMap<PathBuf, Arc<Bundle>>> {
     L.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
-/// A libloading error with the system's reason. libloading's own text is only "dlopen failed"
-/// (or "dlsym failed", "LoadLibraryExW failed"); the reason (`dlerror`, the Windows error) is its
-/// source.
-fn with_reason(e: &libloading::Error) -> String {
-    match std::error::Error::source(e) {
-        Some(why) => format!("{e}: {why}"),
-        None => e.to_string(),
-    }
-}
-
 impl Bundle {
     /// Loads (once per path, then cached for the life of the process) and initialises a `.clap`.
     pub fn load(path: &Path) -> Result<Arc<Bundle>, ClapError> {
@@ -70,12 +59,12 @@ impl Bundle {
         let exe = scan::bundle_executable(path).ok_or_else(|| err("no loadable binary".into()))?;
         // SAFETY: loading a shared library runs its static initialisers. That is inherent to
         // hosting plugins; we only load files found in CLAP plugin folders or named explicitly.
-        let lib = unsafe { libloading::Library::new(&exe) }.map_err(|e| err(with_reason(&e)))?;
+        let lib = unsafe { libloading::Library::new(&exe) }.map_err(|e| err(e.to_string()))?;
         // SAFETY: `clap_entry` is the CLAP-mandated exported data symbol of type
         // `const clap_plugin_entry`; the symbol's address is therefore a `*const clap_plugin_entry`.
         let entry: *const clap_plugin_entry = match unsafe { lib.get::<*const clap_plugin_entry>(b"clap_entry\0") } {
             Ok(sym) => *sym,
-            Err(e) => return Err(err(format!("not a CLAP plugin (no clap_entry): {}", with_reason(&e)))),
+            Err(e) => return Err(err(format!("not a CLAP plugin: {e}"))),
         };
         if entry.is_null() {
             return Err(err("null clap_entry".into()));
@@ -189,7 +178,6 @@ impl Bundle {
             latency: std::ptr::null(),
             notes: std::ptr::null(),
             state_ext: std::ptr::null(),
-            render: std::ptr::null(),
             gui: Arc::new(GuiLink::default()),
             raw: Vec::with_capacity(EVENT_CAP),
             out_params: Vec::with_capacity(EVENT_CAP),
@@ -217,7 +205,6 @@ impl Bundle {
         inst.latency = inst.extension::<clap_plugin_latency>(CLAP_EXT_LATENCY);
         inst.notes = inst.extension::<clap_plugin_note_ports>(CLAP_EXT_NOTE_PORTS);
         inst.state_ext = inst.extension::<clap_plugin_state>(CLAP_EXT_STATE);
-        inst.render = inst.extension::<clap_plugin_render>(CLAP_EXT_RENDER);
         let gui = inst.extension::<clap_plugin_gui>(CLAP_EXT_GUI);
         inst.gui = Arc::new(GuiLink {
             inner: Mutex::new(GuiInner { plugin, gui, state: inst.state_ext, alive: true, created: false, visible: false, window: None }),

crates/clap-host/src/ffi/instance.rs

@@ -8,7 +8,6 @@ use super::{
     clap_plugin, clap_plugin_audio_ports, clap_plugin_latency, clap_plugin_note_ports, clap_plugin_params, clap_plugin_state, clap_process,
     read_name,
 };
-use super::{CLAP_RENDER_OFFLINE, CLAP_RENDER_REALTIME, clap_plugin_render};
 
 // ---- audio buffers -------------------------------------------------------------------------
 
@@ -100,7 +99,6 @@ pub(crate) struct Instance {
     pub(super) latency: *const clap_plugin_latency,
     pub(super) notes: *const clap_plugin_note_ports,
     pub(super) state_ext: *const clap_plugin_state,
-    pub(super) render: *const clap_plugin_render,
     pub(super) gui: Arc<GuiLink>,
     pub(super) raw: Vec<RawEvent>,
     /// Parameter values the plugin reported through output events in the current `process`.
@@ -160,16 +158,6 @@ impl Instance {
         unsafe { load(self.plugin, &stream) }
     }
 
-    /// `clap_plugin_render.set`: offline (no realtime pressure) or realtime. `false` without the
-    /// extension or when the plugin can't switch.
-    pub fn set_render_mode(&self, offline: bool) -> bool {
-        // SAFETY: the extension pointer, when non-null, points to a static vtable in the plugin.
-        let Some(set) = (unsafe { self.render.as_ref() }).and_then(|r| r.set) else { return false };
-        let mode = if offline { CLAP_RENDER_OFFLINE } else { CLAP_RENDER_REALTIME };
-        // SAFETY: valid instance, called from the thread that owns it.
-        unsafe { set(self.plugin, mode) }
-    }
-
     /// Runs `on_main_thread` if the plugin asked for a callback.
     pub fn service_callback(&mut self) {
         if self.state.callback.swap(false, Ordering::Relaxed)

crates/clap-host/src/lib.rs

@@ -262,17 +262,4 @@ mod tests {
         assert!(instantiate("clap:does.not.exist").is_err());
         let _ = std::fs::remove_dir_all(&d);
     }
-
-    /// A binary the system refuses to load reports the system's reason (missing library, wrong
-    /// glibc, not an ELF file), not just "dlopen failed".
-    #[test]
-    fn a_binary_that_does_not_load_says_why() {
-        let d = fresh_private_dir("soundcraft-clap-reason");
-        let f = d.join("garbage.clap");
-        std::fs::write(&f, b"\x7fELF this is not a plugin \x00\x01\x02").unwrap();
-        let msg = load_bundle(&f).err().map(|e| e.to_string()).unwrap_or_default();
-        let reason = msg.split_once("failed: ").map_or("", |(_, r)| r.trim());
-        assert!(!reason.is_empty(), "no reason in: {msg}");
-        let _ = std::fs::remove_dir_all(&d);
-    }
 }

crates/clap-host/src/plugin.rs

@@ -178,11 +178,6 @@ impl Plugin for ClapPlugin {
         }
     }
 
-    fn set_offline(&mut self, offline: bool) {
-        // `clap.render`: plugins without it render the same way either way.
-        self.inst.set_render_mode(offline);
-    }
-
     fn reset(&mut self) {
         self.inst.reset();
         self.queue.retain(|e| matches!(e, Event::Param { .. }));

crates/clap-host/src/scan.rs

@@ -150,9 +150,7 @@ mod tests {
     fn tmp(name: &str) -> PathBuf {
         let d = std::env::temp_dir().join(format!("soundcraft-clap-scan-{name}-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&d);
-        // Created exclusively: a folder still there after the cleanup (someone else's) would
-        // let a link inside it redirect the test's writes.
-        std::fs::create_dir(&d).unwrap();
+        std::fs::create_dir_all(&d).unwrap();
         d
     }
 

crates/clap-host/tests/fixture/src/lib.rs

@@ -9,8 +9,7 @@
 //! - `org.soundcraft.test.wide16`, `.wide17ports`, `.wide65ch`: effects advertising wide layouts
 //!   (16 ports of 64 channels, 17 ports of 2 channels, one port of 65 channels per direction).
 //!   `process` writes 1.0 into every output channel it was given when the host's buffers match the
-//!   advertised layout (2.0 once the host set the offline render mode through `clap.render`), -1.0
-//!   when they do not.
+//!   advertised layout, -1.0 when they do not.
 //!
 //! The gain plugin also implements `clap.state` (gain and mode as two little-endian f64s) and a
 //! floating-only `clap.gui` without a real window: showing it "edits" the gain to 0.25 in the GUI,
@@ -28,7 +27,6 @@ use clap_sys::ext::latency::*;
 use clap_sys::ext::log::*;
 use clap_sys::ext::note_ports::*;
 use clap_sys::ext::params::*;
-use clap_sys::ext::render::*;
 use clap_sys::factory::plugin_factory::*;
 use clap_sys::host::clap_host;
 use clap_sys::id::clap_id;
@@ -104,8 +102,6 @@ struct Fx {
     gui_created: bool,
     gui_visible: bool,
     gui_edit_pending: bool,
-    /// `clap.render` set the offline mode (wide fixtures only).
-    offline: bool,
 }
 
 unsafe fn fx<'a>(p: *const clap_plugin) -> &'a mut Fx {
@@ -193,8 +189,8 @@ fn apply(f: &mut Fx, h: &clap_event_header) {
     }
 }
 
-/// Fill every output channel with `fit` when all ports have the wide layout, else -1.0.
-unsafe fn fill_wide(pr: &clap_process, ports: u32, channels: u32, n: usize, fit: f32) {
+/// Fill every output channel with 1.0 when all ports have the wide layout, else -1.0.
+unsafe fn fill_wide(pr: &clap_process, ports: u32, channels: u32, n: usize) {
     let fits = |bufs: *const clap_audio_buffer, n: u32| {
         n == ports && (0..n as usize).all(|i| unsafe { &*bufs.add(i) }.channel_count == channels)
     };
@@ -204,7 +200,7 @@ unsafe fn fill_wide(pr: &clap_process, ports: u32, channels: u32, n: usize, fit:
         for c in 0..out.channel_count as usize {
             let o = unsafe { *out.data32.add(c) };
             for i in 0..n {
-                unsafe { *o.add(i) = if ok { fit } else { -1.0 } };
+                unsafe { *o.add(i) = if ok { 1.0 } else { -1.0 } };
             }
         }
     }
@@ -256,7 +252,7 @@ unsafe extern "C" fn process(p: *const clap_plugin, pr: *const clap_process) ->
     let ev = unsafe { &*pr.in_events };
     let count = unsafe { (ev.size.unwrap())(pr.in_events) };
     if let Some((ports, channels)) = f.wide {
-        unsafe { fill_wide(pr, ports, channels, n, if f.offline { 2.0 } else { 1.0 }) };
+        unsafe { fill_wide(pr, ports, channels, n) };
         return CLAP_PROCESS_CONTINUE;
     }
     if pr.audio_outputs_count != 1 {
@@ -547,17 +543,6 @@ static GUI: clap_plugin_gui = clap_plugin_gui {
     hide: Some(gui_hide),
 };
 
-unsafe extern "C" fn render_hard_realtime(_p: *const clap_plugin) -> bool {
-    false
-}
-
-unsafe extern "C" fn render_set(p: *const clap_plugin, mode: clap_plugin_render_mode) -> bool {
-    unsafe { fx(p) }.offline = mode == CLAP_RENDER_OFFLINE;
-    true
-}
-
-static RENDER: clap_plugin_render = clap_plugin_render { has_hard_realtime_requirement: Some(render_hard_realtime), set: Some(render_set) };
-
 unsafe extern "C" fn get_extension(p: *const clap_plugin, id: *const c_char) -> *const c_void {
     let id = unsafe { CStr::from_ptr(id) };
     let synth = unsafe { fx(p) }.synth;
@@ -573,8 +558,6 @@ unsafe extern "C" fn get_extension(p: *const clap_plugin, id: *const c_char) ->
         &STATE as *const _ as *const c_void
     } else if id == CLAP_EXT_GUI && !synth {
         &GUI as *const _ as *const c_void
-    } else if id == CLAP_EXT_RENDER && unsafe { fx(p) }.wide.is_some() {
-        &RENDER as *const _ as *const c_void
     } else {
         std::ptr::null()
     }
@@ -640,7 +623,6 @@ unsafe extern "C" fn factory_create(_f: *const clap_plugin_factory, host: *const
         gui_created: false,
         gui_visible: false,
         gui_edit_pending: false,
-        offline: false,
     });
     let raw = Box::into_raw(b);
     unsafe {

crates/clap-host/tests/it/fixture_e2e.rs

@@ -130,19 +130,6 @@ fn layouts_beyond_the_host_limits_are_rejected_not_truncated() {
     }
 }
 
-#[test]
-fn offline_renders_set_the_render_mode() {
-    fixture_dir();
-    for (offline, want) in [(false, 1.0), (true, 2.0)] {
-        let mut p = soundcraft_clap_host::create("clap:org.soundcraft.test.wide16").unwrap();
-        p.set_offline(offline);
-        p.prepare(44_100.0, 64, 2);
-        let mut io = vec![vec![0.5f32; 64]; 2];
-        p.process(&mut io, 64);
-        assert!(io.iter().flatten().all(|&x| x == want), "offline {offline}: {:?}", &io[0][..4]);
-    }
-}
-
 #[test]
 fn many_instances_create_and_drop_cleanly() {
     fixture_dir();

crates/dsp/src/lib.rs

@@ -195,11 +195,6 @@ pub struct Transport {
 pub trait Plugin: Send {
     fn info(&self) -> &'static PluginInfo;
     fn prepare(&mut self, sample_rate: f32, max_block: usize, channels: usize);
-    /// The plugin renders offline (a bounce: faster or slower than realtime, no deadline) rather
-    /// than in realtime. Hosted plugins pass it on (VST3 `processMode`, CLAP `clap.render`): some
-    /// use better algorithms then, or wait for what they load instead of playing on without it.
-    /// Called before `prepare`; plugins are realtime until told otherwise.
-    fn set_offline(&mut self, _offline: bool) {}
     fn reset(&mut self);
     /// Sets a parameter (clamped into range; NaN becomes the default). `false` if `id` is unknown.
     fn set_param(&mut self, id: &str, value: f32) -> bool;

crates/engine/src/autosave.rs

@@ -212,9 +212,6 @@ impl Autosave {
         let audio_dir = self.dir.join("Audio Files");
         let mut s = session.clone();
         let mut copies = BTreeMap::new();
-        // Copies made in this write, by the audio they hold: sources sharing one decoded buffer
-        // (a session may name one file under many ids) share one file.
-        let mut written: BTreeMap<*const SourceAudio, String> = BTreeMap::new();
         for src in &mut s.sources {
             let file = if Path::new(&src.path).is_absolute() { Some(PathBuf::from(&src.path)) } else { base.as_ref().map(|b| b.join(&src.path)) };
             let audio = s.pool.get(src.id);
@@ -227,7 +224,6 @@ impl Autosave {
             let Some(audio) = audio else { continue };
             let name = match self.copies.remove(&src.id) {
                 Some((copy, name)) if copy.upgrade().is_some_and(|a| Arc::ptr_eq(&a, audio)) => name,
-                _ if written.contains_key(&Arc::as_ptr(audio)) => written.get(&Arc::as_ptr(audio)).cloned().unwrap_or_default(),
                 _ => {
                     let name = format!("{} {}.wav", sanitize_name(&src.name), self.next);
                     self.next += 1;
@@ -239,16 +235,13 @@ impl Autosave {
             };
             src.path = audio_dir.join(&name).to_string_lossy().into_owned();
             src.unsaved = true;
-            written.insert(Arc::as_ptr(audio), name.clone());
             copies.insert(src.id, (Arc::downgrade(audio), name));
         }
         let text = s.to_json().map_err(|err| EngineError::Io(err.to_string()))?;
         write_atomically(&self.dir.join(ORIGIN), origin.unwrap_or_default().as_bytes())?;
         write_atomically(&self.dir.join(SESSION), text.as_bytes())?;
         for (_, name) in std::mem::replace(&mut self.copies, copies).into_values() {
-            if !self.copies.values().any(|(_, kept)| *kept == name) {
-                let _ = std::fs::remove_file(audio_dir.join(name));
-            }
+            let _ = std::fs::remove_file(audio_dir.join(name));
         }
         if let Some(r) = recording {
             let plan = serde_json::to_string(r).map_err(|err| EngineError::Io(err.to_string()))?;
@@ -514,25 +507,6 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
-    #[test]
-    fn sources_sharing_one_buffer_share_one_copy() {
-        let dir = folder("autosave-aliases");
-        let mut e = Engine::default();
-        record(&mut e, 0.5);
-        // Nine more source ids over the same decoded audio, as a session file may declare.
-        let s = e.session_mut();
-        let (src, audio) = (s.sources[0].clone(), s.pool.get(s.sources[0].id).cloned().unwrap());
-        for _ in 0..9 {
-            let id = SourceId(s.alloc());
-            s.sources.push(soundcraft_model::Source { id, ..src.clone() });
-            s.pool.insert(id, audio.clone());
-        }
-        let mut a = Autosave::create(&dir.join("Autosave"), "Song").unwrap();
-        a.write(e.session(), None, None).unwrap();
-        assert_eq!(std::fs::read_dir(a.dir.join("Audio Files")).unwrap().count(), 1, "one file for the ten ids");
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
     #[test]
     fn a_take_recorded_after_undo_gets_its_own_copy() {
         let dir = folder("autosave-undo");

crates/engine/src/clip_group_file.rs

@@ -87,16 +87,23 @@ fn decode_group_audio(
     cmd_id: &str,
 ) -> Result<(Vec<(String, soundcraft_audio_io::AudioBuffer)>, BTreeMap<u64, usize>)> {
     let (mut decoded, mut index, mut file_of) = (Vec::new(), BTreeMap::new(), BTreeMap::new());
+    // The folder as the file system knows it, so a link among the group's files can't lead out.
+    let dir = if dir.as_os_str().is_empty() { Path::new(".") } else { dir };
+    let root = crate::io::canonical_path(dir)?;
     for (old, rel) in audio_entries {
         let full = dir.join(rel);
+        let escapes = |rel: &str| EngineError::BadParams(cmd_id.into(), format!("audio path escapes the group folder: {rel}"));
         if !full.starts_with(dir)
             || Path::new(rel)
                 .components()
                 .any(|c| matches!(c, std::path::Component::ParentDir | std::path::Component::RootDir | std::path::Component::Prefix(_)))
         {
-            return Err(EngineError::BadParams(cmd_id.into(), format!("audio path escapes the group folder: {rel}")));
+            return Err(escapes(rel));
+        }
+        let key = crate::io::canonical_path(&full)?;
+        if !key.starts_with(&root) {
+            return Err(escapes(rel));
         }
-        let key = crate::io::file_key(&full);
         let n = match index.get(&key) {
             Some(n) => *n,
             None => {
@@ -268,9 +275,59 @@ mod tests {
         std::fs::write(&path, file.to_string()).unwrap();
         let r = e.execute("file.import_clip_groups", &json!({"path": path, "at": 1000, "track": "Bass"}));
         assert!(matches!(r, Err(crate::EngineError::BadParams(..))), "absolute paths are refused: {r:?}");
+        // A link inside the folder that leads out of it is refused once resolved.
+        #[cfg(unix)]
+        {
+            let outside = std::env::temp_dir().join(format!("sc-grp-outside-{}.wav", std::process::id()));
+            std::fs::copy(dir.join("Wait... what_0.wav"), &outside).unwrap();
+            std::os::unix::fs::symlink(&outside, dir.join("link.wav")).unwrap();
+            for rel in file["audio"].as_object_mut().unwrap().values_mut() {
+                *rel = json!("link.wav");
+            }
+            std::fs::write(&path, file.to_string()).unwrap();
+            let r = e.execute("file.import_clip_groups", &json!({"path": path, "at": 1000, "track": "Bass"}));
+            assert!(matches!(r, Err(crate::EngineError::BadParams(..))), "links out of the folder are refused: {r:?}");
+            let _ = std::fs::remove_file(&outside);
+        }
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// Under a read root, a link in the group folder to a folder outside the root is refused the same way
+    /// whether or not the file asked for exists there, so the group cannot be used to probe for names.
+    #[cfg(unix)]
+    #[test]
+    fn links_out_of_the_read_root_are_refused_alike_for_existing_and_missing_files() {
+        let base = std::env::temp_dir().join(format!("sc-grp-root-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&base);
+        let (dir, outside) = (base.join("group"), base.join("outside"));
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::create_dir_all(&outside).unwrap();
+        let path = dir.join("drums.scgrp").to_string_lossy().to_string();
+        let mut e = crate::demo::demo_engine();
+        let kick = e.session().tracks.iter().find(|t| t.name == "Kick").map(|t| t.id).unwrap();
+        let ids: Vec<_> = e.session().track(kick).unwrap().clips().iter().take(1).map(|c| c.id.0).collect();
+        e.execute("file.export_clip_groups", &json!({"path": path, "clips": ids})).unwrap();
+        let mut file: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
+        let exported = file["audio"].as_object().unwrap().values().next().unwrap().as_str().unwrap().to_string();
+        std::fs::copy(dir.join(&exported), outside.join("real.wav")).unwrap();
+        std::os::unix::fs::symlink(&outside, dir.join("out")).unwrap();
+        let roots = crate::file_access::AutomationRoots::new(&[&dir], &[]).unwrap().unwrap();
+        let mut refusals = Vec::new();
+        for target in ["out/real.wav", "out/missing.wav"] {
+            for rel in file["audio"].as_object_mut().unwrap().values_mut() {
+                *rel = json!(target);
+            }
+            std::fs::write(&path, file.to_string()).unwrap();
+            let r = crate::file_access::confine(Some(&roots), || {
+                e.execute("file.import_clip_groups", &json!({"path": path, "at": 1000, "track": "Bass"}))
+            });
+            refusals.push(r.unwrap_err().to_string());
+        }
+        assert!(refusals[0].contains("outside the read root"), "{}", refusals[0]);
+        assert_eq!(refusals[0].replace("real.wav", "X"), refusals[1].replace("missing.wav", "X"), "existing and missing names are refused alike");
+        let _ = std::fs::remove_dir_all(&base);
+    }
+
     #[test]
     fn imported_clips_carry_no_auto_rename_scheme() {
         let dir = std::env::temp_dir().join(format!("sc-grp-names-{}", std::process::id()));

crates/engine/src/cmd.rs

@@ -347,10 +347,7 @@ pub fn clip_id(p: &Value, cmd: &str) -> Result<ClipId> {
 
 pub fn clip_ids_param(e: &Engine, p: &Value) -> Vec<ClipId> {
     if let Some(arr) = p.get("clips").and_then(Value::as_array) {
-        // Each clip once, in the order given: a repeated id would otherwise be processed (and,
-        // for a render, re-rendered into another source) once per repeat.
-        let mut seen = std::collections::HashSet::new();
-        return arr.iter().filter_map(Value::as_u64).map(ClipId).filter(|id| seen.insert(*id)).collect();
+        return arr.iter().filter_map(Value::as_u64).map(ClipId).collect();
     }
     if let Some(n) = p.get("clip").and_then(Value::as_u64) {
         return vec![ClipId(n)];

crates/engine/src/cmd/audiosuite.rs

@@ -14,7 +14,7 @@ pub fn specs() -> Vec<CommandSpec> {
         "AudioSuite Process",
         [],
         None,
-        "{process: <built-in plugin id (engine.plugins)> | normalize | reverse | invert | gain | duplicate | time_stretch | pitch_shift | varispeed | speed_ramp | signal_generator, params?: {..}, clips?, tracks?, start?, end?} — signal_generator fills start..end (default: the selection) with a new clip on each audio track in `tracks` (default: the selected tracks); speed_ramp takes change (0 slow down, 1 speed up), selection (0 fit to, 1 extend) and fades (1 on, 0 off)",
+        "{process: <plugin id> | normalize | reverse | invert | gain | duplicate | time_stretch | pitch_shift | varispeed | speed_ramp | signal_generator, params?: {..}, clips?, tracks?, start?, end?} — signal_generator fills start..end (default: the selection) with a new clip on each audio track in `tracks` (default: the selected tracks); speed_ramp takes change (0 slow down, 1 speed up), selection (0 fit to, 1 extend) and fades (1 on, 0 off)",
         has_selection,
         process
     )]
@@ -55,9 +55,6 @@ fn process(e: &mut Engine, p: &Value) -> Result<Value> {
                 | "speed_ramp"
                 | "dc_offset_removal"
         );
-    if !known && soundcraft_mix::is_third_party(&name) {
-        return Err(bad("audiosuite.process", format!("`{name}` is a hosted plugin; AudioSuite runs built-in plugins only (engine.plugins)")));
-    }
     if !known {
         return Err(bad("audiosuite.process", format!("unknown process `{name}`")));
     }
@@ -231,17 +228,6 @@ mod tests {
         (crate::Engine::new(s), id)
     }
 
-    #[test]
-    fn hosted_plugin_ids_are_refused_with_the_reason() {
-        let (mut e, id) = gained_clip();
-        for plugin in ["clap:com.example.reverb", "vst3:00112233445566778899AABBCCDDEEFF", "au:aufx:dely:appl"] {
-            let err = e.execute("audiosuite.process", &json!({"process": plugin, "clips": [id.0]})).unwrap_err().to_string();
-            assert!(err.contains("built-in"), "{plugin}: {err}");
-        }
-        let spec = specs().into_iter().find(|s| s.id == "audiosuite.process").unwrap();
-        assert!(spec.params.contains("<built-in plugin id"), "the help says which ids it takes: {}", spec.params);
-    }
-
     #[test]
     fn invert_and_duplicate_keep_clip_gain() {
         let (mut e, id) = gained_clip();

crates/engine/src/cmd/mix.rs

@@ -598,7 +598,6 @@ fn write_current(e: &mut Engine, p: &Value, all: bool) -> Result<Value> {
 }
 
 /// Clip-gain envelope value in dB. An empty envelope contributes nothing, and the last point holds.
-#[cfg(test)]
 fn env_db(env: &[(i64, f32)], at: i64) -> f32 {
     let mut prev: Option<(i64, f32)> = None;
     for &(t, v) in env {
@@ -613,38 +612,6 @@ fn env_db(env: &[(i64, f32)], at: i64) -> f32 {
     prev.map_or(0.0, |(_, v)| v)
 }
 
-/// Repeated lookups in one clip-gain envelope, each O(log n) instead of a walk from its start.
-/// Gives exactly what walking the points in stored order gives, sorted or not: the first point
-/// at or after `at` is the first whose running maximum position reaches `at`.
-struct EnvLookup<'a> {
-    env: &'a [(i64, f32)],
-    /// Largest position among `env[..=i]`.
-    reach: Vec<i64>,
-}
-
-impl<'a> EnvLookup<'a> {
-    fn new(env: &'a [(i64, f32)]) -> Self {
-        let reach = env
-            .iter()
-            .scan(i64::MIN, |m, &(t, _)| {
-                *m = (*m).max(t);
-                Some(*m)
-            })
-            .collect();
-        EnvLookup { env, reach }
-    }
-
-    /// Value in dB at `at` (see `env_db`).
-    fn db(&self, at: i64) -> f32 {
-        let i = self.reach.partition_point(|&m| m < at);
-        let Some(&(t, v)) = self.env.get(i) else { return self.env.last().map_or(0.0, |&(_, v)| v) };
-        match i.checked_sub(1).and_then(|p| self.env.get(p)) {
-            Some(&(pt, pv)) if t > pt => pv + (v - pv) * ((at - pt) as f32 / (t - pt) as f32),
-            _ => v,
-        }
-    }
-}
-
 /// Fold the volume `lane` into the gain envelope of clip `c` over the selection `r`.
 fn bake_volume_into_clip(c: &mut soundcraft_model::Clip, lane: &soundcraft_model::AutomationLane, base: f32, r: soundcraft_time::Range) {
     let delta = |at: i64| lane.value_at(at, base) - base;
@@ -654,41 +621,39 @@ fn bake_volume_into_clip(c: &mut soundcraft_model::Clip, lane: &soundcraft_model
         return;
     }
     let rel = |at: i64| at - c.start;
-    let old_env = std::mem::take(&mut c.gain_env);
-    let env = EnvLookup::new(&old_env);
-    let env_db = |at: i64| env.db(at);
     let rel0 = rel(sel0);
     let rel1 = rel(sel1);
     // Later writes win, so the selection anchors replace any point they land on.
-    let mut pts: Vec<(i64, f32)> = old_env.iter().copied().filter(|&(at, _)| at < rel0.saturating_sub(1) || (sel1 < c.end() && at > rel1)).collect();
+    let mut pts: Vec<(i64, f32)> =
+        c.gain_env.iter().copied().filter(|&(at, _)| at < rel0.saturating_sub(1) || (sel1 < c.end() && at > rel1)).collect();
     if rel0 > 0 {
-        pts.push((rel0 - 1, env_db(rel0 - 1)));
+        pts.push((rel0 - 1, env_db(&c.gain_env, rel0 - 1)));
     }
-    pts.push((rel0, env_db(rel0) + delta(sel0)));
+    pts.push((rel0, env_db(&c.gain_env, rel0) + delta(sel0)));
     for pt in lane.points.iter().filter(|pt| pt.at > sel0 && pt.at < sel1) {
         let at = rel(pt.at);
-        pts.push((at, env_db(at) + delta(pt.at)));
+        pts.push((at, env_db(&c.gain_env, at) + delta(pt.at)));
     }
     // The clip's own gain points inside the selection keep their shape, offset by the lane.
-    for &(at, _) in old_env.iter().filter(|&&(at, _)| at > rel0 && at < rel1) {
-        pts.push((at, env_db(at) + delta(c.start.saturating_add(at))));
+    for &(at, _) in c.gain_env.iter().filter(|&&(at, _)| at > rel0 && at < rel1) {
+        pts.push((at, env_db(&c.gain_env, at) + delta(c.start.saturating_add(at))));
     }
     if sel1 - 1 > sel0 {
         let at = rel(sel1 - 1);
-        pts.push((at, env_db(at) + delta(sel1 - 1)));
+        pts.push((at, env_db(&c.gain_env, at) + delta(sel1 - 1)));
     }
     if sel1 < c.end() {
-        pts.push((rel1, env_db(rel1)));
+        pts.push((rel1, env_db(&c.gain_env, rel1)));
     }
     pts.sort_by_key(|p| p.0);
-    let mut baked = Vec::new();
+    let mut env = Vec::new();
     for p in pts {
-        if baked.last().is_some_and(|q: &(i64, f32)| q.0 == p.0) {
-            baked.pop();
+        if env.last().is_some_and(|q: &(i64, f32)| q.0 == p.0) {
+            env.pop();
         }
-        baked.push(p);
+        env.push(p);
     }
-    c.gain_env = baked;
+    c.gain_env = env;
 }
 
 /// Clear the volume lane over `r` when the clips all sit inside it, else hold the fader there.
@@ -761,9 +726,8 @@ fn clip_gain_to_vol(e: &mut Engine, p: &Value) -> Result<Value> {
                 if let Some(l) = &old {
                     ats.extend(l.points.iter().map(|pt| pt.at).filter(|&at| at > c.start && at < c.end() - 1));
                 }
-                let env = EnvLookup::new(&c.gain_env);
                 for at in ats {
-                    pts.push((at, level(at) + c.gain_db + env.db(at - c.start)));
+                    pts.push((at, level(at) + c.gain_db + env_db(&c.gain_env, at - c.start)));
                 }
                 c.gain_db = 0.0;
                 c.gain_env.clear();

crates/engine/src/cmd/mix/tests.rs

@@ -345,36 +345,3 @@ fn insert_and_send_reject_invalid_slot() {
     let r = e.execute("mix.send", &json!({"track": "Gtr", "bus": "Verb"})).unwrap();
     assert_eq!(r["slot"], 0);
 }
-
-#[test]
-fn indexed_envelope_lookup_matches_the_walk() {
-    let envs: [Vec<(i64, f32)>; 5] = [
-        Vec::new(),
-        vec![(100, -3.0)],
-        vec![(0, 0.0), (100, -6.0), (100, 3.0), (250, -12.0), (900, 1.0)],
-        // Out of order, as a hand-edited session file may hold.
-        vec![(500, -1.0), (100, -6.0), (700, 4.0), (300, 2.0), (700, -9.0), (50, 0.5)],
-        (0..200).map(|i| ((i * 37) % 1000, (i as f32 * 0.7).sin() * 12.0)).collect(),
-    ];
-    for env in &envs {
-        let lookup = EnvLookup::new(env);
-        for at in -20..1100 {
-            assert_eq!(lookup.db(at).to_bits(), env_db(env, at).to_bits(), "{env:?} at {at}");
-        }
-    }
-}
-
-#[test]
-fn clip_gain_to_volume_with_a_large_envelope_stays_fast() {
-    let (mut e, t) = tone_session(&[]);
-    let clip = e.session().track(t).unwrap().clips()[0].id;
-    let n = 200_000i64;
-    let c = e.session_mut().find_clip_mut(clip).unwrap();
-    c.length = n * 5 + 10;
-    c.gain_env = (0..n).map(|i| (i * 5, if i % 2 == 0 { -6.0 } else { 0.0 })).collect();
-    let start = std::time::Instant::now();
-    e.execute("automation.clip_gain_to_volume", &json!({"track": t.0, "start": 0, "end": n * 5 + 10})).unwrap();
-    assert!(start.elapsed() < std::time::Duration::from_secs(10), "{:?}", start.elapsed());
-    let lane = e.session().track(t).unwrap().lane(&AutoParam::Volume).unwrap();
-    assert!(lane.points.len() as i64 >= n);
-}

crates/engine/src/cmd/view.rs

@@ -96,22 +96,14 @@ pub fn specs() -> Vec<CommandSpec> {
 
 const MIN_SPP: f64 = 0.25;
 const MAX_SPP: f64 = 1_000_000.0;
-/// Pixel column an off-screen edit cursor is brought to when zooming (the engine does not know the viewport width).
-const OFFSCREEN_CURSOR_PX: f64 = 500.0;
 
 fn zoom(e: &mut Engine, f: f64, x: Option<f64>) -> Result<Value> {
     let insertion = e.session().edit.selection.start as f64;
     let z = e.zoom_mut();
     let (old, scroll) = (z.samples_per_px, z.scroll as f64);
     let new = (old * f).clamp(MIN_SPP, MAX_SPP);
-    // Without a pointer, the edit cursor is the reference: held in place when visible, centred when off-screen.
-    let cursor_x = (insertion - scroll) / old;
-    if let Some(x) = x {
+    if let Some(x) = x.or_else(|| Some((insertion - scroll) / old).filter(|x| (0.0..4000.0).contains(x))) {
         z.scroll = soundcraft_time::to_samples(scroll + x * (old - new)).clamp(0, MAX_POSITION);
-    } else if (0.0..4000.0).contains(&cursor_x) {
-        z.scroll = soundcraft_time::to_samples(scroll + cursor_x * (old - new)).clamp(0, MAX_POSITION);
-    } else {
-        z.scroll = soundcraft_time::to_samples(insertion - OFFSCREEN_CURSOR_PX * new).clamp(0, MAX_POSITION);
     }
     z.samples_per_px = new;
     Ok(json!({"samples_per_px": new, "scroll": z.scroll}))
@@ -194,17 +186,6 @@ mod tests {
         assert_eq!(view(&e), (100.0, 48_000));
     }
 
-    #[test]
-    fn zoom_in_brings_an_offscreen_edit_cursor_into_view() {
-        let mut e = Engine::default();
-        e.execute("view.zoom_set", &json!({"samples_per_px": 100.0})).unwrap();
-        e.execute("edit.select", &json!({"start": 1_000_000, "end": 1_000_000})).unwrap();
-        e.execute("view.zoom_in", &json!({})).unwrap();
-        let (spp, scroll) = view(&e);
-        let x = (1_000_000.0 - scroll as f64) / spp;
-        assert!((x - OFFSCREEN_CURSOR_PX).abs() < 1.0, "cursor at {x}px");
-    }
-
     #[test]
     fn zoom_and_scroll_stay_in_range() {
         let mut e = Engine::default();

crates/engine/src/io.rs

@@ -85,6 +85,17 @@ pub(crate) fn make_dir(dir: impl AsRef<Path>) -> Result<()> {
     std::fs::create_dir_all(dir).map_err(|err| EngineError::Io(format!("{}: {err}", dir.display())))
 }
 
+/// `path` with its links followed, inside the automation read root when there is one. The root is
+/// checked on the path as named (links followed, a missing tail resolved by its nearest folder)
+/// before anything is resolved, so a name that leads out of the root is refused the same way
+/// whether or not it exists there.
+pub(crate) fn canonical_path(path: impl AsRef<Path>) -> Result<PathBuf> {
+    let path = path.as_ref();
+    let checked = if path.as_os_str().is_empty() { Path::new(".") } else { path };
+    crate::file_access::check_read(checked).map_err(EngineError::Io)?;
+    std::fs::canonicalize(path).map_err(|err| EngineError::Io(format!("{}: {err}", path.display())))
+}
+
 /// Write `bytes` to the file at `path`, inside the automation write root when there is one.
 pub(crate) fn write_path(path: impl AsRef<Path>, bytes: impl AsRef<[u8]>) -> Result<()> {
     let path = path.as_ref();
@@ -178,13 +189,6 @@ pub struct Bounce {
     enc: Option<soundcraft_audio_io::FileEncoder<Out>>,
 }
 
-/// The Broadcast Wave stamp of timeline position `at`: the session's timecode start plus `at`, in
-/// samples since midnight (`bext` TimeReference; 0 before midnight).
-fn time_stamp(s: &Session, at: Samples) -> soundcraft_audio_io::BwfInfo {
-    let time_reference = u64::try_from(s.timecode_start.saturating_add(at)).unwrap_or(0);
-    soundcraft_audio_io::BwfInfo { time_reference, ..Default::default() }
-}
-
 /// A finished bounce: the size of its file and its levels.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Bounced {
@@ -215,9 +219,6 @@ impl Bounce {
         let part = path.with_file_name(format!("{name}.part"));
         crate::file_access::check_write(path).map_err(EngineError::Io)?;
         crate::file_access::check_write(&part).map_err(EngineError::Io)?;
-        // A WAV bounce says where it starts on the session's timecode, as other DAWs' bounces do,
-        // so post and broadcast tools can place it (only WAV has a `bext` chunk to say it in).
-        let opts = &EncodeOptions { bwf: opts.bwf.clone().or_else(|| Some(time_stamp(&s, r.start))), ..opts.clone() };
         let enc = (|| -> std::result::Result<_, soundcraft_audio_io::AudioError> {
             let enc = soundcraft_audio_io::FileEncoder::new(Out::create(&part)?, opts, channels, s.sample_rate.hz(), Some(fmt.channel_mask()))?;
             enc.check_room(u64::try_from(r.len()).unwrap_or(0))?;
@@ -339,7 +340,7 @@ impl Out {
         if cfg!(target_arch = "wasm32") {
             return Ok(Out::Memory(std::io::Cursor::new(Vec::new())));
         }
-        Ok(Out::File(std::io::BufWriter::with_capacity(1 << 20, std::fs::File::create(part)?)))
+        Ok(Out::File(std::io::BufWriter::with_capacity(1 << 20, create_new(part)?)))
     }
 
     /// Puts the finished file at `path` and returns its size: the part file is synced and renamed
@@ -472,14 +473,27 @@ pub fn export_clips(e: &Engine, ids: &[soundcraft_model::ClipId], dir: &str) ->
         let stem = sanitize_name(&c.name);
         let mut path = Path::new(dir).join(format!("{stem}.wav"));
         let mut k = 2u32;
-        while path.exists() {
+        // The name is taken by creating the file, so whatever entry already has it (a link
+        // to elsewhere included) is left alone rather than written through.
+        let mut file = loop {
+            // An occupied name is taken whatever it is (a link whose target is outside the write
+            // root too): it is only looked at, never resolved, so the root check does not stop the
+            // search for a free name. The folder itself was checked above.
+            if std::fs::symlink_metadata(&path).is_err() {
+                crate::file_access::check_write(&path).map_err(EngineError::Io)?;
+                match std::fs::OpenOptions::new().write(true).create_new(true).open(&path) {
+                    Ok(f) => break f,
+                    Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {}
+                    Err(err) => return Err(EngineError::Io(format!("{}: {err}", path.display()))),
+                }
+            }
             path = Path::new(dir).join(format!("{stem}-{k}.wav"));
             k = k.saturating_add(1);
             if k > 10_000 {
                 return Err(EngineError::Io(format!("{dir}: too many files named {stem}")));
             }
-        }
-        write_path(&path, bytes)?;
+        };
+        std::io::Write::write_all(&mut file, &bytes).map_err(|err| EngineError::Io(format!("{}: {err}", path.display())))?;
         n += 1;
     }
     Ok(n)
@@ -516,13 +530,13 @@ fn write_session(session: &Session, path: &str, overwrite: bool) -> Result<(Sess
         {
             src.path = f.join(&src.path).to_string_lossy().into_owned();
         }
-        let exists_rel = same_dir && !Path::new(&src.path).is_absolute() && dir.join(&src.path).exists();
+        let exists_rel = same_dir && !Path::new(&src.path).is_absolute() && file_found(dir.join(&src.path));
         let shared = shared_paths.get(i).copied().unwrap_or(false);
         if exists_rel && !src.unsaved && !shared {
             continue;
         }
         let in_folder = Path::new(&src.path).strip_prefix(&audio_dir).ok().and_then(Path::to_str).map(str::to_string);
-        if let Some(f) = in_folder.filter(|_| !src.unsaved && Path::new(&src.path).is_file()) {
+        if let Some(f) = in_folder.filter(|_| !src.unsaved && file_found(&src.path)) {
             src.path = format!("Audio Files/{f}");
             continue;
         }
@@ -538,7 +552,7 @@ fn write_session(session: &Session, path: &str, overwrite: bool) -> Result<(Sess
         if overwrite {
             // One file per source id so autosaves never collide or pile up.
             stem = format!("{stem}_{}", src.id.0);
-            if audio_dir.join(format!("{stem}.wav")).exists() {
+            if file_found(audio_dir.join(format!("{stem}.wav"))) {
                 src.path = format!("Audio Files/{stem}.wav");
                 src.unsaved = false;
                 files.insert(Arc::as_ptr(audio), src.path.clone());
@@ -598,11 +612,22 @@ fn sync_dir(dir: &Path) {
 
 fn write_synced(path: &Path, bytes: &[u8]) -> std::io::Result<()> {
     use std::io::Write;
-    let mut f = std::fs::File::create(path)?;
+    let mut f = create_new(path)?;
     f.write_all(bytes)?;
     f.sync_all()
 }
 
+/// Creates `path` as a new file. A leftover of that name (a part file from an interrupted write)
+/// is removed first, but an existing entry is never opened: a link planted at a predictable name
+/// in the destination folder can't redirect the write elsewhere.
+fn create_new(path: &Path) -> std::io::Result<std::fs::File> {
+    match std::fs::remove_file(path) {
+        Err(err) if err.kind() != std::io::ErrorKind::NotFound => return Err(err),
+        _ => {}
+    }
+    std::fs::OpenOptions::new().write(true).create_new(true).open(path)
+}
+
 /// Copies `from` to `to`, which must not exist yet; an existing entry, even a link, is never followed.
 fn copy_new(from: &Path, to: &Path) -> std::io::Result<()> {
     let mut src = std::fs::File::open(from)?;
@@ -697,7 +722,12 @@ fn store_wav(dir: &Path, stem: &str, bytes: &[u8]) -> Result<(String, bool)> {
                 return Ok((name, true));
             }
             Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
-                if std::fs::metadata(&path).is_ok_and(|m| m.len() == bytes.len() as u64) && std::fs::read(&path).is_ok_and(|b| b == bytes) {
+                // Reused only when it may be read: whether it equals the audio must not be
+                // learnt about a file the roots allow writing beside but not reading.
+                if crate::file_access::check_read(&path).is_ok()
+                    && std::fs::metadata(&path).is_ok_and(|m| m.len() == bytes.len() as u64)
+                    && std::fs::read(&path).is_ok_and(|b| b == bytes)
+                {
                     return Ok((name, false));
                 }
             }
@@ -744,12 +774,6 @@ fn read_bundle(bytes: &[u8], limits: BundleLimits) -> Result<(String, std::colle
     if z.len() > limits.entries {
         return Err(EngineError::Io("bundle: too many files".into()));
     }
-    // Entries are stored, so the files we keep can only outgrow the bundle when several entries
-    // point at the same bytes: a small bundle naming one payload thousands of times would be
-    // copied out once per name.
-    if z.has_overlapping_files().map_err(zerr)? {
-        return Err(EngineError::Io("bundle: files share data".into()));
-    }
     let (mut text, mut files, mut total) = (None, std::collections::HashMap::new(), 0u64);
     for i in 0..z.len() {
         let mut f = z.by_index(i).map_err(zerr)?;
@@ -801,6 +825,67 @@ pub fn plan_takes(e: &Engine, unsaved_dir: &Path, input_channels: usize) -> Vec<
         .collect()
 }
 
+#[cfg(test)]
+mod exclusive_tests {
+    use super::*;
+
+    fn scratch(name: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("soundcraft-io-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn a_planted_link_at_the_part_name_is_not_written_through() {
+        let dir = scratch("part-link");
+        let (target, part) = (dir.join("elsewhere"), dir.join("session.scraft.tmp"));
+        std::os::unix::fs::symlink(&target, &part).unwrap();
+        write_synced(&part, b"new").unwrap();
+        assert!(!target.exists(), "the link's target was created");
+        assert_eq!(std::fs::read(&part).unwrap(), b"new", "the link itself was replaced by the file");
+        // A leftover regular part file is still replaced.
+        write_synced(&part, b"newer").unwrap();
+        assert_eq!(std::fs::read(&part).unwrap(), b"newer");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn export_skips_a_name_held_by_a_dangling_link() {
+        let dir = scratch("export-link");
+        let e = crate::demo::demo_engine();
+        let (t, c) = e.session().tracks.iter().find_map(|t| t.clips().iter().find(|c| c.is_audio()).map(|c| (t.id, c.clone()))).unwrap();
+        let _ = t;
+        let target = dir.join("elsewhere.wav");
+        std::os::unix::fs::symlink(&target, dir.join(format!("{}.wav", sanitize_name(&c.name)))).unwrap();
+        assert_eq!(export_clips(&e, &[c.id], &dir.to_string_lossy()).unwrap(), 1);
+        assert!(!target.exists(), "the export followed the link");
+        assert!(dir.join(format!("{}-2.wav", sanitize_name(&c.name))).is_file(), "the next free name was used");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// With a write root, a link out of it that holds the name is still just an occupied name.
+    #[cfg(unix)]
+    #[test]
+    fn export_skips_a_link_out_of_the_write_root_too() {
+        let dir = scratch("export-root-link");
+        let e = crate::demo::demo_engine();
+        let c = e.session().tracks.iter().find_map(|t| t.clips().iter().find(|c| c.is_audio()).cloned()).unwrap();
+        let elsewhere = scratch("export-root-elsewhere");
+        let target = elsewhere.join("target.wav");
+        std::os::unix::fs::symlink(&target, dir.join(format!("{}.wav", sanitize_name(&c.name)))).unwrap();
+        let roots = crate::file_access::AutomationRoots::new(&[], &[&dir]).unwrap().unwrap();
+        let n = crate::file_access::confine(Some(&roots), || export_clips(&e, &[c.id], &dir.to_string_lossy())).unwrap();
+        assert_eq!(n, 1);
+        assert!(!target.exists(), "the export followed the link out of the root");
+        assert!(dir.join(format!("{}-2.wav", sanitize_name(&c.name))).is_file(), "the next free name was used");
+        let _ = std::fs::remove_dir_all(&dir);
+        let _ = std::fs::remove_dir_all(&elsewhere);
+    }
+}
+
 #[cfg(test)]
 mod stem_tests {
     #[test]

crates/engine/src/io/bundle.rs

@@ -194,23 +194,6 @@ mod bundle_tests {
         }
     }
 
-    #[test]
-    fn entries_sharing_one_payload_are_refused() {
-        use std::io::Write as _;
-        let mut w = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
-        let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
-        w.start_file("Song.scraft", opts).unwrap();
-        w.write_all(Session::default().to_json().unwrap().as_bytes()).unwrap();
-        w.start_file("Audio Files/a.wav", opts).unwrap();
-        w.write_all(&[7u8; 4096]).unwrap();
-        for i in 0..100 {
-            w.shallow_copy_file("Audio Files/a.wav", &format!("Audio Files/copy{i}.wav")).unwrap();
-        }
-        let bundle = w.finish().unwrap().into_inner();
-        let err = read_bundle(&bundle, BUNDLE_LIMITS).unwrap_err();
-        assert!(err.to_string().contains("share data"), "{err}");
-    }
-
     #[test]
     fn a_bundle_is_saved_only_if_it_opens_again() {
         // #433: the writer keeps to the reader's limits.

crates/engine/src/score.rs

@@ -418,9 +418,7 @@ fn svg_budgeted(parts: &[Part], setup: &ScoreSetup, budget: usize) -> Result<Str
     const STAFF_GAP: f64 = 70.0;
     const SYSTEM_GAP: f64 = 40.0;
     let n_measures = parts.iter().map(|p| p.measures.len()).max().unwrap_or(0);
-    // The layout range the setup offers (1 to 16): a caller's own value can't multiply the
-    // barlines drawn per system beyond it.
-    let per = setup.bars_per_system.clamp(1, 16) as usize;
+    let per = setup.bars_per_system.max(1) as usize;
     let systems = n_measures.div_ceil(per).max(1);
     let label_w = if setup.show_track_names { 70.0 } else { 0.0 };
     let staff_x0 = MARGIN + label_w + 34.0;
@@ -784,14 +782,6 @@ mod tests {
         assert!(m.items.iter().any(|i| i.pitches.is_empty()), "the discarded suffix became rests");
     }
 
-    #[test]
-    fn bars_per_system_is_held_to_the_supported_range() {
-        let setup = ScoreSetup { title: "t".into(), composer: String::new(), bars_per_system: u32::MAX, show_track_names: false };
-        let part = Part { name: "p".into(), bass: false, measures: vec![Measure { numerator: 4, denominator: 4, items: Vec::new() }] };
-        let out = svg_budgeted(std::slice::from_ref(&part), &setup, 1 << 20).unwrap();
-        assert_eq!(out.matches("stroke-width=\"1\"").count(), 16, "sixteen barlines, not billions");
-    }
-
     #[test]
     fn oversized_title_is_refused_by_the_header_check() {
         // An oversized part name/title must be caught by the header check even with no measures:

crates/engine/tests/it/bounce.rs

@@ -123,38 +123,6 @@ fn a_bounce_too_big_for_its_format_fails_and_keeps_the_old_file() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
-/// A WAV bounce is a Broadcast Wave stamped with where it starts on the session's timecode (`bext`
-/// TimeReference, samples since midnight), as other DAWs write it, so post tools can place it.
-#[test]
-fn wav_bounces_carry_their_timecode_position_as_a_bwf_time_reference() {
-    let mut e = soundcraft_engine::demo::demo_engine();
-    let sr = u64::from(e.session().sample_rate.hz());
-    // The session starts at 01:00:00:00; the bounce at 2 s into it.
-    e.session_mut().timecode_start = (3600 * sr) as i64;
-    let (start, end) = (2 * sr, 3 * sr);
-    let dir = scratch("bounce-bext");
-    let stamp = |path: &std::path::Path| {
-        let ext = path.extension().and_then(|x| x.to_str());
-        soundcraft_audio_io::probe(&std::fs::read(path).unwrap(), ext).unwrap().bwf.map(|b| b.time_reference)
-    };
-    let mix = dir.join("Mix.wav");
-    e.execute("file.bounce_mix", &serde_json::json!({"path": mix, "start": start, "end": end})).unwrap();
-    assert_eq!(stamp(&mix), Some(3600 * sr + start), "mix");
-    let stems = dir.join("stems");
-    let files = e.execute("file.bounce_stems", &serde_json::json!({"dir": stems, "start": start, "end": end})).unwrap();
-    let files = files["files"].as_array().unwrap();
-    assert!(!files.is_empty());
-    for f in files {
-        let f = std::path::PathBuf::from(f.as_str().unwrap());
-        assert_eq!(stamp(&f), Some(3600 * sr + start), "{}", f.display());
-    }
-    // A session that starts at zero still says where the bounce starts.
-    e.session_mut().timecode_start = 0;
-    e.execute("file.bounce_mix", &serde_json::json!({"path": mix, "start": start, "end": end})).unwrap();
-    assert_eq!(stamp(&mix), Some(start));
-    let _ = std::fs::remove_dir_all(&dir);
-}
-
 #[test]
 fn dropping_an_unfinished_bounce_cancels_it_and_keeps_the_old_file() {
     let e = soundcraft_engine::demo::demo_engine();

crates/mix/src/instances.rs

@@ -68,23 +68,7 @@ pub struct NewInstance {
 /// Creates a plugin (built-in or hosted), restores `state` (if any) and prepares it. Expensive
 /// for third-party plugins: in realtime use, call it on the control thread.
 pub fn create_instance(id: &str, state: Option<&[u8]>, sample_rate: f32, max_block: usize, ch: usize) -> Option<NewInstance> {
-    create_instance_for(id, state, sample_rate, max_block, ch, false)
-}
-
-/// [`create_instance`] for an engine that renders offline (`offline`) or in realtime: the plugin
-/// is told which before it is prepared ([`Plugin::set_offline`]).
-pub(crate) fn create_instance_for(
-    id: &str,
-    state: Option<&[u8]>,
-    sample_rate: f32,
-    max_block: usize,
-    ch: usize,
-    offline: bool,
-) -> Option<NewInstance> {
     let mut plugin = create_plugin(id)?;
-    if offline {
-        plugin.set_offline(true);
-    }
     let refused_state = state.is_some_and(|st| !plugin.load_state(st));
     if refused_state {
         log::warn!("{id}: the plugin did not accept its stored state");

crates/mix/src/lib.rs

@@ -144,8 +144,6 @@ pub struct MixEngine {
     pub metronome: bool,
     /// Third-party instances come from [`MixEngine::adopt`] instead of being created in `sync`.
     external: bool,
-    /// An offline render: the plugins `sync` creates are told so ([`Plugin::set_offline`]).
-    offline: bool,
     /// Instances handed over by the host, waiting for `sync` to place them.
     adopt: HashMap<(TrackId, usize), PreparedInstance>,
     /// Instances `sync` took out of service, for the host to drop (see [`MixEngine::take_retired`]).
@@ -179,7 +177,6 @@ impl MixEngine {
             recording: false,
             metronome: false,
             external: false,
-            offline: false,
             adopt: HashMap::new(),
             retired: Vec::new(),
             work: Vec::new(),
@@ -192,11 +189,6 @@ impl MixEngine {
         self.external = on;
     }
 
-    /// Offline render (a bounce): plugins created from now on are told they render offline.
-    pub fn set_offline(&mut self, on: bool) {
-        self.offline = on;
-    }
-
     /// Takes instances created off the audio thread; the next render's `sync` places them.
     /// An earlier instance waiting for the same slot is retired.
     pub fn adopt(&mut self, instances: Vec<PreparedInstance>) {
@@ -279,8 +271,7 @@ impl MixEngine {
         if self.main.len() != main_ch {
             self.main = vec![vec![0.0; mb]; main_ch];
         }
-        let mut cx =
-            SlotCtx { sr: self.sample_rate, mb, external: self.external, offline: self.offline, adopt: &mut self.adopt, retired: &mut self.retired };
+        let mut cx = SlotCtx { sr: self.sample_rate, mb, external: self.external, adopt: &mut self.adopt, retired: &mut self.retired };
         let gone: Vec<TrackId> = self.strips.keys().filter(|id| s.track(**id).is_none()).copied().collect();
         for id in gone {
             self.meters.remove(&id);

crates/mix/src/midi.rs

@@ -46,20 +46,12 @@ pub(crate) fn schedule_notes(s: &Session, t: &Track, pos: Samples, frames: usize
                 rtp("delay", 0.0).clamp(-1e7, 1e7) as i64,
             )
         };
-        // The block in clip ticks, one tick wider on each side so rounding never drops an event.
-        let near = s.tempo.samples_to_ticks(pos, sr).saturating_sub(base).saturating_sub(1)
-            ..=s.tempo.samples_to_ticks(end, sr).saturating_sub(base).saturating_add(1);
         for n0 in &sequence.notes {
             let mut n = *n0;
             n.velocity = (i64::from(n.velocity) + dv).clamp(1, 127) as u8;
             n.pitch = (i64::from(n.pitch) + dp).clamp(0, 127) as u8;
             n.length = ((n.length as f64 * dur) as i64).max(1);
             n.start = n.start.saturating_add(delay).max(0);
-            // A note whose on and off both fall outside the block sends nothing: skip it before
-            // converting its positions, so a long sequence costs a comparison per note per block.
-            if n.start > *near.end() || n.start.saturating_add(n.length) < *near.start() {
-                continue;
-            }
             let on = s.tempo.tick_to_samples(base.saturating_add(n.start), sr);
             let off = s.tempo.tick_to_samples(base.saturating_add(n.start).saturating_add(n.length), sr).min(clip.end());
             if on >= clip.end() {
@@ -76,6 +68,8 @@ pub(crate) fn schedule_notes(s: &Session, t: &Track, pos: Samples, frames: usize
                 held.retain(|p| *p != n.pitch);
             }
         }
+        let near = s.tempo.samples_to_ticks(pos, sr).saturating_sub(base).saturating_sub(1)
+            ..=s.tempo.samples_to_ticks(end, sr).saturating_sub(base).saturating_add(1);
         // Events before tick 0 are what a start trim hid: they don't play.
         for c in sequence.ctrls.iter().filter(|c| c.tick >= 0) {
             let tick = c.tick.saturating_add(delay).max(0);

crates/mix/src/offline.rs

@@ -57,8 +57,7 @@ impl RangeRender {
     /// Renders the main mix over `range`, or `bus` when one is named.
     pub fn new(s: &Session, bus: Option<BusId>, range: Range, block: usize) -> Self {
         let nch = source_channels(s, bus);
-        let mut eng = MixEngine::new(s.sample_rate.as_f64() as f32, block);
-        eng.set_offline(true);
+        let eng = MixEngine::new(s.sample_rate.as_f64() as f32, block);
         let tmp = vec![vec![0.0f32; eng.max_block()]; nch];
         let len = if nch == 0 { 0 } else { usize::try_from(range.len().max(0)).unwrap_or(0) };
         RangeRender { eng, bus, tmp, start: range.start, done: 0, total: len, latency: 0 }

crates/mix/src/routing.rs

@@ -46,8 +46,7 @@ pub(crate) fn processing_order(s: &Session) -> Vec<usize> {
     } else {
         // A cycle keeps the existing bounded ordering for the entire graph, including any
         // independent acyclic branches. Feedback does not have a finite longest-path depth.
-        let depths = bounded_aux_depths(s);
-        auxes.sort_by_key(|&i| depths.get(i).copied().unwrap_or(0));
+        auxes.sort_by_key(|&i| bounded_aux_depth(s, i));
     }
     order.extend(auxes);
     order
@@ -116,38 +115,32 @@ fn aux_output_busses(t: &Track) -> impl Iterator<Item = BusId> + '_ {
         .filter_map(|route| if let Route::Bus(bus) = route { Some(*bus) } else { None })
 }
 
-/// Hop cap for the bounded depth used when the aux graph has a cycle.
-const MAX_BOUNDED_DEPTH: usize = 8;
-
-/// For each track, the bounded depth used for a cyclic graph: the length of the longest chain of
-/// Aux/Folder feeders into it (through a bus its input reads and the feeder's output or a send
-/// writes), capped at [`MAX_BOUNDED_DEPTH`] hops. One pass per hop over the tracks and their bus
-/// writes, so the cost is linear in the routing, not a fresh feeder search per track per
-/// sort comparison.
-fn bounded_aux_depths(s: &Session) -> Vec<usize> {
-    let is_aux = |t: &Track| matches!(t.kind, TrackKind::Aux | TrackKind::Folder);
-    // Tracks with a feeder chain of the current length ending at them (length 0: every aux).
-    let mut reached: Vec<bool> = s.tracks.iter().map(is_aux).collect();
-    let mut depths = vec![0usize; s.tracks.len()];
-    let mut fed = std::collections::HashSet::<BusId>::new();
-    for hop in 1..=MAX_BOUNDED_DEPTH {
-        fed.clear();
-        for (t, _) in s.tracks.iter().zip(&reached).filter(|(t, r)| **r && is_aux(t)) {
-            fed.extend(aux_output_busses(t));
-        }
-        let mut any = false;
-        for ((t, r), d) in s.tracks.iter().zip(reached.iter_mut()).zip(depths.iter_mut()) {
-            *r = matches!(&t.mixer.input, Route::Bus(b) if fed.contains(b));
-            if *r {
-                *d = hop;
-                any = true;
-            }
-        }
-        if !any {
+/// The previous bounded depth calculation, retained unchanged for any cyclic graph.
+fn bounded_aux_depth(s: &Session, i: usize) -> usize {
+    let mut d = 0;
+    let mut cur = vec![i];
+    for _ in 0..8 {
+        let inputs: Vec<&Route> = cur.iter().filter_map(|&k| s.tracks.get(k)).map(|t| &t.mixer.input).collect();
+        let feeders: Vec<usize> = auxes_feeding(s, &inputs);
+        if feeders.is_empty() {
             break;
         }
+        d += 1;
+        cur = feeders;
     }
-    depths
+    d
+}
+
+fn auxes_feeding(s: &Session, inputs: &[&Route]) -> Vec<usize> {
+    s.tracks
+        .iter()
+        .enumerate()
+        .filter(|(_, t)| matches!(t.kind, TrackKind::Aux | TrackKind::Folder))
+        .filter(|(_, t)| {
+            inputs.iter().any(|r| matches!(r, Route::Bus(_)) && (&&t.mixer.output == r || t.mixer.sends.iter().flatten().any(|sn| &&sn.target == r)))
+        })
+        .map(|(i, _)| i)
+        .collect()
 }
 
 /// Implicit solo: an aux is not muted when a soloed track feeds its input bus.
@@ -211,81 +204,4 @@ mod processing_order_tests {
         // Both deepest independent returns tie with the cycle at the legacy eight-hop cap.
         assert_eq!(processing_order(&s), vec![9, 8, 7, 6, 5, 4, 3, 2, 0, 1, 10]);
     }
-
-    /// The per-track feeder search `bounded_aux_depths` replaced, kept as its reference.
-    fn reference_depth(s: &Session, i: usize) -> usize {
-        let mut d = 0;
-        let mut cur = vec![i];
-        for _ in 0..MAX_BOUNDED_DEPTH {
-            let inputs: Vec<&Route> = cur.iter().filter_map(|&k| s.tracks.get(k)).map(|t| &t.mixer.input).collect();
-            let feeders: Vec<usize> = s
-                .tracks
-                .iter()
-                .enumerate()
-                .filter(|(_, t)| matches!(t.kind, TrackKind::Aux | TrackKind::Folder))
-                .filter(|(_, t)| {
-                    inputs
-                        .iter()
-                        .any(|r| matches!(r, Route::Bus(_)) && (&&t.mixer.output == r || t.mixer.sends.iter().flatten().any(|sn| &&sn.target == r)))
-                })
-                .map(|(i, _)| i)
-                .collect();
-            if feeders.is_empty() {
-                break;
-            }
-            d += 1;
-            cur = feeders;
-        }
-        d
-    }
-
-    #[test]
-    fn bounded_depths_match_the_per_track_feeder_search() {
-        // A small pseudo-random graph of auxes, folders and audio tracks with cycles, joins,
-        // sends and unrouted inputs.
-        let mut s = Session::default();
-        let busses: Vec<_> = (0..6).map(|i| s.add_bus(&format!("B{i}"), ChannelFormat::Stereo)).collect();
-        let mut x = 12345u32;
-        let mut next = |m: usize| {
-            x = x.wrapping_mul(1_103_515_245).wrapping_add(12_345);
-            (x >> 16) as usize % m
-        };
-        for i in 0..30 {
-            let kind = [TrackKind::Aux, TrackKind::Folder, TrackKind::Audio][next(3)];
-            let id = s.add_track(kind, ChannelFormat::Stereo, None);
-            let pick = |n: usize| if n < busses.len() { Route::Bus(busses[n]) } else { Route::Main };
-            let (input, output, send) = (pick(next(8)), pick(next(8)), pick(next(8)));
-            let t = s.track_mut(id).unwrap();
-            t.mixer.input = input;
-            t.mixer.output = output;
-            if i % 2 == 0 {
-                t.mixer.sends[0] = Some(SendSlot::new(send));
-            }
-        }
-        let depths = bounded_aux_depths(&s);
-        for (i, (t, depth)) in s.tracks.iter().zip(&depths).enumerate() {
-            if matches!(t.kind, TrackKind::Aux | TrackKind::Folder) {
-                assert_eq!(*depth, reference_depth(&s, i), "track {i}");
-            }
-        }
-        assert!(depths.contains(&MAX_BOUNDED_DEPTH));
-    }
-
-    #[test]
-    fn a_large_cyclic_graph_orders_quickly() {
-        // Thousands of auxes all reading and writing one bus: every aux feeds every other.
-        let mut s = Session::default();
-        let bus = s.add_bus("Loop", ChannelFormat::Stereo);
-        for _ in 0..3000 {
-            let id = s.add_track(TrackKind::Aux, ChannelFormat::Stereo, None);
-            let t = s.track_mut(id).unwrap();
-            t.mixer.input = Route::Bus(bus);
-            t.mixer.output = Route::Bus(bus);
-            t.mixer.sends[0] = Some(SendSlot::new(Route::Bus(bus)));
-        }
-        let start = std::time::Instant::now();
-        let order = processing_order(&s);
-        assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
-        assert_eq!(order, (0..3000).collect::<Vec<_>>());
-    }
 }

crates/mix/src/strip.rs

@@ -1,6 +1,6 @@
 use super::automation::{GainRamp, transport_at, volume_db_at};
 use super::clips::{ClipFx, clip_fx_params, render_clip};
-use super::instances::{INSTRUMENT_SLOT, PluginFailures, PreparedInstance, create_instance_for, is_third_party};
+use super::instances::{INSTRUMENT_SLOT, PluginFailures, PreparedInstance, create_instance, is_third_party};
 use super::midi::{chase_controllers, schedule_notes};
 use super::pan::{PanSpec, apply_matrix, build_matrix, identity_matrix};
 use super::routing::receives_solo;
@@ -24,9 +24,6 @@ pub(crate) struct PluginSlot {
     pub(crate) plugin: Box<dyn Plugin>,
     /// Last values pushed to the plugin, in the insert's parameter-map order.
     applied: Vec<f32>,
-    /// Scratch for `apply_params`: indexes of the track's automation lanes for this slot, kept
-    /// so the audio thread reuses its allocation.
-    lanes: Vec<usize>,
     pub(crate) failed: bool,
 }
 
@@ -160,8 +157,6 @@ pub(crate) struct SlotCtx<'a> {
     pub(crate) sr: f32,
     pub(crate) mb: usize,
     pub(crate) external: bool,
-    /// The engine renders offline: plugins it creates are told so.
-    pub(crate) offline: bool,
     pub(crate) adopt: &'a mut HashMap<(TrackId, usize), PreparedInstance>,
     pub(crate) retired: &'a mut Vec<Box<dyn Plugin>>,
 }
@@ -194,9 +189,9 @@ impl SlotCtx<'_> {
             }
         } else {
             let state = if third { ins.state_bytes() } else { None };
-            create_instance_for(&ins.plugin, state.as_deref(), self.sr, self.mb, ch, self.offline).map(|n| n.plugin)
+            create_instance(&ins.plugin, state.as_deref(), self.sr, self.mb, ch).map(|n| n.plugin)
         }?;
-        Some(PluginSlot { id: ins.plugin.clone(), ch, plugin, applied: Vec::new(), lanes: Vec::new(), failed: false })
+        Some(PluginSlot { id: ins.plugin.clone(), ch, plugin, applied: Vec::new(), failed: false })
     }
 }
 
@@ -496,40 +491,21 @@ pub(crate) fn apply_params(slot: &mut PluginSlot, ins: &soundcraft_model::Insert
     let Ok(slot_u8) = u8::try_from(i) else {
         return apply_values(slot, ins, |_, v| v);
     };
-    let lanes = &t.automation;
-    let name = |j: usize| match lanes.get(j).map(|l| &l.param) {
-        Some(AutoParam::Plugin { param, .. }) => param.as_str(),
-        _ => "",
-    };
-    // This slot's lanes, ordered by parameter name (the parameter map's order) and keeping only
-    // the first lane per name (the one a lookup by name finds). Matching them to the parameters
-    // in one merge costs O(lanes log lanes + params) per block, not O(lanes x params).
-    let mut order = std::mem::take(&mut slot.lanes);
-    order.clear();
-    if t.mixer.automation_mode.reads() {
-        order
-            .extend(lanes.iter().enumerate().filter(|(_, l)| matches!(&l.param, AutoParam::Plugin { slot, .. } if *slot == slot_u8)).map(|(j, _)| j));
-        if !order.iter().any(|&j| lanes.get(j).is_some_and(|l| !l.points.is_empty())) {
-            order.clear();
-        }
-        order.sort_unstable_by(|&a, &b| name(a).cmp(name(b)).then(a.cmp(&b)));
-        order.dedup_by(|later, kept| name(*later) == name(*kept));
-    }
-    let mut next = order.iter().copied().peekable();
+    let automated = t.mixer.automation_mode.reads()
+        && t.automation.iter().any(|l| matches!(&l.param, AutoParam::Plugin { slot, .. } if *slot == slot_u8) && !l.points.is_empty());
     apply_values(slot, ins, |k, val| {
-        while next.next_if(|&j| name(j) < k).is_some() {}
-        if let Some(l) = next.peek().filter(|&&j| name(j) == k).and_then(|&j| lanes.get(j))
+        if automated
+            && let Some(l) = t.automation.iter().find(|l| matches!(&l.param, AutoParam::Plugin { slot, param } if *slot == slot_u8 && param == k))
             && !l.points.is_empty()
         {
             return l.value_at(pos, val);
         }
         val
     });
-    slot.lanes = order;
 }
 
 /// Sends each stored param (as mapped by `value`) to the plugin when it changed since last time.
-fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, mut value: impl FnMut(&str, f32) -> f32) {
+fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, value: impl Fn(&str, f32) -> f32) {
     if slot.applied.len() != ins.params.len() {
         slot.applied = vec![f32::NAN; ins.params.len()];
     }
@@ -541,99 +517,3 @@ fn apply_values(slot: &mut PluginSlot, ins: &soundcraft_model::Insert, mut value
         }
     }
 }
-
-#[cfg(test)]
-mod apply_params_tests {
-    use super::*;
-    use soundcraft_model::{AutomationLane, Insert};
-    use std::sync::Mutex;
-
-    /// A built-in gain that logs every parameter set.
-    struct Recorder {
-        inner: Box<dyn Plugin>,
-        sets: Arc<Mutex<Vec<(String, f32)>>>,
-    }
-
-    impl Plugin for Recorder {
-        fn info(&self) -> &'static soundcraft_dsp::PluginInfo {
-            self.inner.info()
-        }
-        fn prepare(&mut self, sr: f32, mb: usize, ch: usize) {
-            self.inner.prepare(sr, mb, ch);
-        }
-        fn reset(&mut self) {
-            self.inner.reset();
-        }
-        fn set_param(&mut self, id: &str, v: f32) -> bool {
-            self.sets.lock().unwrap().push((id.to_string(), v));
-            true
-        }
-        fn param(&self, id: &str) -> Option<f32> {
-            self.inner.param(id)
-        }
-        fn process(&mut self, io: &mut [Vec<f32>], frames: usize) {
-            self.inner.process(io, frames);
-        }
-    }
-
-    fn recorder() -> (PluginSlot, Arc<Mutex<Vec<(String, f32)>>>) {
-        let sets = Arc::new(Mutex::new(Vec::new()));
-        let plugin = Box::new(Recorder { inner: soundcraft_dsp::create("gain").unwrap(), sets: Arc::clone(&sets) });
-        (PluginSlot { id: "gain".into(), ch: 2, plugin, applied: Vec::new(), lanes: Vec::new(), failed: false }, sets)
-    }
-
-    fn lane(slot: u8, param: &str, point: Option<f32>) -> AutomationLane {
-        let mut l = AutomationLane::new(AutoParam::Plugin { slot, param: param.into() });
-        if let Some(v) = point {
-            l.set_point(0, v);
-        }
-        l
-    }
-
-    #[test]
-    fn first_lane_per_param_of_this_slot_drives_it() {
-        let mut s = Session::default();
-        let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None);
-        let tr = s.track_mut(t).unwrap();
-        tr.automation = vec![
-            lane(0, "c", None),
-            lane(1, "a", Some(5.0)),
-            lane(0, "b", Some(9.0)),
-            lane(0, "c", Some(7.0)),
-            lane(0, "zz", Some(1.0)),
-            lane(0, "b", Some(8.0)),
-        ];
-        let mut ins = Insert::new("gain");
-        for (k, v) in [("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0)] {
-            ins.params.insert(k.into(), v);
-        }
-        let (mut slot, sets) = recorder();
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        let got = sets.lock().unwrap().clone();
-        let want: Vec<(String, f32)> = [("a", 1.0), ("b", 9.0), ("c", 3.0), ("d", 4.0)].iter().map(|(k, v)| (k.to_string(), *v)).collect();
-        assert_eq!(got, want);
-        // Unchanged values are not sent again.
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        assert_eq!(sets.lock().unwrap().len(), 4);
-    }
-
-    #[test]
-    fn many_params_and_lanes_apply_without_a_quadratic_search() {
-        let n = 40_000;
-        let mut s = Session::default();
-        let t = s.add_track(TrackKind::Audio, ChannelFormat::Stereo, None);
-        let tr = s.track_mut(t).unwrap();
-        tr.automation = (0..n).rev().map(|i| lane(0, &format!("p{i:06}"), Some(i as f32))).collect();
-        let mut ins = Insert::new("gain");
-        for i in 0..n {
-            ins.params.insert(format!("p{i:06}"), -1.0);
-        }
-        let (mut slot, sets) = recorder();
-        let start = std::time::Instant::now();
-        apply_params(&mut slot, &ins, tr, 0, 0);
-        assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
-        let got = sets.lock().unwrap();
-        assert_eq!(got.len(), n);
-        assert!(got.iter().all(|(k, v)| k == &format!("p{:06}", *v as usize)));
-    }
-}

crates/time/src/tempo.rs

@@ -40,34 +40,14 @@ pub struct BarBeat {
 
 /// Tempo and meter changes for a session. Always has at least one of each, at tick 0.
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-#[serde(from = "TempoMapData")]
 pub struct TempoMap {
     tempos: Vec<TempoEvent>,
     meters: Vec<MeterEvent>,
-    /// For each tempo event, the elapsed time at its tick in quarter-note minutes (ticks / bpm,
-    /// summed over the earlier segments). Lets tick/sample conversions binary-search the segment
-    /// instead of walking every earlier tempo change, so converting many positions against a large
-    /// tempo map stays O(log n) each. Rebuilt whenever `tempos` changes.
-    #[serde(skip)]
-    elapsed: Vec<f64>,
-}
-
-/// The serialized form of [`TempoMap`], without the derived lookup table.
-#[derive(serde::Deserialize)]
-struct TempoMapData {
-    tempos: Vec<TempoEvent>,
-    meters: Vec<MeterEvent>,
-}
-
-impl From<TempoMapData> for TempoMap {
-    fn from(d: TempoMapData) -> Self {
-        TempoMap::from_parts(d.tempos, d.meters)
-    }
 }
 
 impl Default for TempoMap {
     fn default() -> Self {
-        TempoMap::from_parts(vec![TempoEvent { tick: 0, bpm: 120.0 }], vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }])
+        TempoMap { tempos: vec![TempoEvent { tick: 0, bpm: 120.0 }], meters: vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }] }
     }
 }
 
@@ -80,43 +60,6 @@ fn valid_meter(numerator: u32, denominator: u32) -> bool {
 }
 
 impl TempoMap {
-    fn from_parts(tempos: Vec<TempoEvent>, meters: Vec<MeterEvent>) -> Self {
-        let mut m = TempoMap { tempos, meters, elapsed: Vec::new() };
-        m.reindex();
-        m
-    }
-
-    /// Rebuild `elapsed` from `tempos`. The first segment runs from tick 0 at the first tempo.
-    fn reindex(&mut self) {
-        let mut elapsed = Vec::with_capacity(self.tempos.len());
-        let mut acc = 0.0;
-        let mut seg_tick = 0i64;
-        let mut bpm = self.tempos.first().map_or(120.0, |e| e.bpm);
-        for (i, e) in self.tempos.iter().enumerate() {
-            if i > 0 {
-                // Saturating: a file's ticks are indexed before `sanitize` orders them.
-                acc += e.tick.saturating_sub(seg_tick) as f64 / bpm;
-                seg_tick = e.tick;
-                bpm = e.bpm;
-            }
-            elapsed.push(acc);
-        }
-        self.elapsed = elapsed;
-    }
-
-    /// Samples per quarter-note minute (the unit of `elapsed`) at `sr`.
-    fn samples_per_elapsed(sr: SampleRate) -> f64 {
-        sr.as_f64() * 60.0 / TICKS_PER_QUARTER as f64
-    }
-
-    /// The tempo segment `i` (an index into `tempos`, 0 when it is empty): its start tick (0 for
-    /// the first), bpm and elapsed time at its start.
-    fn segment(&self, i: usize) -> (i64, f64, f64) {
-        let bpm = self.tempos.get(i).or(self.tempos.first()).map_or(120.0, |e| e.bpm);
-        let tick = if i == 0 { 0 } else { self.tempos.get(i).map_or(0, |e| e.tick) };
-        (tick, bpm, self.elapsed.get(i).copied().unwrap_or(0.0))
-    }
-
     pub fn new(bpm: f64, numerator: u32, denominator: u32) -> Result<Self, TimeError> {
         let mut m = TempoMap::default();
         m.set_tempo(0, bpm)?;
@@ -148,7 +91,6 @@ impl TempoMap {
             let (numerator, denominator) = self.meters.first().map_or((4, 4), |m| (m.numerator, m.denominator));
             self.meters.insert(0, MeterEvent { tick: 0, numerator, denominator });
         }
-        self.reindex();
     }
 
     /// Insert or replace the tempo at `tick`.
@@ -163,7 +105,6 @@ impl TempoMap {
             }
             Err(i) => self.tempos.insert(i, TempoEvent { tick, bpm }),
         }
-        self.reindex();
         Ok(())
     }
 
@@ -174,7 +115,6 @@ impl TempoMap {
         }
         let before = self.tempos.len();
         self.tempos.retain(|e| e.tick != tick);
-        self.reindex();
         before != self.tempos.len()
     }
 
@@ -213,52 +153,18 @@ impl TempoMap {
         }
     }
 
-    /// Remove the meters after `tick`, returning each with the bar it starts: the bar
-    /// [`Self::bar_beat_at_tick`] gives its tick, counted in one pass over the map rather than one
-    /// walk per meter, so a session with many meter changes edits in linear time.
+    /// Remove the meters after `tick`, returning each with the bar it starts.
     fn take_meters_after(&mut self, tick: i64) -> Vec<(i64, MeterEvent)> {
-        let mut later = Vec::new();
-        let (mut bar, mut seg_tick) = (1i64, 0i64);
-        for (i, m) in self.meters.iter().enumerate() {
-            let tpb = m.ticks_per_bar();
-            if m.tick > tick {
-                later.push((bar.saturating_add(m.tick.saturating_sub(seg_tick) / tpb), *m));
-            }
-            if let Some(n) = self.meters.get(i + 1) {
-                bar = bar.saturating_add(ceil_div(n.tick.saturating_sub(seg_tick), tpb));
-                seg_tick = n.tick;
-            }
-        }
+        let later: Vec<_> = self.meters.iter().filter(|e| e.tick > tick).map(|e| (self.bar_beat_at_tick(e.tick).bar, *e)).collect();
         self.meters.retain(|e| e.tick <= tick);
         later
     }
 
-    /// The bar and tick of the last meter's segment, where [`Self::bar_start_tick`]'s walk ends.
-    fn last_segment(&self) -> (i64, i64) {
-        let (mut cur_bar, mut cur_tick) = (1i64, 0i64);
-        for (i, m) in self.meters.iter().enumerate() {
-            if let Some(n) = self.meters.get(i + 1) {
-                cur_bar = cur_bar.saturating_add(ceil_div(n.tick.saturating_sub(cur_tick), m.ticks_per_bar()));
-                cur_tick = n.tick;
-            }
-        }
-        (cur_bar, cur_tick)
-    }
-
     /// Put meters back at the start of their bars under the current earlier meters, in bar order.
-    /// Each lands at or past the last meter, so the walk to its bar resumes from there; a bar
-    /// before it (meters off their bar lines) takes the full walk.
     fn restore_meters_at_bars(&mut self, later: Vec<(i64, MeterEvent)>) {
-        let (mut cur_bar, mut cur_tick) = self.last_segment();
         for (bar, ev) in later {
-            let tick = if bar >= cur_bar {
-                let tpb = self.meters.last().map_or(MeterEvent { tick: 0, numerator: 4, denominator: 4 }, |m| *m).ticks_per_bar();
-                cur_tick.saturating_add(bar.saturating_sub(cur_bar).saturating_mul(tpb))
-            } else {
-                self.bar_start_tick(bar)
-            };
+            let tick = self.bar_start_tick(bar);
             self.put_meter(MeterEvent { tick, ..ev });
-            (cur_bar, cur_tick) = if bar >= cur_bar { (bar, tick) } else { self.last_segment() };
         }
     }
 
@@ -298,20 +204,36 @@ impl TempoMap {
     }
 
     fn tick_to_samples_f(&self, tick: i64, sr: SampleRate) -> f64 {
-        // Tempo events after the first that start before `tick` (the segments it has passed).
-        let passed = self.tempos.get(1..).map_or(0, |rest| rest.partition_point(|e| e.tick < tick));
-        let (seg_tick, bpm, elapsed) = self.segment(passed);
-        elapsed * Self::samples_per_elapsed(sr) + (tick - seg_tick) as f64 * Self::samples_per_tick(bpm, sr)
+        let mut acc = 0.0;
+        let mut seg_tick = 0i64;
+        let mut bpm = self.tempos.first().map_or(120.0, |e| e.bpm);
+        for e in self.tempos.iter().skip(1) {
+            if e.tick >= tick {
+                break;
+            }
+            acc += (e.tick - seg_tick) as f64 * Self::samples_per_tick(bpm, sr);
+            seg_tick = e.tick;
+            bpm = e.bpm;
+        }
+        acc + (tick - seg_tick) as f64 * Self::samples_per_tick(bpm, sr)
     }
 
     /// Samples → ticks (fractional).
     pub fn samples_to_ticks_f(&self, s: Samples, sr: SampleRate) -> f64 {
         let s = s as f64;
-        let scale = Self::samples_per_elapsed(sr);
-        // Tempo events after the first that start at or before `s`.
-        let passed = self.elapsed.get(1..).map_or(0, |rest| rest.partition_point(|e| e * scale <= s));
-        let (seg_tick, bpm, elapsed) = self.segment(passed);
-        seg_tick as f64 + (s - elapsed * scale) / Self::samples_per_tick(bpm, sr)
+        let mut acc = 0.0;
+        let mut seg_tick = 0i64;
+        let mut bpm = self.tempos.first().map_or(120.0, |e| e.bpm);
+        for e in self.tempos.iter().skip(1) {
+            let seg = (e.tick - seg_tick) as f64 * Self::samples_per_tick(bpm, sr);
+            if acc + seg > s {
+                break;
+            }
+            acc += seg;
+            seg_tick = e.tick;
+            bpm = e.bpm;
+        }
+        seg_tick as f64 + (s - acc) / Self::samples_per_tick(bpm, sr)
     }
 
     pub fn samples_to_ticks(&self, s: Samples, sr: SampleRate) -> i64 {
@@ -397,7 +319,6 @@ impl TempoMap {
             e.bpm = valid_bpm(e.bpm * factor)?;
         }
         self.tempos = out;
-        self.reindex();
         Ok(())
     }
 }
@@ -475,36 +396,6 @@ mod tests {
         assert_eq!(m.bar_beat_at_tick(m.tick_at_bar_beat(bb)), bb);
     }
 
-    #[test]
-    fn editing_an_early_meter_keeps_later_bars_and_scales_linearly() {
-        // 200 000 meter changes, one per bar, built directly: a walk per meter would take
-        // minutes to edit here, and even to build through `set_meter`.
-        let mut m = TempoMap::new(120.0, 4, 4).unwrap();
-        let mut tick = 0;
-        for bar in 1..200_000i64 {
-            let numerator = 3 + (bar % 2) as u32;
-            tick += m.meters.last().map_or(0, MeterEvent::ticks_per_bar);
-            m.meters.push(MeterEvent { tick, numerator, denominator: 4 });
-        }
-        let sample = [1usize, 1_000, 199_998];
-        let bars = |m: &TempoMap| sample.map(|i| m.bar_beat_at_tick(m.meters[i].tick).bar);
-        assert_eq!(bars(&m), [2, 1_001, 199_999]);
-        m.set_meter(0, 7, 8).unwrap();
-        assert_eq!(bars(&m), [2, 1_001, 199_999], "later meters keep their bar numbers");
-        assert_eq!(m.meters.len(), 200_000);
-        assert!(m.meters.windows(2).all(|w| w[0].tick < w[1].tick));
-        assert!(m.remove_meter(m.meters[1].tick));
-        assert_eq!([1usize, 999, 199_997].map(|i| m.bar_beat_at_tick(m.meters[i].tick).bar), [3, 1_001, 199_999]);
-        // Meters off their bar lines (counted as bars 2 and 4) land where they always did: on
-        // bar 2 of the new meter, then two bars of their own later.
-        let mut off = TempoMap::new(120.0, 4, 4).unwrap();
-        off.meters.push(MeterEvent { tick: 100, numerator: 3, denominator: 4 });
-        off.meters.push(MeterEvent { tick: 5_000, numerator: 5, denominator: 4 });
-        off.set_meter(0, 2, 4).unwrap();
-        let placed: Vec<(i64, u32)> = off.meters.iter().map(|e| (e.tick, e.numerator)).collect();
-        assert_eq!(placed, vec![(0, 2), (2 * TICKS_PER_QUARTER, 3), (8 * TICKS_PER_QUARTER, 5)]);
-    }
-
     #[test]
     fn eighth_note_meters() {
         let m = TempoMap::new(120.0, 6, 8).unwrap();
@@ -516,24 +407,24 @@ mod tests {
     fn sanitize_keeps_what_the_setters_accept() {
         let tempo = |tick, bpm| TempoEvent { tick, bpm };
         let meter = |tick, numerator, denominator| MeterEvent { tick, numerator, denominator };
-        let mut m = TempoMap::from_parts(
-            vec![tempo(960, 4e9), tempo(3840, 90.0), tempo(-5, 100.0), tempo(1920, 60.0), tempo(1920, 70.0)],
-            vec![meter(0, 0, 4), meter(3840, 3, 4)],
-        );
+        let mut m = TempoMap {
+            tempos: vec![tempo(960, 4e9), tempo(3840, 90.0), tempo(-5, 100.0), tempo(1920, 60.0), tempo(1920, 70.0)],
+            meters: vec![meter(0, 0, 4), meter(3840, 3, 4)],
+        };
         m.sanitize();
         assert_eq!(m.tempos(), [tempo(0, 60.0), tempo(1920, 60.0), tempo(3840, 90.0)]);
         assert_eq!(m.meters(), [meter(0, 3, 4), meter(3840, 3, 4)]);
-        let mut empty = TempoMap::from_parts(Vec::new(), Vec::new());
+        let mut empty = TempoMap { tempos: Vec::new(), meters: Vec::new() };
         empty.sanitize();
         assert_eq!(empty, TempoMap::default());
     }
 
     #[test]
     fn sanitize_drops_events_beyond_the_position_range() {
-        let mut m = TempoMap::from_parts(
-            vec![TempoEvent { tick: 0, bpm: 120.0 }, TempoEvent { tick: i64::MAX, bpm: 90.0 }],
-            vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }, MeterEvent { tick: i64::MAX, numerator: 3, denominator: 4 }],
-        );
+        let mut m = TempoMap {
+            tempos: vec![TempoEvent { tick: 0, bpm: 120.0 }, TempoEvent { tick: i64::MAX, bpm: 90.0 }],
+            meters: vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }, MeterEvent { tick: i64::MAX, numerator: 3, denominator: 4 }],
+        };
         m.sanitize();
         assert_eq!(m, TempoMap::default());
         assert_eq!(m.bar_start_tick(2), TICKS_PER_QUARTER * 4);
@@ -555,68 +446,4 @@ mod tests {
         assert_eq!(m.bar_beat_at_tick(-TICKS_PER_QUARTER * 4), BarBeat { bar: 0, beat: 1, tick: 0 });
         assert_eq!(m.bar_beat_at_tick(-TICKS_PER_QUARTER), BarBeat { bar: 0, beat: 4, tick: 0 });
     }
-
-    /// The segment walk the indexed conversions replaced, kept as the reference they must match.
-    fn linear_tick_to_samples(m: &TempoMap, tick: i64, sr: SampleRate) -> i64 {
-        let mut acc = 0.0;
-        let mut seg_tick = 0i64;
-        let mut bpm = m.tempos[0].bpm;
-        for e in m.tempos.iter().skip(1) {
-            if e.tick >= tick {
-                break;
-            }
-            acc += (e.tick - seg_tick) as f64 * TempoMap::samples_per_tick(bpm, sr);
-            seg_tick = e.tick;
-            bpm = e.bpm;
-        }
-        to_samples(acc + (tick - seg_tick) as f64 * TempoMap::samples_per_tick(bpm, sr))
-    }
-
-    #[test]
-    fn indexed_conversions_match_the_segment_walk() {
-        let sr = SampleRate::HZ_48000;
-        let mut m = TempoMap::default();
-        for i in 1..200i64 {
-            m.set_tempo(i * 487, 40.0 + ((i * 37) % 300) as f64).unwrap();
-        }
-        assert!(m.remove_tempo(487 * 50));
-        for tick in (-1000..200 * 487 + 5000).step_by(113) {
-            let s = m.tick_to_samples(tick, sr);
-            assert_eq!(s, linear_tick_to_samples(&m, tick, sr), "tick {tick}");
-            assert!((m.samples_to_ticks(s, sr) - tick).abs() <= 1, "tick {tick}");
-        }
-        let json = serde_json::to_string(&m).unwrap();
-        assert!(!json.contains("elapsed"));
-        let back: TempoMap = serde_json::from_str(&json).unwrap();
-        assert_eq!(back, m);
-        assert_eq!(back.tick_to_samples(150 * 487 + 3, sr), m.tick_to_samples(150 * 487 + 3, sr));
-    }
-
-    #[test]
-    fn a_file_with_wild_ticks_is_indexed_without_overflow() {
-        let json = r#"{"tempos":[{"tick":0,"bpm":120.0},{"tick":-9223372036854775808,"bpm":100.0},{"tick":9223372036854775807,"bpm":90.0}],"meters":[{"tick":0,"numerator":4,"denominator":4}]}"#;
-        let mut m: TempoMap = serde_json::from_str(json).unwrap();
-        m.sanitize();
-        assert_eq!(m.tempos().first().map(|e| e.tick), Some(0));
-        assert_eq!(m.elapsed.len(), m.tempos().len());
-    }
-
-    #[test]
-    fn conversions_against_a_large_tempo_map_stay_fast() {
-        // 200k tempo changes, then 200k conversions each way: quadratic if every conversion walks
-        // the earlier segments, well under a second when it binary-searches them.
-        let sr = SampleRate::HZ_48000;
-        let n = 200_000i64;
-        let tempos = (0..n).map(|i| TempoEvent { tick: i * 10, bpm: 60.0 + (i % 7) as f64 }).collect();
-        let mut m = TempoMap::from_parts(tempos, vec![MeterEvent { tick: 0, numerator: 4, denominator: 4 }]);
-        m.sanitize();
-        let start = std::time::Instant::now();
-        let mut sum = 0i64;
-        for i in 0..n {
-            let s = m.tick_to_samples(i * 10 + 5, sr);
-            sum = sum.wrapping_add(s).wrapping_add(m.samples_to_ticks(s, sr));
-        }
-        assert!(sum != 0);
-        assert!(start.elapsed() < std::time::Duration::from_secs(5), "{:?}", start.elapsed());
-    }
 }

crates/ui-egui/src/edit_window/header.rs

@@ -115,18 +115,8 @@ fn name_plate(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect, select
         track.name.clone()
     };
     let name_color = if selected { t.text_dark } else { t.text.lerp_to_gamma(t.text_dim, 0.4) };
-    let font = bold(12.5);
-    let galley = ui.painter().layout_no_wrap(shown_name.clone(), font.clone(), name_color);
-    let overflows = galley.size().x > name_r.width() - 3.0;
-    let (text_pos, align) =
-        if overflows { (pos2(name_r.min.x + 1.5, name_r.center().y), Align2::LEFT_CENTER) } else { (name_r.center(), Align2::CENTER_CENTER) };
-    ui.painter().with_clip_rect(name_r).text(text_pos, align, &shown_name, font, name_color);
-    let mut nresp = ui.interact(name_r, ui.scope_id().with(("name", id.0)), Sense::click_and_drag());
-    if overflows {
-        nresp = nresp.on_hover_ui(|ui| {
-            ui.label(&shown_name);
-        });
-    }
+    ui.painter().with_clip_rect(name_r).text(pos2(name_r.min.x + 1.5, name_r.center().y), Align2::LEFT_CENTER, &shown_name, bold(12.5), name_color);
+    let nresp = ui.interact(name_r, ui.scope_id().with(("name", id.0)), Sense::click_and_drag());
     if nresp.double_clicked() {
         app.dialogs.open_rename_track(id, &track.name);
     } else if nresp.clicked() {
@@ -200,9 +190,8 @@ fn toggle_keys(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) {
     let h = head.height();
     let at = |x: f32, y: f32, w: f32, h: f32| Rect::from_min_size(pos2(head.min.x + x, head.min.y + y), vec2(w, h));
     let m = &track.mixer;
-    let is_master = track.kind == TrackKind::Master;
-    if h >= 37.0 && !is_master {
-        let (records, mixes) = (track.kind.has_playlist(), true);
+    if h >= 37.0 {
+        let (records, mixes) = (track.kind.has_playlist(), track.kind != TrackKind::Master);
         let implied = !m.solo && app.engine.session().tracks.iter().any(|t| t.mixer.solo);
         let keys = [
             (HeaderKey::Rec, m.record_arm, false, "mix.record_arm", records),
@@ -224,13 +213,10 @@ fn view_selector(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) {
     let id = track.id;
     let h = head.height();
     let at = |x: f32, y: f32, w: f32, h: f32| Rect::from_min_size(pos2(head.min.x + x, head.min.y + y), vec2(w, h));
-    let is_master = track.kind == TrackKind::Master;
-    let view_y = if is_master { 20.0 } else { 39.0 };
-    let view_min_h = if is_master { 37.0 } else { 58.0 };
-    if h >= view_min_h {
+    if h >= 58.0 {
         let vresp = header_selector(
             ui,
-            at(17.0, view_y, 105.0, 17.0),
+            at(17.0, 39.0, 105.0, 17.0),
             ui.scope_id().with(("view", id.0)),
             &view_label(&track.view),
             t.text,
@@ -239,32 +225,10 @@ fn view_selector(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) {
         );
         egui::Popup::menu(&vresp).show(|ui| view_menu(app, ui, track));
     }
-    if is_master && h >= 58.0 {
-        let mode = track.mixer.automation_mode;
-        let col = match mode {
-            soundcraft_model::AutomationMode::Read => t.auto_read,
-            soundcraft_model::AutomationMode::Write => t.auto_write,
-            soundcraft_model::AutomationMode::Touch | soundcraft_model::AutomationMode::TouchLatch => t.auto_touch,
-            soundcraft_model::AutomationMode::Latch => t.auto_latch,
-            _ => t.text_dim,
-        };
-        let mode_name = format!("Automation mode for {}", track.name);
-        let aresp = header_selector(ui, at(17.0, 39.0, 105.0, 17.0), ui.scope_id().with(("auto_mode", id.0)), mode.label(), col, true, &mode_name);
-        egui::Popup::menu(&aresp).show(|ui| {
-            for m in soundcraft_model::AutomationMode::ALL {
-                if ui.selectable_label(m == mode, m.label()).clicked() {
-                    let _ = app.run("mix.automation_mode", json!({"track": id.0, "mode": m.label()}));
-                }
-            }
-        });
-    }
 }
 
 /// Freeze, voice and automation mode.
 fn voice_row(app: &mut SoundApp, ui: &mut Ui, track: &Track, head: Rect) {
-    if track.kind == TrackKind::Master {
-        return;
-    }
     let t = Tokens::current();
     let id = track.id;
     let h = head.height();

crates/ui-egui/src/edit_window/rulers.rs

@@ -222,8 +222,7 @@ pub(super) fn draw_rulers(app: &mut SoundApp, ui: &mut Ui, area: Rect, tl: Rect,
                     } else if resp.clicked()
                         && let Some(m) = hit
                     {
-                        let command = if ui.input(|i| i.modifiers.alt) { "markers.delete" } else { "markers.recall" };
-                        let _ = app.run(command, json!({"number": m.number}));
+                        let _ = app.run("markers.recall", json!({"number": m.number}));
                     }
                 }
             }

crates/ui-egui/src/edit_window/tests.rs

@@ -1508,50 +1508,3 @@ fn alt_click_on_a_breakpoint_deletes_it() {
         assert_eq!(h.state().engine.session().track(track).unwrap().clips(), clips.as_slice(), "{tool}");
     }
 }
-
-#[test]
-fn alt_click_on_a_marker_deletes_it() {
-    let mut engine = soundcraft_engine::demo::demo_engine();
-    engine.session_mut().edit.rulers = vec!["markers".into()];
-    engine.execute("markers.add", &json!({"at": 48_000, "name": "Alt-delete me"})).unwrap();
-    let mut h = harness_with(engine);
-    let s = h.state().engine.session_arc();
-    let marker = s.markers.iter().find(|m| m.name == "Alt-delete me").unwrap();
-    let at = pos2(x_of(&s, timeline(&h), marker.start), timeline(&h).min.y - 11.5);
-    let before = s.markers.len();
-
-    click_with(&mut h, at, egui::Modifiers::ALT);
-
-    assert_eq!(h.state().engine.session().markers.len(), before - 1);
-    assert!(!h.state().engine.session().markers.iter().any(|m| m.name == "Alt-delete me"));
-}
-
-#[test]
-fn short_track_name_is_centered_and_long_name_is_left_aligned() {
-    let mut h = harness(2);
-    let s = h.state().engine.session_arc();
-    let first = s.tracks[0].id.0;
-    let second = s.tracks[1].id.0;
-    h.state_mut().run("track.rename", json!({"track": first, "name": "Vocal"})).unwrap();
-    h.state_mut().run("track.rename", json!({"track": second, "name": "A Very Long Track Name That Exceeds Header Width"})).unwrap();
-    h.step();
-
-    let r0 = row(&h, 0);
-    let r1 = row(&h, 1);
-
-    let first_text = h.output().shapes.iter().find_map(|s| match &s.shape {
-        Shape::Text(t) if t.galley.text() == "Vocal" && s.clip_rect.intersects(r0) => Some((t.pos, t.galley.size())),
-        _ => None,
-    });
-    let long_text = h.output().shapes.iter().find_map(|s| match &s.shape {
-        Shape::Text(t) if t.galley.text() == "A Very Long Track Name That Exceeds Header Width" && s.clip_rect.intersects(r1) => Some(t.pos),
-        _ => None,
-    });
-
-    let (first_pos, first_size) = first_text.expect("short track name should be rendered in edit header");
-    let long_pos = long_text.expect("long track name should be rendered in edit header");
-
-    assert_eq!(long_pos.x, r1.min.x + 17.5);
-    let first_center_x = first_pos.x + first_size.x * 0.5;
-    assert!((first_center_x - (r0.min.x + 64.5)).abs() <= 0.1, "short name should be centered (center was at {first_center_x})");
-}

crates/ui-egui/src/icons.rs

@@ -176,19 +176,6 @@ pub fn draw(painter: &Painter, r: Rect, name: &str, c: Color32) {
                 painter.line_segment([p(r, x, 0.5 - h), p(r, x, 0.5 + h)], s);
             }
         }
-        "link_track" => {
-            // A link chain below two track rows, so the track link reads apart from the timeline link's plain chain.
-            painter.line_segment([p(r, 0.12, 0.18), p(r, 0.88, 0.18)], s);
-            painter.line_segment([p(r, 0.12, 0.32), p(r, 0.88, 0.32)], s);
-            painter.circle_stroke(p(r, 0.38, 0.72), r.width() * 0.16, s);
-            painter.circle_stroke(p(r, 0.62, 0.72), r.width() * 0.16, s);
-        }
-        "insertion_follows" => {
-            // The insertion line, a lead, and the playhead arrow it follows.
-            painter.line_segment([p(r, 0.3, 0.14), p(r, 0.3, 0.86)], s);
-            painter.line_segment([p(r, 0.42, 0.5), p(r, 0.62, 0.5)], s);
-            painter.add(Shape::convex_polygon(vec![p(r, 0.84, 0.5), p(r, 0.64, 0.34), p(r, 0.64, 0.66)], c, Stroke::NONE));
-        }
         _ => {
             painter.rect_stroke(r.shrink(r.width() * 0.25), 1.0, s, egui::StrokeKind::Middle);
         }

crates/ui-egui/src/mix_window/routing.rs

@@ -11,12 +11,7 @@ pub(crate) fn route_name(app: &SoundApp, r: &Route) -> String {
 }
 
 pub(crate) fn input_name(app: &SoundApp, track: &Track) -> String {
-    if track.kind.has_playlist() && track.mixer.input == Route::None {
-        let channels = track.format.channels();
-        if channels == 1 { "In 1".to_string() } else { format!("In 1-{channels}") }
-    } else {
-        route_name(app, &track.mixer.input)
-    }
+    if track.kind.has_playlist() && track.mixer.input == Route::None { "In 1".to_string() } else { route_name(app, &track.mixer.input) }
 }
 
 /// The input or output menu under `resp`. It closes only on a click outside, so its bus search
@@ -64,19 +59,3 @@ fn route_menu(app: &mut SoundApp, ui: &mut Ui, id: TrackId, input: bool) {
         ui.close();
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::input_name;
-    use crate::{Services, SoundApp};
-    use serde_json::json;
-
-    #[test]
-    fn stereo_track_defaults_to_a_stereo_input_pair() {
-        let mut app = SoundApp::new(soundcraft_engine::Engine::default(), None, Services::default());
-        app.run("track.new", json!({"format": "stereo"})).unwrap();
-        let track = &app.engine.session().tracks[0];
-
-        assert_eq!(input_name(&app, track), "In 1-2");
-    }
-}

crates/ui-egui/src/mix_window/sends.rs

@@ -388,17 +388,8 @@ fn send_route_menu(app: &mut SoundApp, ui: &Ui, field: &egui::Response, id: Trac
         },
     );
     let Some((picked, footer)) = shown else { return };
-    // As in Pro Tools, a new send opens its Send window (moving it from any other send), so its
-    // fader is on screen right away. A send that only changes destination leaves the window alone.
-    let show_new_send = |app: &mut SoundApp| {
-        if !has_send {
-            app.ui.send_window = Some((id, slot));
-        }
-    };
-    if let Some(bus) = picked
-        && app.run("mix.send", json!({"track": id.0, "slot": slot, "bus": bus})).is_ok()
-    {
-        show_new_send(app);
+    if let Some(bus) = picked {
+        let _ = app.run("mix.send", json!({"track": id.0, "slot": slot, "bus": bus}));
     }
     match footer {
         Some(SendFooter::NewBus) => {
@@ -408,10 +399,8 @@ fn send_route_menu(app: &mut SoundApp, ui: &Ui, field: &egui::Response, id: Trac
             {
                 n += 1;
             }
-            if app.run("mix.new_bus", json!({"name": format!("Bus {n}")})).is_ok()
-                && app.run("mix.send", json!({"track": id.0, "slot": slot, "bus": format!("Bus {n}")})).is_ok()
-            {
-                show_new_send(app);
+            if app.run("mix.new_bus", json!({"name": format!("Bus {n}")})).is_ok() {
+                let _ = app.run("mix.send", json!({"track": id.0, "slot": slot, "bus": format!("Bus {n}")}));
             }
         }
         Some(SendFooter::RemoveSend) => {
@@ -475,79 +464,4 @@ mod tests {
         assert_eq!(field(&h), search, "the search field stays put");
         assert!((footer(&h).top() - full.top()).abs() < 1.0, "cleared, the footer is back under the full list: {:?} vs {full:?}", footer(&h));
     }
-
-    /// Kick's send A slot in a test harness, with buses "Aux" and "Other"; with `existing_send`, the
-    /// slot already sends to "Other".
-    fn kick_send_harness(existing_send: bool) -> (Harness<'static, (SoundApp, TrackId)>, TrackId) {
-        let mut app = SoundApp::new(soundcraft_engine::demo::demo_engine(), None, Services::default());
-        app.run("mix.new_bus", json!({"name": "Aux"})).unwrap();
-        app.run("mix.new_bus", json!({"name": "Other"})).unwrap();
-        let kick = app.engine.session().track_by_name("Kick").unwrap().id;
-        if existing_send {
-            app.run("mix.send", json!({"track": kick.0, "slot": 0, "bus": "Other"})).unwrap();
-        }
-        let mut ready = false;
-        let h = Harness::builder().with_size(vec2(600.0, 800.0)).build_ui_state(
-            move |ui, (app, kick): &mut (SoundApp, TrackId)| {
-                if !ready {
-                    crate::fonts::install(ui.ctx(), true);
-                    crate::theme::apply(ui.ctx(), false);
-                    ready = true;
-                    return;
-                }
-                let track = app.engine.session().track(*kick).cloned().unwrap();
-                let r = Rect::from_min_size(ui.max_rect().min + vec2(20.0, 20.0), vec2(120.0, 24.0));
-                send_slot(app, ui, &track, 0, r);
-            },
-            (app, kick),
-        );
-        (h, kick)
-    }
-
-    /// Creating a send opens its Send window, so the new send's fader is on screen right away (#1269).
-    #[test]
-    fn creating_a_send_opens_its_send_window() {
-        let _palette = crate::theme::lock_test_palette();
-        let (mut h, kick) = kick_send_harness(false);
-        h.run();
-        h.get_by_label("Send A for Kick").click();
-        h.run();
-        h.get_by_label("Aux").click();
-        h.run();
-        let (app, _) = h.state();
-        let send = app.engine.session().track(kick).and_then(|t| t.mixer.sends.first().cloned().flatten());
-        assert!(send.is_some(), "the send was created");
-        assert_eq!(app.ui.send_window, Some((kick, 0)), "the new send's window is open");
-    }
-
-    /// So does a send made with "new bus...".
-    #[test]
-    fn a_send_to_a_new_bus_opens_its_send_window() {
-        let _palette = crate::theme::lock_test_palette();
-        let (mut h, kick) = kick_send_harness(false);
-        h.run();
-        h.get_by_label("Send A for Kick").click();
-        h.run();
-        h.get_by_label("new bus...").click();
-        h.run();
-        let (app, _) = h.state();
-        assert!(app.engine.session().track(kick).and_then(|t| t.mixer.sends.first().cloned().flatten()).is_some(), "the send was created");
-        assert_eq!(app.ui.send_window, Some((kick, 0)), "the new send's window is open");
-    }
-
-    /// Moving an existing send to another bus keeps the Send window as it was.
-    #[test]
-    fn changing_a_sends_destination_leaves_the_send_window_alone() {
-        let _palette = crate::theme::lock_test_palette();
-        let (mut h, kick) = kick_send_harness(true);
-        h.run();
-        h.get_by_label("Send A for Kick").click();
-        h.run();
-        h.get_by_label("Aux").click();
-        h.run();
-        let (app, _) = h.state();
-        let target = app.engine.session().track(kick).and_then(|t| t.mixer.sends.first().cloned().flatten()).map(|s| route_name(app, &s.target));
-        assert_eq!(target.as_deref(), Some("Aux"), "the send moved");
-        assert_eq!(app.ui.send_window, None, "no window opened");
-    }
 }

crates/ui-egui/src/panels/tracks.rs

@@ -46,28 +46,9 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) {
     if crate::widgets::icon_button(&mut ui.new_child(egui::UiBuilder::new().max_rect(plus)), plus.size(), "plus", false, &tip).clicked() {
         let _ = app.dialogs.open_for_command(&app.engine, "track.new");
     }
-    let tracks: Vec<(u64, String, bool, [u8; 3], bool, usize)> = {
+    let tracks: Vec<(u64, String, bool, [u8; 3], bool)> = {
         let s = app.engine.session();
-        s.tracks
-            .iter()
-            .map(|x| {
-                let mut current = x.folder;
-                let mut depth = 0;
-                let mut seen = Vec::new();
-                while let Some(folder_id) = current {
-                    if seen.contains(&folder_id) {
-                        break;
-                    }
-                    seen.push(folder_id);
-                    let Some(folder) = s.track(folder_id) else {
-                        break;
-                    };
-                    depth += 1;
-                    current = folder.folder;
-                }
-                (x.id.0, x.name.clone(), !x.hidden, x.color, s.edit.selected_tracks.contains(&x.id), depth)
-            })
-            .collect()
+        s.tracks.iter().map(|x| (x.id.0, x.name.clone(), !x.hidden, x.color, s.edit.selected_tracks.contains(&x.id))).collect()
     };
     let hidden = egui::scroll_area::ScrollBarVisibility::AlwaysHidden;
     let lists = with_pending_offset(egui::ScrollArea::vertical().id_salt("tracks_scroll"), ui, "tracks_scroll")
@@ -75,7 +56,7 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) {
         .auto_shrink([false, false])
         .scroll_bar_visibility(hidden);
     let out = lists.show(ui, |ui| {
-        for (id, name, shown, color, sel, depth) in tracks {
+        for (id, name, shown, color, sel) in tracks {
             let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), 17.0), Sense::click_and_drag());
             resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, true, sel, &name));
             if sel {
@@ -89,8 +70,7 @@ pub fn tracks_and_groups(app: &mut SoundApp, ui: &mut Ui) {
             }
             ui.painter().rect_filled(Rect::from_min_size(pos2(r.min.x + 20.0, r.min.y + 3.0), vec2(4.0, 11.0)), 0.0, rgb(color));
             ui.painter().with_clip_rect(r).text(
-                // Indent stops growing at eight levels so a deep name keeps room in the column.
-                pos2(r.min.x + 30.0 + depth.min(8) as f32 * 10.0, r.center().y),
+                pos2(r.min.x + 30.0, r.center().y),
                 Align2::LEFT_CENTER,
                 &name,
                 regular(11.5),

crates/ui-egui/src/toolbar.rs

@@ -6,7 +6,7 @@ use crate::{SoundApp, icons};
 use egui::{Align2, Color32, CornerRadius, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
 use serde_json::json;
 use soundcraft_engine::edit::{SHUFFLE_LOCK, SNAP_TO_GRID};
-use soundcraft_model::{EditMode, EditState, Tool};
+use soundcraft_model::{EditMode, Tool};
 use soundcraft_time::{TimeFormat, format_length};
 
 pub const HEIGHT: f32 = 78.0;
@@ -205,7 +205,14 @@ fn tools(app: &mut SoundApp, ui: &mut Ui) {
             ui.horizontal(|ui| {
                 ui.spacing_mut().item_spacing.x = 2.0;
                 let e = app.engine.session().edit.clone();
-                for (id, icon, on, tip) in option_toggles(&e) {
+                let toggles: [(&str, &str, bool, &str); 5] = [
+                    ("options.tab_to_transient", "tab_transient", e.tab_to_transient, "Tab to Transient"),
+                    ("options.link_timeline_edit", "link", e.link_timeline_edit, "Link Timeline and Edit Selection"),
+                    ("options.link_track_edit", "link", e.link_track_edit, "Link Track and Edit Selection"),
+                    ("options.mirrored_midi", "note", e.mirrored_midi, "Mirrored MIDI Editing"),
+                    ("options.automation_follows_edit", "wave", e.automation_follows_edit, "Automation Follows Edit"),
+                ];
+                for (id, icon, on, tip) in toggles {
                     if icon_button(ui, vec2(36.0, 18.0), icon, on, tip).clicked() {
                         let _ = app.run(id, json!({}));
                     }
@@ -220,18 +227,6 @@ fn tools(app: &mut SoundApp, ui: &mut Ui) {
     });
 }
 
-/// The Edit-window toolbar's option toggles: (command id, icon, on, tooltip).
-fn option_toggles(e: &EditState) -> [(&'static str, &'static str, bool, &'static str); 6] {
-    [
-        ("options.tab_to_transient", "tab_transient", e.tab_to_transient, "Tab to Transient"),
-        ("options.link_timeline_edit", "link", e.link_timeline_edit, "Link Timeline and Edit Selection"),
-        ("options.link_track_edit", "link_track", e.link_track_edit, "Link Track and Edit Selection"),
-        ("options.insertion_follows_playback", "insertion_follows", e.insertion_follows_playback, "Insertion Follows Playback"),
-        ("options.mirrored_midi", "note", e.mirrored_midi, "Mirrored MIDI Editing"),
-        ("options.automation_follows_edit", "wave", e.automation_follows_edit, "Automation Follows Edit"),
-    ]
-}
-
 fn fmt_pos(app: &SoundApp, at: i64, f: TimeFormat) -> String {
     let s = app.engine.session();
     s.format_position(at, f)
@@ -462,21 +457,3 @@ fn output_meter(app: &mut SoundApp, ui: &mut Ui) {
         crate::widgets::meter(ui, rr, m.level[c], m.hold[c], m.clip);
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// #1262: the two link toggles differ only by their icon, so each option toggle needs its own.
-    #[test]
-    fn option_toggles_have_distinct_icons() {
-        let toggles = option_toggles(&EditState::default());
-        let timeline = toggles.iter().find(|t| t.0 == "options.link_timeline_edit").unwrap();
-        let track = toggles.iter().find(|t| t.0 == "options.link_track_edit").unwrap();
-        assert_ne!(timeline.1, track.1, "the timeline and track links need different icons");
-        let mut icons: Vec<&str> = toggles.iter().map(|t| t.1).collect();
-        icons.sort_unstable();
-        icons.dedup();
-        assert_eq!(icons.len(), toggles.len(), "every option toggle needs its own icon");
-    }
-}

crates/ui-egui/tests/it/send_window.rs

@@ -1,6 +1,5 @@
 //! A send's level opens its Send window, as in Pro Tools: a fader with Alt-click for 0 dB, moved to
-//! another send by clicking that send's level, closed by clicking the same one again. Creating a send
-//! opens it too.
+//! another send by clicking that send's level, closed by clicking the same one again.
 
 use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
 use egui_kittest::Harness;
@@ -76,33 +75,6 @@ fn a_sends_level_opens_its_send_window() {
     assert!(h.query_by_label_contains("Vox · Send").is_none());
 }
 
-/// Creating a send opens its Send window, so the new send's fader is on screen right away (#1269). The
-/// window moves there from the send it was showing, and undoing the new send closes it.
-#[test]
-fn a_new_send_shows_its_fader_at_once() {
-    let (mut h, vox) = harness();
-    h.get_by_label("Send A level for Vox").click();
-    h.run_steps(3);
-    assert!(h.query_by_label_contains("Vox · Send A").is_some());
-
-    h.get_by_label("Send C for Vox").click();
-    h.run_steps(3);
-    // Send A's own "Verb" label is on screen too, so pick the menu's button.
-    h.get_by_role_and_label(egui::accesskit::Role::Button, "Verb").click();
-    h.run_steps(3);
-    assert!(h.state().engine.session().tracks[0].mixer.sends[2].is_some(), "send C was created");
-    assert_eq!(h.state().ui.send_window, Some((vox, 2)));
-    assert!(h.query_by_label_contains("Vox · Send C").is_some(), "the window shows the new send");
-    assert!(h.query_by_label_contains("Vox · Send A").is_none(), "and no longer send A");
-    assert!(h.query_by_label("Send level").is_some(), "the new send's fader is on screen");
-
-    h.state_mut().engine.execute("edit.undo", &json!({})).unwrap();
-    h.run_steps(3);
-    assert!(h.state().engine.session().tracks[0].mixer.sends[2].is_none(), "the send was undone");
-    assert_eq!(h.state().ui.send_window, None, "undoing the send closes its window");
-    assert!(h.query_by_label_contains("Vox · Send").is_none());
-}
-
 /// Escape first closes a send menu or cancels level typing, then a further Escape closes the send window.
 #[test]
 fn escape_closes_the_send_window_after_menus_and_typing() {

crates/ui-egui/tests/it/track_list.rs

@@ -50,16 +50,6 @@ impl Rig {
             .expect("row not in the Tracks list")
     }
 
-    fn text_x(&self, name: &str) -> f32 {
-        self.shapes
-            .iter()
-            .find_map(|c| match &c.shape {
-                Shape::Text(t) if t.galley.text() == name && t.pos.x < 150.0 => Some(t.pos.x),
-                _ => None,
-            })
-            .expect("text not in the Tracks list")
-    }
-
     fn press(&mut self, at: Pos2, pressed: bool) {
         self.frame(vec![
             Event::PointerMoved(at),
@@ -100,35 +90,3 @@ fn clicking_a_track_list_row_still_selects_the_track() {
     r.press(at, false);
     assert_eq!(r.app.engine.session().edit.selected_tracks, vec![r.order()[2]]);
 }
-
-#[test]
-fn a_track_inside_a_folder_is_indented_in_the_track_list() {
-    let mut r = Rig::new();
-    let child = r.order()[1];
-    let child_name = r.app.engine.session().track(child).unwrap().name.clone();
-    r.app.run("track.move_to_new_folder", json!({"tracks": [child.0], "name": "Folder"})).unwrap();
-    r.frame(vec![]);
-    let folder = r.app.engine.session().tracks.iter().find(|track| track.is_folder()).unwrap();
-
-    assert!(r.text_x(&child_name) > r.text_x(&folder.name), "child is not indented under the folder");
-}
-
-#[test]
-fn deeply_nested_tracks_keep_indenting_past_six_folders() {
-    let mut r = Rig::new();
-    let child = r.order()[1];
-    let child_name = r.app.engine.session().track(child).unwrap().name.clone();
-    r.app.run("track.move_to_new_folder", json!({"tracks": [child.0], "name": "Folder 1"})).unwrap();
-
-    let mut parent = r.app.engine.session().tracks.iter().find(|track| track.name == "Folder 1").unwrap().id;
-    for depth in 2..=7 {
-        r.app.run("track.move_to_new_folder", json!({"tracks": [parent.0], "name": format!("Folder {depth}")})).unwrap();
-        parent = r.app.engine.session().tracks.iter().find(|track| track.name == format!("Folder {depth}")).unwrap().id;
-    }
-    r.frame(vec![]);
-
-    // "Folder 1" is the child's own folder and the seventh level; "Folder 7" is the outermost.
-    assert_eq!(r.app.engine.session().track(parent).unwrap().name, "Folder 7");
-    assert!(r.text_x(&child_name) > r.text_x("Folder 1"), "deeply nested child is not indented under its own folder");
-    assert!(r.text_x("Folder 1") > r.text_x("Folder 2"), "each level indents further");
-}

crates/video/src/h264/dpb.rs

@@ -72,22 +72,6 @@ impl Dpb {
         self.entries.retain(|e| e.needed_for_output || e.mark != RefMark::Unused);
     }
 
-    /// Make room for a picture: output one (C.4.5.3), or, when none waits for output and
-    /// references alone fill the DPB (marking that keeps more than it holds), drop the reference
-    /// decoded longest ago. False when the DPB is empty.
-    fn make_room(&mut self, out: &mut Vec<Output>) -> bool {
-        if self.bump(out) {
-            return true;
-        }
-        let Some(i) = self.entries.iter().enumerate().filter(|(_, e)| e.mark != RefMark::Unused).min_by_key(|(_, e)| e.frame.id).map(|(i, _)| i)
-        else {
-            return false;
-        };
-        self.entries[i].mark = RefMark::Unused;
-        self.prune();
-        true
-    }
-
     /// Output the picture with the smallest POC (C.4.5.3 "bumping"). Returns false if none waits.
     fn bump(&mut self, out: &mut Vec<Output>) -> bool {
         let Some(i) = self.entries.iter().enumerate().filter(|(_, e)| e.needed_for_output).min_by_key(|(_, e)| e.poc).map(|(i, _)| i) else {
@@ -150,29 +134,21 @@ impl Dpb {
         poc_state: &mut dyn FnMut(u32),
     ) {
         let mut unused = (prev_ref_frame_num + 1) % max_frame_num;
-        // Only the last `max_num_ref_frames` missing frames can still be references when the gap
-        // ends: the sliding window drops the earlier ones first, so building their pictures would
-        // be work (up to 65 535 frame copies from one slice header) thrown straight away. They
-        // advance the POC state only.
-        let gap = (frame_num + max_frame_num - unused) % max_frame_num;
-        let skip = gap.saturating_sub(u32::try_from(max_num_ref_frames.max(1)).unwrap_or(u32::MAX));
         let mut guard = 0;
         while unused != frame_num && guard < max_frame_num {
+            self.sliding_window(unused, max_frame_num, max_num_ref_frames);
+            let (frame, meta) = make_frame(unused);
             poc_state(unused);
-            if guard >= skip {
-                self.sliding_window(unused, max_frame_num, max_num_ref_frames);
-                let (frame, meta) = make_frame(unused);
-                self.entries.push(DpbEntry {
-                    poc: frame.poc,
-                    frame,
-                    frame_num: unused,
-                    long_term_frame_idx: 0,
-                    mark: RefMark::Short,
-                    needed_for_output: false,
-                    non_existing: true,
-                    meta,
-                });
-            }
+            self.entries.push(DpbEntry {
+                poc: frame.poc,
+                frame,
+                frame_num: unused,
+                long_term_frame_idx: 0,
+                mark: RefMark::Short,
+                needed_for_output: false,
+                non_existing: true,
+                meta,
+            });
             unused = (unused + 1) % max_frame_num;
             guard += 1;
         }
@@ -301,11 +277,6 @@ impl Dpb {
                         }
                     }
                 }
-                3 | 6 if self.max_long_term_frame_idx.is_none_or(|max| m.long_term_frame_idx > max) => {
-                    // A long-term index outside what MMCO 4 (or the IDR) allowed (8.2.5.4.3): a
-                    // conforming stream never sends one, and honouring it would let distinct
-                    // indices retain references past the DPB's capacity.
-                }
                 3 => {
                     let pn = i64::from(curr_pic_num) - (i64::from(m.difference_of_pic_nums_minus1) + 1);
                     for e in &mut self.entries {
@@ -413,13 +384,13 @@ impl Dpb {
                     out.push(Output { frame, poc, meta });
                     return;
                 }
-                if !self.make_room(out) {
+                if !self.bump(out) {
                     break;
                 }
             }
         } else {
             while self.entries.len() >= self.capacity {
-                if !self.make_room(out) {
+                if !self.bump(out) {
                     break;
                 }
             }
@@ -458,98 +429,6 @@ mod tests {
         Mmco { op, difference_of_pic_nums_minus1: diff, long_term_pic_num: 0, long_term_frame_idx: 0, max_long_term_frame_idx_plus1: 0 }
     }
 
-    fn frame(id: u32) -> (FrameRef, Arc<OutputMeta>) {
-        let meta = OutputMeta {
-            pts: 0,
-            key: false,
-            crop: (0, 0, 0, 0),
-            full_range: false,
-            colour_primaries: 0,
-            transfer_characteristics: 0,
-            matrix_coefficients: 0,
-            sar: (1, 1),
-            draft: false,
-        };
-        (Arc::new(crate::h264::picture::Frame::new(id, 0, 1, 1)), Arc::new(meta))
-    }
-
-    /// A P slice header of a reference picture, with nothing else set.
-    fn reference_slice() -> SliceHeader {
-        SliceHeader {
-            nal_ref_idc: 1,
-            nal_unit_type: 1,
-            idr: false,
-            first_mb_in_slice: 0,
-            slice_type_raw: 0,
-            slice_type: SliceType::P,
-            pps_id: 0,
-            colour_plane_id: 0,
-            frame_num: 0,
-            field_pic: false,
-            bottom_field: false,
-            idr_pic_id: 0,
-            pic_order_cnt_lsb: 0,
-            delta_pic_order_cnt_bottom: 0,
-            delta_pic_order_cnt: [0; 2],
-            redundant_pic_cnt: 0,
-            direct_spatial_mv_pred: false,
-            num_ref_idx_active: [1, 0],
-            ref_pic_list_mod: [Vec::new(), Vec::new()],
-            pred_weight_table: None,
-            no_output_of_prior_pics: false,
-            long_term_reference: false,
-            adaptive_ref_pic_marking: false,
-            mmcos: Vec::new(),
-            cabac_init_idc: 0,
-            slice_qp_delta: 0,
-            sp_for_switch: false,
-            slice_qs_delta: 0,
-            disable_deblocking_filter_idc: 0,
-            slice_alpha_c0_offset_div2: 0,
-            slice_beta_offset_div2: 0,
-            slice_group_change_cycle: 0,
-            header_bits: 0,
-        }
-    }
-
-    #[test]
-    fn a_frame_num_gap_builds_only_the_frames_that_stay_references() {
-        let mut dpb = Dpb::new();
-        let (mut built, mut poc_updates) = (Vec::new(), 0u32);
-        // frame_num 0 was the last reference; the next slice says 60_000: 59 999 missing frames.
-        dpb.fill_frame_num_gap(0, 60_000, 1 << 16, 4, &mut |n| (built.push(n), frame(n)).1, &mut |_| poc_updates += 1);
-        assert_eq!(poc_updates, 59_999, "every missing frame advances the POC state");
-        assert_eq!(built, vec![59_996, 59_997, 59_998, 59_999], "only the ones the sliding window would keep are built");
-        assert_eq!(dpb.entries.iter().map(|e| e.frame_num).collect::<Vec<_>>(), built);
-        // A gap shorter than the window builds every frame, as before.
-        let mut dpb = Dpb::new();
-        let mut built = Vec::new();
-        dpb.fill_frame_num_gap(7, 10, 16, 4, &mut |n| (built.push(n), frame(n)).1, &mut |_| {});
-        assert_eq!(built, vec![8, 9]);
-    }
-
-    #[test]
-    fn long_term_marking_cannot_grow_the_dpb_past_its_capacity() {
-        let mut dpb = Dpb::new();
-        dpb.capacity = 4;
-        let mut out = Vec::new();
-        let mut sh = SliceHeader { adaptive_ref_pic_marking: true, ..reference_slice() };
-        // Each picture takes a distinct long-term index, after MMCO 4 allowed 1000 of them.
-        for n in 0..40u32 {
-            sh.frame_num = n;
-            sh.mmcos = vec![Mmco { op: 4, max_long_term_frame_idx_plus1: 1000, ..mmco(0, 0) }, Mmco { op: 6, long_term_frame_idx: n, ..mmco(0, 0) }];
-            let (f, meta) = frame(n);
-            dpb.store_picture(&sh, f, n as i32, 1 << 16, 16, meta, &mut out);
-            assert!(dpb.entries.len() <= 4, "{} entries after picture {n}", dpb.entries.len());
-        }
-        // An index past what MMCO 4 allowed is ignored: the picture is a short-term reference.
-        sh.frame_num = 40;
-        sh.mmcos = vec![Mmco { op: 6, long_term_frame_idx: 5000, ..mmco(0, 0) }];
-        let (f, meta) = frame(40);
-        dpb.store_picture(&sh, f, 40, 1 << 16, 16, meta, &mut out);
-        assert_eq!(dpb.entries.iter().find(|e| e.frame_num == 40).map(|e| e.mark), Some(RefMark::Short));
-    }
-
     #[test]
     fn mmco_huge_difference_does_not_panic() {
         for op in [1, 3] {

crates/video/src/h264/params.rs

@@ -397,10 +397,6 @@ impl Sps {
         let pic_height_in_map_units = plus(r.read_ue()?, 1, "picture too large")?;
         ensure!(pic_width_in_mbs <= 1024 && pic_height_in_map_units <= 1024, "picture too large");
         let frame_mbs_only = r.read_flag()?;
-        // Picture state is allocated from these before any macroblock is read: the movie's pixel
-        // budget applies here too, so a 16 384-square SPS can't claim its planes.
-        let coded_mbs = u64::from(pic_width_in_mbs) * u64::from(pic_height_in_map_units) * if frame_mbs_only { 1 } else { 2 };
-        ensure!(coded_mbs * 256 <= crate::movie::MAX_PIXELS, "picture too large");
         let mb_adaptive_frame_field = if !frame_mbs_only { r.read_flag()? } else { false };
         let direct_8x8_inference = r.read_flag()?;
         let frame_crop = if r.read_flag()? { Some((r.read_ue()?, r.read_ue()?, r.read_ue()?, r.read_ue()?)) } else { None };
@@ -703,37 +699,6 @@ mod tests {
         assert_eq!(l, [10; 16]);
     }
 
-    #[test]
-    fn an_sps_past_the_pixel_budget_is_refused_before_allocation() {
-        // As `parse_minimal_baseline_sps`, with `mbs` × `mbs` macroblocks.
-        let sps = |mbs: u32, frame_mbs_only: bool| {
-            let mut w = BitWriter::new();
-            w.write_bits(66, 8);
-            w.write_bits(0xC0, 8);
-            w.write_bits(30, 8);
-            w.write_ue(0);
-            w.write_ue(0);
-            w.write_ue(2);
-            w.write_ue(1);
-            w.write_bit(false);
-            w.write_ue(mbs - 1);
-            w.write_ue(mbs - 1);
-            w.write_bit(frame_mbs_only);
-            if !frame_mbs_only {
-                w.write_bit(false); // mb_adaptive_frame_field
-            }
-            w.write_bit(true);
-            w.write_bit(false);
-            w.write_bit(false);
-            w.rbsp_trailing();
-            Sps::parse(&w.finish())
-        };
-        assert!(sps(512, true).is_ok(), "8192 × 8192 is the budget");
-        assert!(sps(513, true).is_err(), "one macroblock column more is past it");
-        assert!(sps(512, false).is_err(), "field pictures double the map units");
-        assert!(sps(362, false).is_ok());
-    }
-
     #[test]
     fn parse_minimal_baseline_sps() {
         // profile 66, level 30, sps_id 0, log2_max_frame_num_minus4 0, poc type 2, 1 ref, 11x9 MBs.

crates/vst3-host/src/ffi/instance.rs

@@ -75,8 +75,6 @@ pub(crate) struct Instance {
     pub(super) active: bool,
     pub(super) processing: bool,
     pub(super) max_frames: usize,
-    /// `kRealtime` or `kOffline`, for `setupProcessing` and every `process` call.
-    pub(super) process_mode: i32,
     pub(super) in_params: ComWrapper<ParamChanges>,
     pub(super) out_params: ComWrapper<ParamChanges>,
     pub(super) in_events: ComWrapper<EventList>,
@@ -253,12 +251,6 @@ impl Instance {
         self.active
     }
 
-    /// Offline (`kOffline`: no realtime pressure, e.g. a bounce) or realtime processing, from the
-    /// next [`Instance::configure`] on.
-    pub fn set_offline(&mut self, offline: bool) {
-        self.process_mode = if offline { sv::ProcessModes_::kOffline } else { sv::ProcessModes_::kRealtime } as i32;
-    }
-
     fn bus_count(&self, media: sv::MediaTypes, dir: sv::BusDirections) -> i32 {
         // SAFETY: valid component.
         unsafe { self.component.getBusCount(media as sv::MediaType, dir as sv::BusDirection) }.max(0)
@@ -367,8 +359,12 @@ impl Instance {
             return Err(Vst3Error::Process("plugin cannot process 32-bit float".into()));
         }
         let max = i32::try_from(max_frames).unwrap_or(i32::MAX);
-        let mut setup =
-            sv::ProcessSetup { processMode: self.process_mode, symbolicSampleSize: sample32, maxSamplesPerBlock: max, sampleRate: sample_rate };
+        let mut setup = sv::ProcessSetup {
+            processMode: sv::ProcessModes_::kRealtime as i32,
+            symbolicSampleSize: sample32,
+            maxSamplesPerBlock: max,
+            sampleRate: sample_rate,
+        };
         // SAFETY: valid processor, inactive; `setup` is a valid struct for the call.
         if !ok(unsafe { p.setupProcessing(&mut setup) }) {
             return Err(Vst3Error::Process("setupProcessing failed".into()));
@@ -454,7 +450,7 @@ impl Instance {
             None => self.context.projectTimeSamples = project_time,
         }
         let mut data = sv::ProcessData {
-            processMode: self.process_mode,
+            processMode: sv::ProcessModes_::kRealtime as i32,
             symbolicSampleSize: sv::SymbolicSampleSizes_::kSample32 as i32,
             numSamples: i32::try_from(frames).unwrap_or(0),
             numInputs: i32::try_from(inputs.bufs.len()).unwrap_or(0),

crates/vst3-host/src/ffi/module.rs

@@ -137,16 +137,6 @@ mod cf {
     }
 }
 
-/// A libloading error with the system's reason. libloading's own text is only "dlopen failed"
-/// (or "dlsym failed", "LoadLibraryExW failed"); the reason (`dlerror`, the Windows error) is its
-/// source.
-fn with_reason(e: &libloading::Error) -> String {
-    match std::error::Error::source(e) {
-        Some(why) => format!("{e}: {why}"),
-        None => e.to_string(),
-    }
-}
-
 /// Opens the shared library and runs the platform module entry (`bundleEntry` with a
 /// `CFBundleRef` on macOS, `InitDll` on Windows, `ModuleEntry` with the `dlopen` handle on Linux).
 /// Also returns the matching module exit, when the entry ran and the module exports one.
@@ -156,7 +146,7 @@ fn open_library(bundle: &Path, exe: &Path) -> Result<(libloading::Library, Optio
         use libloading::os::unix::{Library as UnixLib, RTLD_LOCAL, RTLD_NOW};
         // SAFETY: loading a shared library runs its static initialisers. That is inherent to
         // hosting plugins; we only load files found in VST3 plugin folders or named explicitly.
-        let lib = unsafe { UnixLib::open(Some(exe), RTLD_NOW | RTLD_LOCAL) }.map_err(|e| with_reason(&e))?;
+        let lib = unsafe { UnixLib::open(Some(exe), RTLD_NOW | RTLD_LOCAL) }.map_err(|e| e.to_string())?;
         type ModuleEntry = unsafe extern "C" fn(*mut c_void) -> bool;
         // SAFETY: `ModuleEntry` is the VST3-mandated Linux entry with this signature.
         let entry = unsafe { lib.get::<ModuleEntry>(b"ModuleEntry\0") }.ok().map(|s| *s);
@@ -180,7 +170,7 @@ fn open_library(bundle: &Path, exe: &Path) -> Result<(libloading::Library, Optio
     {
         // SAFETY: loading a shared library runs its static initialisers. That is inherent to
         // hosting plugins; we only load files found in VST3 plugin folders or named explicitly.
-        let lib = unsafe { libloading::Library::new(exe) }.map_err(|e| with_reason(&e))?;
+        let lib = unsafe { libloading::Library::new(exe) }.map_err(|e| e.to_string())?;
         let mut exit: Option<ModuleExit> = None;
         #[cfg(windows)]
         {
@@ -345,7 +335,7 @@ impl Bundle {
         // SAFETY: `GetPluginFactory` is the VST3-mandated export with this signature.
         let get = match unsafe { lib.get::<GetFactory>(b"GetPluginFactory\0") } {
             Ok(sym) => *sym,
-            Err(e) => return Err(fail(format!("not a VST3 plugin (no GetPluginFactory): {}", with_reason(&e)))),
+            Err(e) => return Err(fail(format!("not a VST3 plugin: {e}"))),
         };
         // SAFETY: the module is loaded and its entry function (if any) has run.
         let raw = unsafe { get() };
@@ -459,7 +449,6 @@ impl Bundle {
             active: false,
             processing: false,
             max_frames: 0,
-            process_mode: sv::ProcessModes_::kRealtime as i32,
             in_params: ComWrapper::new(ParamChanges::new(PARAM_QUEUE_CAP)),
             out_params: ComWrapper::new(ParamChanges::new(PARAM_QUEUE_CAP)),
             in_events: ComWrapper::new(EventList::new(EVENT_CAP)),

crates/vst3-host/src/lib.rs

@@ -307,21 +307,6 @@ mod tests {
         let _ = std::fs::remove_dir_all(&d);
     }
 
-    /// A binary the system refuses to load reports the system's reason (missing library, wrong
-    /// glibc, not an ELF file), not just "dlopen failed".
-    #[test]
-    fn a_binary_that_does_not_load_says_why() {
-        let d = std::env::temp_dir().join(format!("soundcraft-vst3-reason-{}", std::process::id()));
-        let _ = std::fs::remove_dir_all(&d);
-        std::fs::create_dir_all(&d).unwrap();
-        let f = d.join("garbage.vst3");
-        std::fs::write(&f, b"\x7fELF this is not a plugin \x00\x01\x02").unwrap();
-        let msg = load_bundle(&f).err().map(|e| e.to_string()).unwrap_or_default();
-        let reason = msg.split_once("failed: ").map_or("", |(_, r)| r.trim());
-        assert!(!reason.is_empty(), "no reason in: {msg}");
-        let _ = std::fs::remove_dir_all(&d);
-    }
-
     // Unix only: the test points a ".vst3" at a system library through a symlink.
     #[cfg(unix)]
     #[test]
@@ -341,7 +326,6 @@ mod tests {
         std::os::unix::fs::symlink(&lib, d.join("z.vst3")).unwrap();
         let e = load_bundle(&d.join("z.vst3")).unwrap_err();
         assert!(e.to_string().contains("not a VST3 plugin"), "{e}");
-        assert!(e.to_string().contains("GetPluginFactory"), "the system's reason names the missing export: {e}");
         let _ = std::fs::remove_dir_all(&d);
     }
 }

crates/vst3-host/src/plugin.rs

@@ -259,11 +259,6 @@ impl Plugin for Vst3Plugin {
         }
     }
 
-    fn set_offline(&mut self, offline: bool) {
-        // `processMode`, set up by the next `prepare`.
-        self.inst.set_offline(offline);
-    }
-
     fn reset(&mut self) {
         // Keep pending releases and release whatever is still held, so the processor's voices stop
         // on the next block instead of sounding on while the host forgets them.

crates/vst3-host/tests/fixture/src/lib.rs

@@ -14,9 +14,8 @@
 //! - "Fixture Wide 16x64", "Fixture Wide 32 buses", "Fixture Wide 65 buses", "Fixture Wide 65
 //!   channels" (`Fx`): effects advertising wide layouts (16 buses of 64 channels, 32 and 65 buses
 //!   of 2 channels, one bus of 65 channels per direction), through `getBusInfo` only. `process` writes 1.0 into every channel
-//!   of output bus 0 when the host's buffers match the advertised layout (2.0 when the host set it
-//!   up and runs it with `kOffline`), -1.0 when they do not or when `process` gets another
-//!   `processMode` than `setupProcessing` did. Report 3 samples of latency.
+//!   of output bus 0 when the host's buffers match the advertised layout, -1.0 when they do not.
+//!   Report 3 samples of latency.
 //!
 //! The module checks the host's module lifecycle the way real plugins depend on it (see "module
 //! lifecycle" below) and aborts the process when it is broken.
@@ -26,7 +25,7 @@
 #![allow(non_snake_case, clippy::missing_safety_doc)]
 
 use std::ffi::{c_char, c_int, c_void};
-use std::sync::atomic::{AtomicBool, AtomicI32, AtomicI64, AtomicU32, AtomicU64, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU32, AtomicU64, AtomicUsize, Ordering};
 use vst3::Steinberg::Vst::*;
 use vst3::Steinberg::*;
 use vst3::{Class, ComRef, ComWrapper, uid};
@@ -641,8 +640,6 @@ impl IEditControllerTrait for Synth {
 struct Wide {
     buses: i32,
     channels: i32,
-    /// The `processMode` of the last `setupProcessing`.
-    mode: AtomicI32,
     _live: Live,
 }
 
@@ -707,8 +704,7 @@ impl IAudioProcessorTrait for Wide {
     unsafe fn getLatencySamples(&self) -> u32 {
         3
     }
-    unsafe fn setupProcessing(&self, setup: *mut ProcessSetup) -> tresult {
-        self.mode.store(unsafe { &*setup }.processMode, Ordering::Relaxed);
+    unsafe fn setupProcessing(&self, _setup: *mut ProcessSetup) -> tresult {
         kResultOk
     }
     unsafe fn setProcessing(&self, _state: TBool) -> tresult {
@@ -718,11 +714,10 @@ impl IAudioProcessorTrait for Wide {
         let d = unsafe { &*data };
         let fits =
             |bufs: *mut AudioBusBuffers, n: i32| n == self.buses && (0..n as usize).all(|i| unsafe { &*bufs.add(i) }.numChannels == self.channels);
-        let ok = fits(d.inputs, d.numInputs) && fits(d.outputs, d.numOutputs) && d.processMode == self.mode.load(Ordering::Relaxed);
-        let fit = if d.processMode == ProcessModes_::kOffline as i32 { 2.0 } else { 1.0 };
+        let ok = fits(d.inputs, d.numInputs) && fits(d.outputs, d.numOutputs);
         if d.numOutputs > 0 {
             for ch in unsafe { channels(&*d.outputs, d.numSamples.max(0) as usize) } {
-                ch.fill(if ok { fit } else { -1.0 });
+                ch.fill(if ok { 1.0 } else { -1.0 });
             }
         }
         kResultOk
@@ -796,7 +791,7 @@ impl IPluginFactoryTrait for Factory {
             .into_iter()
             .find_map(|(c, layout)| (c == cid).then_some(layout))
         {
-            ComWrapper::new(Wide { buses, channels, mode: AtomicI32::new(-1), _live: Live::new(&OBJECTS) }).to_com_ptr::<FUnknown>()
+            ComWrapper::new(Wide { buses, channels, _live: Live::new(&OBJECTS) }).to_com_ptr::<FUnknown>()
         } else {
             None
         };

crates/vst3-host/tests/it/fixture_e2e.rs

@@ -331,18 +331,6 @@ fn layouts_beyond_the_host_limits_are_rejected_not_truncated() {
     }
 }
 
-#[test]
-fn offline_renders_set_up_and_process_in_offline_mode() {
-    for (offline, want) in [(false, 1.0), (true, 2.0)] {
-        let mut p = soundcraft_vst3_host::create(&id_of("Fixture Wide 16x64")).unwrap();
-        p.set_offline(offline);
-        p.prepare(44_100.0, 64, 2);
-        let mut io = vec![vec![0.5f32; 64]; 2];
-        p.process(&mut io, 64);
-        assert!(io.iter().flatten().all(|&x| x == want), "offline {offline}: {:?}", &io[0][..4]);
-    }
-}
-
 #[test]
 fn many_buses_like_multi_out_instruments_are_activated() {
     // Multi-out instruments declare dozens of buses (SSD Sampler 5: 32); only the main one is

docs/cli.md

@@ -38,7 +38,7 @@ Results go to standard output, as JSON where a program is meant to read them. `i
 file), `describe`, `app` and the `--inspect` output of `run` and `script` pretty-print it; `--compact`
 prints the same JSON on one line. The result lines of `run` and `script` (`ID: JSON`) and the
 `--bounce` and `--save` results are always one line each. `commands`, `plugins`, `parity` and the
-`.scraft` summary of `info` are text. Errors go to standard error as `error: <message>`, and so do the warnings and errors SoundCraft and the plugin hosts log (`warning: <message>`, `error: <message>`), such as a plugin that fails to load. `mcp` writes only the protocol
+`.scraft` summary of `info` are text. Errors go to standard error as `error: <message>`. `mcp` writes only the protocol
 to standard output.
 
 | Exit code | Meaning |

docs/file-format-parity.md

@@ -1,6 +1,6 @@
 # File-format parity
 
-> **Last reviewed:** 2026-10-19 · **Last updated:** 2026-11-02 · **Change:** trivial (bounces carry a BWF time reference, #1296; previously trivial: Float32 file headroom, #791) · **Target:** Avid Pro Tools Ultimate 2026.4.1
+> **Last reviewed:** 2026-10-19 · **Last updated:** 2026-10-19 · **Change:** trivial (Float32 file headroom, #791) · **Target:** Avid Pro Tools Ultimate 2026.4.1
 
 Every format Pro Tools reads or writes, and ours. The Pro Tools list comes from the document types
 its bundle declares (`CFBundleDocumentTypes` in Info.plist: names only, nothing else read) and its
@@ -33,7 +33,7 @@ Legend: ✅ supported and tested · 🟡 partial · ❌ missing · — not appli
 
 | Format | Pro Tools | Read | Write | Tests / notes |
 |---|---|---|---|---|
-| WAV / BWF (PCM 16/24/32, float 32), `bext` | native | ✅ | ✅ | Native reader/writer, TPDF dither option; Float32 retains finite headroom (#791); also 8-bit and float 64 read. An empty data chunk followed by metadata reads as no audio; an unfinalised recording's audio is still read (#466). WAV bounces (mix and stems) carry a `bext` TimeReference: the session's timecode start plus the bounce start (#1296). |
+| WAV / BWF (PCM 16/24/32, float 32), `bext` | native | ✅ | ✅ | Native reader/writer, TPDF dither option; Float32 retains finite headroom (#791); also 8-bit and float 64 read. An empty data chunk followed by metadata reads as no audio; an unfinalised recording's audio is still read (#466). |
 | RF64 / BW64 (> 4 GiB) | read/write | ✅ | ✅ | `encode_wav_rf64` |
 | WAV `WAVE_FORMAT_EXTENSIBLE` multichannel with channel mask | read/write | ✅ | ✅ | `encode_with_channel_mask`; default 5.1 import creates a stereo track (#89, PR #128) |
 | AIFF / AIFF-C | native | ✅ | ✅ (`fl32`) | Native; `fl32` retains finite headroom (#791) |
@@ -80,7 +80,6 @@ Legend: ✅ supported and tested · 🟡 partial · ❌ missing · — not appli
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-11-02 | trivial | WAV bounces (mix and stems) write a `bext` TimeReference: session timecode start plus bounce start (#1296) |
 | 2026-10-19 | trivial | WAV and AIFF-C Float32 encoders retain finite headroom (#791); whole-file, streaming and bounce regression tests |
 | 2026-10-13 | trivial | WAV: empty data chunk with trailing metadata (#466) |
 | 2026-10-13 | minor | Fade curvature round-trips in sessions with a zero default for older files. Format version and readiness estimate unchanged |

xtask/src/version.rs

@@ -197,11 +197,8 @@ mod tests {
 
     #[test]
     fn a_failed_update_restores_the_manifest() {
-        // Created exclusively: a folder already there (planted, or left by a failed run) would be
-        // someone else's, and a link inside it could redirect the writes below.
-        let nanos = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.subsec_nanos());
-        let root = std::env::temp_dir().join(format!("xtask-version-restore-{}-{nanos}", std::process::id()));
-        std::fs::create_dir(&root).unwrap();
+        let root = std::env::temp_dir().join(format!("xtask-version-restore-{}", std::process::id()));
+        std::fs::create_dir_all(&root).unwrap();
         let path = root.join("Cargo.toml");
         std::fs::write(&path, MANIFEST).unwrap();
         let err = set(&root, &path, MANIFEST, "2.0.0", || Err("cargo update failed".into())).unwrap_err();