665bfac0b339
disk_cache.rs
//! The persistent disk cache (PRV-2) through the session: settings, layer cache persistence
//! across restarts, invalidation on edits, purging.
use serde_json::json;
use crate::Session;
use crate::render::RenderOpts;
fn folder(name: &str) -> String {
let d = std::env::temp_dir().join(format!("effectcraft-session-disk-{name}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
d.to_string_lossy().to_string()
}
fn session(dir: &str) -> Session {
let mut s = Session::default();
s.execute_checked("prefs.set", json!({"values": {"disk.diskCacheFolder": dir, "disk.diskCacheEnabled": true}})).unwrap();
// Write every layer buffer, however quick to render.
s.disk_cache.as_ref().unwrap().set_min_layer_ms(0);
s
}
fn project(s: &mut Session) -> effectcraft_project::ItemId {
s.execute("comp.new", json!({"name": "D", "width": 160, "height": 90, "frameRate": 30, "duration": 1})).unwrap();
s.execute("layer.newSolid", json!({"color": "#3080ff", "width": 80, "height": 40})).unwrap();
s.execute("effect.apply", json!({"layer": "#1", "effect": "Gaussian Blur"})).unwrap();
s.execute("prop.set", json!({"layer": "#1", "path": "effects/#1/blurriness", "value": 12})).unwrap();
s.active_comp_id().unwrap()
}
#[test]
fn disk_cache_settings_persistence_and_invalidation() {
crate::tests::roto::hold_roto_cache_test_lock();
let dir = folder("persist");
let mut s = session(&dir);
let st = s.execute_checked("cache.diskStats", json!({})).unwrap();
assert_eq!(st["enabled"], json!(true));
assert_eq!(st["maxBytes"], json!(20u64 << 30));
let cid = project(&mut s);
let t = s.time();
let first = s.render(cid, t, RenderOpts::default());
let dc = s.disk_cache.clone().unwrap();
dc.flush();
let written = dc.stats().entries;
assert!(written > 0, "layer buffers written");
// "Restart": a new session on the same folder and project renders from disk.
let saved = s.project.clone();
drop(s);
let mut s2 = session(&dir);
s2.project = saved;
s2.bump();
s2.open_comp(cid);
let dc2 = s2.disk_cache.clone().unwrap();
assert_eq!(dc2.stats().entries, written);
let again = s2.render(cid, t, RenderOpts::default());
assert!(dc2.stats().hits > 0, "{:?}", dc2.stats());
assert_eq!(again.data, first.data, "disk-cached pixels are exact");
// An edit changes the keys: a miss, and new entries.
let hits = dc2.stats().hits;
s2.execute("prop.set", json!({"layer": "#1", "path": "effects/#1/blurriness", "value": 20})).unwrap();
let edited = s2.render(cid, t, RenderOpts::default());
assert_ne!(edited.data, first.data);
assert_eq!(dc2.stats().hits, hits);
dc2.flush();
assert!(dc2.stats().entries > written);
// Purge ▸ All Disk Cache empties it; memory purge leaves the disk alone.
let r = s2.execute_checked("edit.purge", json!({"what": "memory"})).unwrap();
assert_eq!(r["diskEntries"], json!(0));
assert!(dc2.stats().entries > 0);
let r = s2.execute_checked("edit.purge", json!({"what": "disk"})).unwrap();
assert!(r["diskEntries"].as_u64().unwrap() > 0);
assert_eq!(dc2.stats().entries, 0);
// Disabling detaches it.
s2.execute_checked("prefs.set", json!({"key": "disk.diskCacheEnabled", "value": false})).unwrap();
assert!(s2.disk_cache.is_none());
assert!(s2.layer_cache.disk().is_none());
}
/// The comp key comes from the project in memory: a footage file that changes on disk doesn't
/// change it (the entries check their own files, #3184); edits that change pixels do.
#[test]
fn comp_content_keys_come_from_memory() {
let dir = folder("keys");
let mut s = session(&dir);
let foot = std::env::temp_dir().join(format!("effectcraft-keys-{}.png", std::process::id()));
std::fs::write(&foot, b"one").unwrap();
s.edit("add", None, |p, _| {
let f = effectcraft_project::Footage {
path: foot.to_string_lossy().to_string(),
kind: effectcraft_project::FootageKind::Still,
width: 1,
height: 1,
pixel_aspect: 1.0,
frame_rate: effectcraft_time::FrameRate::FPS_30,
native_rate: None,
duration: effectcraft_time::Tick::ZERO,
has_video: true,
has_audio: false,
alpha: effectcraft_project::AlphaMode::Ignore,
premul_color: [0.0; 3],
loop_count: 1,
codec: "PNG".into(),
missing: false,
sequence: vec![],
color_profile: None,
layer: None,
..Default::default()
};
p.add_item("f.png", effectcraft_color::Label::Lavender, None, effectcraft_project::ItemKind::Footage(f));
Ok(())
})
.unwrap();
let cid = project(&mut s);
let k1 = effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
std::fs::write(&foot, b"two, longer").unwrap();
assert_eq!(effectcraft_render::disk_cache::comp_content_key(&s.project, cid), k1, "no file is looked at");
s.execute("prop.set", json!({"layer": "#1", "path": "transform/opacity", "value": 50})).unwrap();
let k2 = effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
assert_ne!(k1, k2);
// Switches that don't change pixels (Audio, Lock, Shy, Hide Shy Layers) don't change it (#103).
for sw in ["audio", "lock", "shy"] {
s.execute("layer.setSwitch", json!({"layers": ["#1"], "switch": sw, "value": sw != "audio"})).unwrap();
}
s.execute("comp.setSwitch", json!({"switch": "hideShy", "value": true})).unwrap();
assert_eq!(effectcraft_render::disk_cache::comp_content_key(&s.project, cid), k2);
// Unrelated comps do not change it.
s.execute("comp.new", json!({"name": "Other", "width": 10, "height": 10, "frameRate": 30, "duration": 1})).unwrap();
assert_eq!(effectcraft_render::disk_cache::comp_content_key(&s.project, cid), k2);
// A proxy, and its Use Proxy switch, change the pixels.
let set_proxy = |s: &mut Session, enabled: bool| {
let it = std::sync::Arc::make_mut(&mut s.project).items.get_mut(&cid).unwrap();
it.proxy = Some(Box::new(effectcraft_project::Proxy { footage: effectcraft_project::Footage::default(), enabled }));
effectcraft_render::disk_cache::comp_content_key(&s.project, cid)
};
let k3 = set_proxy(&mut s, true);
assert_ne!(k3, k2);
assert_ne!(set_proxy(&mut s, false), k3);
}
/// No salt and no scan (#3184, replacing the background footage salt of #3106): the disk cache
/// is attached to the layer cache as soon as it is switched on, and stays attached through
/// edits that add footage (a large image sequence included), settings changes and opening a
/// project, none of which looks at a single file for it. The first render may use it at once.
#[test]
fn the_disk_cache_is_attached_at_once_and_edits_do_no_file_work() {
let dir = folder("attach");
let mut s = session(&dir);
let dc = s.disk_cache.clone().unwrap();
let attached = |s: &Session| s.layer_cache.disk().is_some_and(|d| std::sync::Arc::ptr_eq(&d, &dc));
assert!(attached(&s), "attached at once");
// A sequence of 5000 frames that don't even exist.
let seq_dir = std::env::temp_dir().join(format!("effectcraft-no-scan-{}", std::process::id()));
let f = effectcraft_project::Footage {
path: seq_dir.join("f_00000.exr").to_string_lossy().to_string(),
kind: effectcraft_project::FootageKind::Sequence,
sequence: (0..5000).map(|i| seq_dir.join(format!("f_{i:05}.exr")).to_string_lossy().to_string()).collect(),
width: 8,
height: 8,
has_video: true,
..Default::default()
};
s.edit("add", None, |p, _| {
p.add_item("seq", effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f));
Ok(())
})
.unwrap();
assert!(attached(&s), "an import keeps it attached");
let cid = project(&mut s);
s.execute("prop.set", json!({"layer": "#1", "path": "transform/opacity", "value": 50})).unwrap();
s.execute_checked("prefs.set", json!({"key": "disk.diskCacheMaxGb", "value": 30})).unwrap();
assert!(attached(&s), "edits and other settings keep it attached");
let same = (*s.project).clone();
s.replace_project(same, None);
assert!(attached(&s), "opening a project keeps it attached");
// The first render uses it: a solid reads no file, so nothing is checked either.
s.render(cid, s.time(), RenderOpts::default());
dc.flush();
assert!(dc.stats().entries > 0, "written by the first render");
assert_eq!(dc.file_checks(), 0, "no file looked at for the disk cache");
// Switched off and on: attached again at once.
s.execute_checked("prefs.set", json!({"key": "disk.diskCacheEnabled", "value": false})).unwrap();
assert!(s.layer_cache.disk().is_none());
s.execute_checked("prefs.set", json!({"key": "disk.diskCacheEnabled", "value": true})).unwrap();
assert!(s.layer_cache.disk().is_some());
}
/// Marker edits keep the disk key (the sound of a playing preview must not wait for frames to
/// render again, #1083); an expression that reads markers makes them count.
#[test]
fn markers_keep_the_content_key_unless_an_expression_reads_them() {
let mut s = Session::default();
s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
let cid = s.active_comp_id().unwrap();
let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
let k0 = key(&s);
s.execute("comp.addMarker", json!({"time": 0.5, "comment": "beat"})).unwrap();
s.execute("markers.set", json!({"layer": l, "new": true, "time": 0.25})).unwrap();
assert_eq!(key(&s), k0, "markers");
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
let k1 = key(&s);
assert_ne!(k1, k0);
s.execute("comp.addMarker", json!({"time": 1.0})).unwrap();
assert_ne!(key(&s), k1, "a marker read by an expression");
}
/// A comp marker alone (no layer marker beside it) keeps the key too.
#[test]
fn a_lone_comp_marker_keeps_the_content_key() {
let mut s = Session::default();
s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
let cid = s.active_comp_id().unwrap();
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
let k0 = key(&s);
s.execute("comp.addMarker", json!({"time": 0.5, "comment": "beat"})).unwrap();
assert_eq!(key(&s), k0);
}
/// A protected marker with a duration retimes a stretched precomp layer (Responsive Design), so
/// changing it changes the key of the comp that nests it; a plain marker beside it does not.
#[test]
fn protected_markers_with_a_duration_change_the_content_key() {
let mut s = Session::default();
s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "frameRate": 30, "duration": 4})).unwrap();
let inner = s.active_comp_id().unwrap();
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "frameRate": 30, "duration": 10})).unwrap();
let outer = s.active_comp_id().unwrap();
let l = s.execute("layer.addItem", json!({"item": inner.0})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.select", json!({"layers": [l]})).unwrap();
s.execute("layer.timeStretch", json!({"percent": 200})).unwrap();
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, outer);
let k0 = key(&s);
s.execute("comp.addMarker", json!({"comp": inner.0, "time": 2.0, "comment": "beat"})).unwrap();
assert_eq!(key(&s), k0, "a plain marker");
s.execute("comp.addMarker", json!({"comp": inner.0, "time": 1.0})).unwrap();
let index = s.project.comp(inner).unwrap().markers.iter().position(|m| m.time.seconds() == 1.0).unwrap();
s.execute("markers.set", json!({"comp": inner.0, "index": index, "duration": 1.0, "protected": true})).unwrap();
let k1 = key(&s);
assert_ne!(k1, k0, "a protected marker with a duration");
s.execute("markers.set", json!({"comp": inner.0, "index": index, "duration": 2.0})).unwrap();
assert_ne!(key(&s), k1, "its duration");
}
/// With expressions the comp key covers what they can read, not the whole project (#3184,
/// #1492): an expression reading only its own comp keeps the key through edits of another comp
/// and of unused footage; `comp("Other")` makes "Other" count (and which comps have that name),
/// not a third comp; a computed name counts every item.
#[test]
fn expressions_reach_only_what_they_name() {
let mut s = Session::default();
let comp = |s: &mut Session, name: &str| {
let c = s.execute("comp.new", json!({"name": name, "width": 8, "height": 8, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
let l = s.execute("layer.newSolid", json!({"comp": c, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
(effectcraft_project::ItemId(c), (c, l))
};
let (main, ml) = comp(&mut s, "Main");
let (_, ol) = comp(&mut s, "Other");
let (third, tl) = comp(&mut s, "Third");
let unused = s.edit("add", None, |p, _| {
let f = effectcraft_project::Footage { path: "/nowhere/a.png".into(), has_video: true, ..Default::default() };
Ok(p.add_item("a.png", effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f)))
});
let unused = unused.unwrap();
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, main);
let expr = |s: &mut Session, (comp, layer): (u64, u64), text: &str| {
s.execute("prop.setExpression", json!({"comp": comp, "layer": layer, "path": "transform/opacity", "expression": text})).unwrap();
};
let opacity = |s: &mut Session, (comp, layer): (u64, u64), v: f64| {
s.execute("prop.set", json!({"comp": comp, "layer": layer, "path": "transform/opacity", "value": v})).unwrap();
};
let repath = |s: &mut Session, path: &str| {
let path = path.to_string();
s.edit("repath", None, move |p, _| {
if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(unused).map(|i| &mut i.kind) {
f.path = path;
}
Ok(())
})
.unwrap();
};
// Its own comp only.
expr(&mut s, ml, "thisComp.layer(1).transform.rotation + wiggle(1, 1)[0]");
expr(&mut s, ol, "wiggle(2, 10)");
let k0 = key(&s);
opacity(&mut s, ol, 40.0);
expr(&mut s, tl, "time * 10");
repath(&mut s, "/nowhere/b.png");
s.execute("comp.addMarker", json!({"comp": third.0, "time": 0.5})).unwrap();
assert_eq!(key(&s), k0, "edits elsewhere keep the key");
// An edit in the comp itself changes it.
opacity(&mut s, ml, 30.0);
assert_ne!(key(&s), k0);
// `comp("Other")`: Other counts, Third doesn't.
expr(&mut s, ml, "comp(\"Other\").layer(1).transform.opacity");
let k1 = key(&s);
expr(&mut s, ol, "wiggle(3, 10)");
let k2 = key(&s);
assert_ne!(k2, k1, "the comp it names");
opacity(&mut s, tl, 20.0);
repath(&mut s, "/nowhere/c.png");
assert_eq!(key(&s), k2, "a comp it doesn't name");
// Another comp taking the name changes what it may read.
s.edit("rename", None, |p, _| {
p.item_mut(third).unwrap().name = "Other".into();
Ok(())
})
.unwrap();
let k3 = key(&s);
assert_ne!(k3, k2, "a second comp named Other");
// A computed name reaches every item.
expr(&mut s, ml, "comp(\"Oth\" + \"er\").layer(1).transform.opacity");
let k4 = key(&s);
repath(&mut s, "/nowhere/d.png");
assert_ne!(key(&s), k4, "unused footage counts with a computed name");
}
/// Markers count only for the comps whose expressions can read them (#1083): an expression in
/// another comp that reads markers leaves this comp's markers out of its key.
#[test]
fn markers_count_only_where_an_expression_can_read_them() {
let mut s = Session::default();
s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
let cid = s.active_comp_id().unwrap();
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
let other = s.execute("comp.new", json!({"name": "N", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
let ol = s.execute("layer.newSolid", json!({"comp": other, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.setExpression", json!({"comp": other, "layer": ol, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
let k0 = key(&s);
s.execute("comp.addMarker", json!({"comp": cid.0, "time": 0.5, "comment": "beat"})).unwrap();
assert_eq!(key(&s), k0, "no expression of M reads its markers");
s.execute("prop.setExpression", json!({"comp": other, "layer": ol, "path": "transform/opacity", "expression": "comp(\"M\").marker.numKeys"})).unwrap();
let other_key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, effectcraft_project::ItemId(other));
let n0 = other_key(&s);
s.execute("comp.addMarker", json!({"comp": cid.0, "time": 1.0})).unwrap();
assert_ne!(other_key(&s), n0, "N reads M's markers");
assert_eq!(key(&s), k0, "M itself still doesn't");
}
/// File ▸ Reload Footage drops the disk entries made of the item's files (#3184): a file
/// replaced by one with the same size and modification time is read again (the check on hit
/// can't tell), and entries of other files stay.
#[test]
fn reload_footage_drops_the_entries_of_its_files() {
use crate::render::reads::{FileStamp, ReadFile, ReadFiles};
struct Probe;
impl crate::Importer for Probe {
fn probe(&self, path: &str) -> std::result::Result<effectcraft_project::Footage, String> {
Ok(effectcraft_project::Footage {
path: path.into(),
kind: effectcraft_project::FootageKind::Still,
width: 1,
height: 1,
has_video: true,
..Default::default()
})
}
}
let dir = folder("reload");
let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
s.execute_checked("prefs.set", json!({"values": {"disk.diskCacheFolder": &dir, "disk.diskCacheEnabled": true}})).unwrap();
let src = std::path::Path::new(&dir).join("src");
std::fs::create_dir_all(&src).unwrap();
let mut add = |name: &str| {
let p = src.join(name);
std::fs::write(&p, b"aa").unwrap();
let path = p.to_string_lossy().to_string();
let f = effectcraft_project::Footage {
path: path.clone(),
kind: effectcraft_project::FootageKind::Still,
width: 1,
height: 1,
has_video: true,
..Default::default()
};
let id = s.edit("add", None, |p, _| Ok(p.add_item(name, effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f)))).unwrap();
(id, path)
};
let (a, a_path) = add("a.png");
let (_, b_path) = add("b.png");
let dc = s.disk_cache.clone().unwrap();
let read = |p: &str| -> ReadFiles { [ReadFile::new(p, FileStamp::native(p).unwrap())].into_iter().collect() };
dc.put_frame_now(1, 1, 1, &[1; 4], &read(&a_path));
dc.put_frame_now(2, 1, 1, &[2; 4], &read(&b_path));
dc.put_layer_now(3, &effectcraft_effects::Buf { img: effectcraft_raster::Image::new(1, 1), offset: [0.0; 2], scale: 1.0 }, &read(&a_path));
// Other bytes, same size, the old time back.
let t = std::fs::metadata(&a_path).unwrap().modified().unwrap();
std::fs::write(&a_path, b"AA").unwrap();
std::fs::File::options().append(true).open(&a_path).unwrap().set_modified(t).unwrap();
assert!(dc.contains(crate::render::disk_cache::Kind::Frame, 1));
s.execute_checked("file.reloadFootage", json!({"item": a.0})).unwrap();
dc.flush();
assert!(dc.get_frame(1, None).is_none(), "the reloaded file's frame renders again");
assert!(dc.get_layer(3, None).is_none(), "and its layer buffer");
assert!(dc.get_frame(2, None).is_some(), "another file's frame stays");
let _ = std::fs::remove_dir_all(&dir);
}
/// Reload Footage while the disk cache is off (#3184): when it is switched on later in the
/// session, the entries made of the reloaded files are dropped before anything is read from it
/// (a file replaced by one with the same size and time would pass the check on hit); entries of
/// other files stay.
#[test]
fn reload_footage_while_the_disk_cache_is_off_drops_its_entries_when_it_is_on() {
use crate::render::disk_cache::{DiskCache, Kind};
use crate::render::reads::{FileStamp, ReadFile, ReadFiles};
struct Probe;
impl crate::Importer for Probe {
fn probe(&self, path: &str) -> std::result::Result<effectcraft_project::Footage, String> {
Ok(effectcraft_project::Footage {
path: path.into(),
kind: effectcraft_project::FootageKind::Still,
width: 1,
height: 1,
has_video: true,
..Default::default()
})
}
}
let dir = folder("reload-off");
let src = std::path::Path::new(&dir).join("src");
std::fs::create_dir_all(&src).unwrap();
let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
let mut add = |name: &str| {
let p = src.join(name);
std::fs::write(&p, b"aa").unwrap();
let path = p.to_string_lossy().to_string();
let f = effectcraft_project::Footage {
path: path.clone(),
kind: effectcraft_project::FootageKind::Still,
width: 1,
height: 1,
has_video: true,
..Default::default()
};
let id = s.edit("add", None, |p, _| Ok(p.add_item(name, effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f)))).unwrap();
(id, path)
};
let (a, a_path) = add("a.png");
let (_, b_path) = add("b.png");
// Entries from an earlier session in the cache folder.
let read = |p: &str| -> ReadFiles { [ReadFile::new(p, FileStamp::native(p).unwrap())].into_iter().collect() };
{
let dc = DiskCache::open(&dir, 1 << 30).unwrap();
dc.put_frame_now(1, 1, 1, &[1; 4], &read(&a_path));
dc.put_frame_now(2, 1, 1, &[2; 4], &read(&b_path));
dc.put_layer_now(3, &effectcraft_effects::Buf { img: effectcraft_raster::Image::new(1, 1), offset: [0.0; 2], scale: 1.0 }, &read(&a_path));
}
// Other bytes, same size, the old time back; reloaded while the cache is off.
let t = std::fs::metadata(&a_path).unwrap().modified().unwrap();
std::fs::write(&a_path, b"AA").unwrap();
std::fs::File::options().append(true).open(&a_path).unwrap().set_modified(t).unwrap();
assert!(s.disk_cache.is_none());
s.execute_checked("file.reloadFootage", json!({"item": a.0})).unwrap();
// Switched on: the reloaded file's entries are misses from the start, and then gone.
s.execute_checked("prefs.set", json!({"values": {"disk.diskCacheFolder": &dir, "disk.diskCacheEnabled": true}})).unwrap();
let dc = s.disk_cache.clone().unwrap();
assert!(dc.get_frame(1, None).is_none(), "the reloaded file's frame renders again");
assert!(dc.get_layer(3, None).is_none(), "and its layer buffer");
dc.flush();
assert!(!dc.contains(Kind::Frame, 1) && !dc.contains(Kind::Layer, 3));
assert!(dc.get_frame(2, None).is_some(), "another file's frame stays");
assert!(s.pending_disk_drops.is_empty(), "applied once");
drop(dc);
drop(s);
let _ = std::fs::remove_dir_all(&dir);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.