f67d38b35cc5
autosave.rs
//! Auto-save ring + crash-recovery journal, and the preferences that drive them.
//!
//! **Auto Save** (Premiere behaviour, Preferences ▸ Auto Save): every *interval* minutes, if the
//! project changed since the last auto-save, a copy is written to the `Auto-Save` folder next to the
//! project as `<name>-YYYY-MM-DD_HH-MM-SS.fcproj`, keeping at most *Maximum Project Versions* files.
//! Optionally the project file itself is saved too.
//!
//! **Recovery journal** (FilmCraft addition): while the project has unsaved changes, a snapshot is
//! written to `<data dir>/Recovery/<session>/snapshot.fcproj` shortly after each change (debounced,
//! and at least every *N* seconds while edits keep coming). Each running app holds an OS lock on
//! `<session>/lock`; when the process dies (crash, `kill -9`, power cut) the lock is released, so on
//! the next launch any session directory whose lock can be taken and that holds a snapshot is a
//! recovery candidate ("Recover unsaved changes from <time>?").
//!
//! **Threading.** The UI thread only hands the worker an `Arc<Project>` (the immutable snapshot the
//! engine already keeps for undo) — a pointer copy and a channel send. Serialization and all file
//! I/O happen on the worker thread, so neither ever stalls the UI.
use std::fs::{self, File};
use std::io;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{Receiver, RecvTimeoutError, Sender, channel};
use std::thread::JoinHandle;
use std::time::Duration;
use filmcraft_format::autosave as names;
use filmcraft_project::Project;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use web_time::{Instant, SystemTime, UNIX_EPOCH};
use crate::settings;
// ------------------------------------------------------------------ preferences
/// Preferences ▸ Auto Save.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct AutoSavePrefs {
/// "Automatically save projects".
pub enabled: bool,
/// "Automatically Save Every: N minute(s)".
pub interval_minutes: u32,
/// "Maximum Project Versions".
pub max_versions: u32,
/// "Auto Save also saves the current project(s)".
pub save_current_project: bool,
/// Keep a crash-recovery journal of unsaved changes.
pub recovery_journal: bool,
/// Longest time (s) unsaved changes may stay out of the journal while edits keep coming.
pub recovery_interval_seconds: u32,
/// Folders chosen in Project Settings ▸ Scratch Disks on this computer. A project file may
/// name these, or folders inside its own folder; see
/// [`crate::project_tools::trusted_scratch`].
pub scratch_folders: Vec<String>,
}
impl Default for AutoSavePrefs {
fn default() -> Self {
Self {
enabled: true,
interval_minutes: 5,
max_versions: 20,
save_current_project: false,
recovery_journal: true,
recovery_interval_seconds: 5,
scratch_folders: Vec::new(),
}
}
}
impl AutoSavePrefs {
fn clamp(&mut self) {
self.interval_minutes = self.interval_minutes.clamp(1, 1440);
self.max_versions = self.max_versions.clamp(1, 1000);
self.recovery_interval_seconds = self.recovery_interval_seconds.clamp(1, 600);
}
}
/// Settings ▸ Playback.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct PlaybackPrefs {
/// "Preroll: N seconds" (Play Around, trim-mode loop playback).
pub preroll_seconds: f64,
/// "Postroll: N seconds".
pub postroll_seconds: f64,
/// "Step forward/back many: N frames" (Shift+Right / Shift+Left).
pub step_many_frames: u32,
pub pause_encoder_queue: bool,
pub enable_transmit: bool,
pub disable_video_in_background: bool,
/// Draft decoding while playing at 1/2 resolution or lower: H.264 non-reference pictures
/// skip deblocking (faster; those frames are approximate). Never used for exports, renders or
/// a paused frame. Off by default.
pub draft_decode: bool,
/// "Hardware decoding": `auto` (default: the system's hardware decoder for streams it
/// supports, e.g. VideoToolbox H.264 / HEVC on macOS, falling back to FilmCraft's own decoder)
/// or `off` (always FilmCraft's own decoders). Media already open keeps its decoder until it
/// is reopened.
pub hardware_decoding: String,
}
impl Default for PlaybackPrefs {
fn default() -> Self {
Self {
preroll_seconds: 3.0,
postroll_seconds: 2.0,
step_many_frames: 5,
pause_encoder_queue: true,
enable_transmit: false,
disable_video_in_background: true,
draft_decode: false,
hardware_decoding: "auto".into(),
}
}
}
/// Settings ▸ Trim.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct TrimPrefs {
/// "Large Trim Offset: N frames" (Trim Forward/Backward Many, the Trim Monitor's ±N buttons).
pub large_trim_offset: u32,
/// The audio Large Trim Offset (audio time units).
pub large_trim_offset_audio: u32,
/// "Allow Selection tool to choose Roll and Ripple trims without modifier key".
pub selection_tool_roll_ripple: bool,
pub tool_changes_trim_type: bool,
pub shift_overlapping_clips: bool,
pub ripple_adds_edits: bool,
/// "Playhead position determines trim monitor loop playback" (else the edit point does).
pub playhead_determines_loop: bool,
pub dynamic_ripple_updates: bool,
}
impl Default for TrimPrefs {
fn default() -> Self {
Self {
large_trim_offset: 5,
large_trim_offset_audio: 100,
selection_tool_roll_ripple: false,
tool_changes_trim_type: true,
shift_overlapping_clips: false,
ripple_adds_edits: false,
playhead_determines_loop: false,
dynamic_ripple_updates: true,
}
}
}
/// User preferences (persisted as JSON in the per-user data directory). Keys are dotted camelCase
/// paths: `autoSave.enabled`, `autoSave.intervalMinutes`, `playback.prerollSeconds`, …
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct Preferences {
/// File layout version ([`crate::settings::PREFS_VERSION`]); older files are migrated on load.
pub version: u32,
pub general: settings::GeneralPrefs,
pub appearance: settings::AppearancePrefs,
pub audio: AudioPrefs,
pub audio_hardware: settings::AudioHardwarePrefs,
pub auto_save: AutoSavePrefs,
pub color: settings::ColorPrefs,
pub graphics: settings::GraphicsPrefs,
pub labels: settings::LabelPrefs,
pub media: MediaPrefs,
pub media_analysis: settings::MediaAnalysisPrefs,
pub media_cache: settings::MediaCachePrefs,
pub memory: settings::MemoryPrefs,
pub playback: PlaybackPrefs,
pub plugins: settings::PluginPrefs,
pub timeline: settings::TimelinePrefs,
pub trim: TrimPrefs,
pub essential_sound: EssentialSoundPrefs,
pub guides: GuidePrefs,
/// Voice-Over Record Settings (timeline track header ▸ right-click the microphone).
pub voice_over: crate::voiceover::VoiceOverPrefs,
/// Project panel: view, List view columns and sort, view presets, Freeform options.
pub project_panel: crate::project_panel::ProjectPanelPrefs,
/// Media Browser: Favorites, recent directories, file types, view, columns.
pub media_browser: crate::media_browser::MediaBrowserPrefs,
}
impl Default for Preferences {
fn default() -> Self {
Self {
version: settings::PREFS_VERSION,
general: Default::default(),
appearance: Default::default(),
audio: Default::default(),
audio_hardware: Default::default(),
auto_save: Default::default(),
color: Default::default(),
graphics: Default::default(),
labels: Default::default(),
media: Default::default(),
media_analysis: Default::default(),
media_cache: Default::default(),
memory: Default::default(),
playback: Default::default(),
plugins: Default::default(),
timeline: Default::default(),
trim: Default::default(),
essential_sound: Default::default(),
guides: Default::default(),
voice_over: Default::default(),
project_panel: Default::default(),
media_browser: Default::default(),
}
}
}
/// View ▸ Guide Templates: guide sets saved from the Program Monitor.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct GuidePrefs {
pub templates: Vec<GuideTemplate>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct GuideTemplate {
pub name: String,
pub guides: Vec<Guide>,
}
/// A monitor guide: a vertical line at x = `position` or a horizontal line at y = `position`
/// (frame pixels).
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct Guide {
pub vertical: bool,
pub position: f64,
}
/// Settings ▸ Media.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct MediaPrefs {
/// "Indeterminate Media Timebase": the frame rate of stills (`29.97df`, `25`, …).
pub indeterminate_timebase: String,
/// "Timecode": `useMediaSource` | `generate`.
pub timecode: String,
/// "Frame Count": `startAt0` | `startAt1` | `timecodeConversion`.
pub frame_count: String,
/// "Default Media Scaling": `none` | `scaleToFrameSize` | `setToFrameSize`.
pub default_media_scaling: String,
pub write_xmp_id: bool,
pub validate_content_credentials: bool,
pub write_clip_markers_to_xmp: bool,
pub enable_xmp_linking: bool,
pub include_captions_on_import: bool,
/// "Enable proxies": playback and monitors read attached proxies (the monitors' Toggle
/// Proxies button). Export always uses full-resolution media.
pub enable_proxies: bool,
pub allow_duplicate_media: bool,
pub create_folder_for_imported_projects: bool,
pub auto_hide_dependent_clips: bool,
pub import_image_sequences: bool,
pub refresh_growing_files: bool,
pub resume_growing_playback: bool,
pub growing_refresh_seconds: u32,
pub hardware_decoding: bool,
pub prores_hardware_encoding: bool,
}
impl Default for MediaPrefs {
fn default() -> Self {
Self {
indeterminate_timebase: "29.97df".into(),
timecode: "useMediaSource".into(),
frame_count: "startAt0".into(),
default_media_scaling: "none".into(),
write_xmp_id: false,
validate_content_credentials: true,
write_clip_markers_to_xmp: false,
enable_xmp_linking: false,
include_captions_on_import: true,
enable_proxies: false,
allow_duplicate_media: false,
create_folder_for_imported_projects: false,
auto_hide_dependent_clips: false,
import_image_sequences: false,
refresh_growing_files: true,
resume_growing_playback: false,
growing_refresh_seconds: 60,
hardware_decoding: true,
prores_hardware_encoding: true,
}
}
}
/// Essential Sound: user presets saved from the panel (built-in presets live in
/// `filmcraft_project::essential`).
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct EssentialSoundPrefs {
pub user_presets: Vec<UserSoundPreset>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UserSoundPreset {
pub name: String,
pub settings: filmcraft_project::EssentialSound,
}
/// Preferences ▸ Audio (the mixer-automation part) and the Track Mixer panel-menu toggle.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct AudioPrefs {
/// "Automatch Time" (s): how long Touch takes to return to the existing automation.
pub automatch_time: f64,
/// "Large Volume Adjustment" (dB) for the Increase/Decrease Clip Volume Many commands.
pub large_volume_adjustment: f64,
/// Automation Keyframe Optimization: "Linear keyframe thinning".
pub linear_keyframe_thinning: bool,
/// "Minimum time interval thinning".
pub minimum_time_interval_thinning: bool,
/// "Minimum time" (ms).
pub minimum_time_ms: u32,
/// Track Mixer ▸ "Switch to Touch after Write".
pub switch_to_touch_after_write: bool,
/// "5.1 Mixdown Type": `front` | `frontRear` | `frontLfe` | `frontRearLfe`.
pub mixdown_type: String,
pub sum_to_mono_in_source: bool,
pub scrub_audio: bool,
pub maintain_pitch_shuttling: bool,
pub mute_input_during_recording: bool,
pub generate_waveforms_on_import: bool,
pub multithreaded_waveforms: bool,
pub render_audio_with_video: bool,
pub auto_tag_audio_types: bool,
pub always_override_audio_tags: bool,
/// "Render Edit in Audition files to": `scratch` | `nextToMedia`.
pub edit_in_audition_location: String,
/// Essential Sound Loudness Auto-Match targets (integrated LUFS) per audio type.
pub dialogue_target_lufs: f64,
pub music_target_lufs: f64,
pub sfx_target_lufs: f64,
pub ambience_target_lufs: f64,
}
impl Default for AudioPrefs {
fn default() -> Self {
Self {
automatch_time: 1.0,
large_volume_adjustment: 6.0,
linear_keyframe_thinning: true,
minimum_time_interval_thinning: false,
minimum_time_ms: 20,
switch_to_touch_after_write: true,
mixdown_type: "frontRear".into(),
sum_to_mono_in_source: true,
scrub_audio: true,
maintain_pitch_shuttling: true,
mute_input_during_recording: false,
generate_waveforms_on_import: true,
multithreaded_waveforms: false,
render_audio_with_video: false,
auto_tag_audio_types: true,
always_override_audio_tags: false,
edit_in_audition_location: "nextToMedia".into(),
dialogue_target_lufs: -23.0,
music_target_lufs: -25.0,
sfx_target_lufs: -21.0,
ambience_target_lufs: -30.0,
}
}
}
impl AudioPrefs {
/// Auto-Match target for an audio type.
pub fn loudness_target(&self, t: filmcraft_project::AudioType) -> f64 {
match t {
filmcraft_project::AudioType::Dialogue => self.dialogue_target_lufs,
filmcraft_project::AudioType::Music => self.music_target_lufs,
filmcraft_project::AudioType::Sfx => self.sfx_target_lufs,
filmcraft_project::AudioType::Ambience => self.ambience_target_lufs,
}
}
fn clamp(&mut self) {
self.automatch_time = if self.automatch_time.is_finite() { self.automatch_time.clamp(0.0, 30.0) } else { 1.0 };
self.large_volume_adjustment = if self.large_volume_adjustment.is_finite() { self.large_volume_adjustment.clamp(0.0, 96.0) } else { 6.0 };
self.minimum_time_ms = self.minimum_time_ms.clamp(1, 10_000);
for (v, d) in [
(&mut self.dialogue_target_lufs, -23.0),
(&mut self.music_target_lufs, -25.0),
(&mut self.sfx_target_lufs, -21.0),
(&mut self.ambience_target_lufs, -30.0),
] {
*v = if v.is_finite() { v.clamp(-60.0, 0.0) } else { d };
}
}
}
impl Preferences {
fn clamp(&mut self) {
self.auto_save.clamp();
self.audio.clamp();
let secs = |v: f64| if v.is_finite() { v.clamp(0.0, 60.0) } else { 0.0 };
self.playback.preroll_seconds = secs(self.playback.preroll_seconds);
self.playback.postroll_seconds = secs(self.playback.postroll_seconds);
self.trim.large_trim_offset = self.trim.large_trim_offset.clamp(1, 1000);
self.labels.sanitize_labels();
self.appearance.sync_color_theme();
self.version = settings::PREFS_VERSION;
}
/// Parse a preferences document: migrate older layouts, repair values against the schema.
pub fn from_value(mut v: Value) -> Self {
settings::migrate(&mut v);
settings::sanitize(&mut v, &Self::default().to_value());
let mut p: Preferences = serde_json::from_value(v).unwrap_or_default();
p.clamp();
p
}
pub fn to_value(&self) -> Value {
serde_json::to_value(self).unwrap_or_default()
}
/// All leaf keys (`autoSave.enabled`, …).
pub fn keys(&self) -> Vec<String> {
fn walk(prefix: &str, v: &Value, out: &mut Vec<String>) {
match v {
Value::Object(m) => {
for (k, c) in m {
walk(&if prefix.is_empty() { k.clone() } else { format!("{prefix}.{k}") }, c, out);
}
}
_ => out.push(prefix.to_string()),
}
}
let mut out = Vec::new();
walk("", &self.to_value(), &mut out);
out
}
pub fn get(&self, key: &str) -> Option<Value> {
let v = self.to_value();
key.split('.').try_fold(&v, |v, k| v.get(k)).cloned()
}
/// Set one key (type-checked against the schema, values clamped to their ranges).
pub fn set(&mut self, key: &str, value: Value) -> Result<(), String> {
let mut v = self.to_value();
let mut slot = &mut v;
for k in key.split('.') {
slot = slot.get_mut(k).ok_or_else(|| format!("unknown preference `{key}`"))?;
}
if slot.is_object() {
return Err(format!("`{key}` is a group; set one of its keys"));
}
settings::validate(key, &value)?;
let value = match (&*slot, value) {
// Numeric choices (buffer size, sample rate) arrive as strings from the dialog.
(Value::Number(_), Value::String(t)) if t.parse::<u64>().is_ok() => Value::from(t.parse::<u64>().unwrap_or_default()),
// Accept 5.0 for integer prefs (agents often send floats).
(Value::Number(n), Value::Number(m)) if n.is_u64() && !m.is_u64() => {
Value::from(m.as_f64().filter(|f| f.is_finite() && *f >= 0.0).ok_or_else(|| format!("`{key}` must be a non-negative number"))?.round() as u64)
}
(_, v) => v,
};
*slot = value;
let _: Preferences = serde_json::from_value(v.clone()).map_err(|e| format!("`{key}`: {e}"))?;
settings::sanitize(&mut v, &Self::default().to_value());
let mut p: Preferences = serde_json::from_value(v).map_err(|e| format!("`{key}`: {e}"))?;
// Old clients that set the single Color Theme still pick the theme they name (before
// `clamp`, which brings `colorTheme` back in line with the mode and theme choices).
if key == "appearance.colorTheme" {
let theme = p.appearance.color_theme.clone();
p.appearance.select_theme(&theme);
}
p.clamp();
*self = p;
Ok(())
}
pub fn load(path: &Path) -> Self {
fs::read(path).ok().and_then(|b| serde_json::from_slice::<Value>(&b).ok()).map(Self::from_value).unwrap_or_default()
}
pub fn save(&self, path: &Path) -> io::Result<()> {
if let Some(d) = path.parent() {
fs::create_dir_all(d)?;
}
filmcraft_format::atomic_write(path, &serde_json::to_vec_pretty(self).unwrap_or_default())
}
}
/// A file with this name next to the executable makes the install portable: its data directory is
/// `<exe dir>/data` instead of the per-user one (the Windows portable zip ships it).
pub const PORTABLE_MARKER: &str = "portable.txt";
/// `<exe_dir>/data` when `exe_dir` holds [`PORTABLE_MARKER`], else `None`.
pub fn portable_data_dir(exe_dir: &Path) -> Option<PathBuf> {
exe_dir.join(PORTABLE_MARKER).is_file().then(|| exe_dir.join("data"))
}
/// The data directory. `FILMCRAFT_DATA_DIR` overrides; a portable install ([`PORTABLE_MARKER`] next
/// to the executable) uses `<exe dir>/data`; otherwise the per-user directory:
/// macOS `~/Library/Application Support/FilmCraft`, Windows `%APPDATA%\FilmCraft`,
/// elsewhere `$XDG_DATA_HOME/filmcraft` or `~/.local/share/filmcraft`.
pub fn default_data_dir() -> Option<PathBuf> {
let env = |k: &str| std::env::var_os(k).filter(|v| !v.is_empty()).map(PathBuf::from);
if let Some(d) = env("FILMCRAFT_DATA_DIR") {
return Some(d);
}
if let Some(d) = std::env::current_exe().ok().and_then(|exe| exe.parent().and_then(portable_data_dir)) {
return Some(d);
}
if cfg!(target_os = "macos") {
return env("HOME").map(|h| h.join("Library/Application Support/FilmCraft"));
}
if cfg!(windows) {
return env("APPDATA").map(|h| h.join("FilmCraft"));
}
env("XDG_DATA_HOME").map(|d| d.join("filmcraft")).or_else(|| env("HOME").map(|h| h.join(".local/share/filmcraft")))
}
pub fn unix_now() -> i64 {
SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_secs() as i64).unwrap_or(0)
}
// ------------------------------------------------------------------ recovery candidates
/// Snapshot meta written next to `snapshot.fcproj`.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct JournalMeta {
pub pid: u32,
pub started_unix: i64,
pub saved_unix: i64,
pub revision: u64,
pub project_name: String,
pub project_path: Option<String>,
pub generator: String,
pub bytes: usize,
/// True when the app was closed normally while changes were unsaved (no crash).
pub clean_exit: bool,
}
/// Unsaved changes left behind by a session that is no longer running.
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RecoveryCandidate {
/// Session directory name (pass to `file.recover {id}`).
pub id: String,
#[serde(skip)]
pub dir: PathBuf,
#[serde(flatten)]
pub meta: JournalMeta,
}
const SNAPSHOT: &str = "snapshot.fcproj";
const META: &str = "session.json";
const LOCK: &str = "lock";
pub fn recovery_root(data_dir: &Path) -> PathBuf {
data_dir.join("Recovery")
}
/// Is the session directory's lock free (owner gone)?
fn lock_is_stale(dir: &Path) -> bool {
let Ok(f) = File::options().read(true).write(true).open(dir.join(LOCK)) else { return true };
match f.try_lock() {
Ok(()) => true,
Err(fs::TryLockError::WouldBlock) => false,
// Locking unsupported on this file system: fall back to the meta's pid being gone is not
// knowable portably, so treat as stale (the snapshot is offered, never deleted silently).
Err(fs::TryLockError::Error(_)) => true,
}
}
/// Find snapshots of sessions that are no longer running. Stale session directories without a
/// snapshot (nothing unsaved) are removed. `skip` is the caller's own session directory.
pub fn scan_candidates(data_dir: &Path, skip: Option<&Path>) -> Vec<RecoveryCandidate> {
let Ok(rd) = fs::read_dir(recovery_root(data_dir)) else { return Vec::new() };
let mut out = Vec::new();
for e in rd.filter_map(|e| e.ok()) {
let dir = e.path();
if !dir.is_dir() || Some(dir.as_path()) == skip || !lock_is_stale(&dir) {
continue;
}
let snap = dir.join(SNAPSHOT);
if !snap.is_file() {
// Empty leftover dirs (clean exit, or a crash before the first snapshot).
let _ = fs::remove_dir_all(&dir);
continue;
}
// Keep the snapshot even when session.json is missing or unreadable: the project
// is still recoverable. Meta fields fall back to defaults.
let meta = fs::read(dir.join(META)).ok().and_then(|b| serde_json::from_slice::<JournalMeta>(&b).ok()).unwrap_or_default();
out.push(RecoveryCandidate { id: e.file_name().to_string_lossy().into_owned(), dir, meta });
}
out.sort_by(|a, b| b.meta.saved_unix.cmp(&a.meta.saved_unix).then(b.id.cmp(&a.id)));
out
}
/// Load a candidate's snapshot.
pub fn load_candidate(c: &RecoveryCandidate) -> Result<filmcraft_format::Loaded, String> {
let b = filmcraft_media::reader::read_regular_file_bounded(&c.dir.join(SNAPSHOT), filmcraft_format::MAX_PROJECT_BYTES)
.map_err(|e| format!("{}: {e}", c.dir.display()))?;
filmcraft_format::decode(&b).map_err(|e| e.to_string())
}
pub fn discard_candidate(c: &RecoveryCandidate) -> io::Result<()> {
fs::remove_dir_all(&c.dir)
}
// ------------------------------------------------------------------ worker
/// Host configuration for [`Persistence::start`].
#[derive(Clone)]
pub struct AutosaveConfig {
pub data_dir: PathBuf,
/// Local UTC offset (seconds) at a unix time — used for auto-save file names and display.
pub local_offset: fn(i64) -> i32,
/// Quiet period after a change before the journal is written.
pub journal_debounce: Duration,
}
impl AutosaveConfig {
pub fn new(data_dir: impl Into<PathBuf>) -> Self {
Self { data_dir: data_dir.into(), local_offset: |_| 0, journal_debounce: Duration::from_millis(1000) }
}
}
/// What the session last told the worker.
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct Sent {
pub revision: u64,
pub saved_revision: u64,
pub path: Option<String>,
}
struct Snapshot {
project: Arc<Project>,
revision: u64,
path: Option<String>,
}
enum Msg {
/// The project has unsaved changes at this revision.
Dirty(Snapshot),
/// Nothing unsaved (just saved / opened): drop the journal.
Clean,
Prefs(AutoSavePrefs),
AutoSaveNow(Sender<Result<PathBuf, String>>),
Flush(Sender<Result<Option<u64>, String>>),
Stop,
}
/// Worker → session notifications.
#[derive(Clone, Debug)]
pub enum WorkerEvent {
Journaled {
revision: u64,
unix: i64,
serialize_ms: f64,
write_ms: f64,
bytes: usize,
},
AutoSaved {
path: PathBuf,
revision: u64,
unix: i64,
serialize_ms: f64,
write_ms: f64,
bytes: usize,
},
/// "Auto Save also saves the current project" wrote the project file at this revision.
SavedProject {
path: String,
revision: u64,
},
Error(String),
}
const WORKER_STOPPED: &str =
"Auto-save worker stopped; automatic saving and recovery journaling are unavailable. Use File > Save or Save As to save your changes.";
/// Shared by the thread boundary and callers: a stopped worker is one failure, even when
/// several queued requests or subsequent edits discover the disconnected channel.
struct WorkerFailure {
reported: AtomicBool,
events: Sender<WorkerEvent>,
}
impl WorkerFailure {
fn report(&self) {
if !self.reported.swap(true, Ordering::AcqRel) {
log::error!("{WORKER_STOPPED}");
let _ = self.events.send(WorkerEvent::Error(WORKER_STOPPED.into()));
}
}
}
/// Last activity, for `file.autoSaveStatus` and the UI.
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Status {
pub last_auto_save: Option<String>,
pub last_auto_save_unix: Option<i64>,
pub auto_saves_written: u64,
pub last_journal_unix: Option<i64>,
pub journaled_revision: u64,
pub journals_written: u64,
/// Worker-side cost of the last write (serialize = JSON encode of the snapshot).
pub last_serialize_ms: f64,
pub last_write_ms: f64,
pub last_bytes: usize,
pub last_error: Option<String>,
}
/// The running auto-save/recovery machinery of one session.
pub struct Persistence {
pub data_dir: PathBuf,
pub session_dir: PathBuf,
pub local_offset: fn(i64) -> i32,
pub candidates: Vec<RecoveryCandidate>,
pub status: Status,
pub(crate) last_sent: Option<Sent>,
lock: Option<File>,
tx: Sender<Msg>,
events: Receiver<WorkerEvent>,
thread: Option<JoinHandle<()>>,
failure: Arc<WorkerFailure>,
}
impl Persistence {
/// Create this session's journal directory (holding its lock), find recovery candidates left by
/// dead sessions, and start the worker thread.
pub fn start(cfg: &AutosaveConfig, prefs: AutoSavePrefs) -> io::Result<Self> {
let root = recovery_root(&cfg.data_dir);
fs::create_dir_all(&root)?;
let started = unix_now();
let pid = std::process::id();
// Unique even for several sessions in one process within a second (tests, future multi-window).
static SEQ: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
let seq = SEQ.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let session_dir = root.join(if seq == 0 { format!("{started}-{pid}") } else { format!("{started}-{pid}-{seq}") });
fs::create_dir_all(&session_dir)?;
let lock = File::options().create(true).truncate(false).read(true).write(true).open(session_dir.join(LOCK))?;
// Unsupported locking only weakens stale detection; it must not stop the app.
let _ = lock.try_lock();
let candidates = scan_candidates(&cfg.data_dir, Some(&session_dir));
let (tx, rx) = channel();
let (etx, events) = channel();
let failure = Arc::new(WorkerFailure { reported: AtomicBool::new(false), events: etx.clone() });
let mut w = Worker {
data_dir: cfg.data_dir.clone(),
session_dir: session_dir.clone(),
local_offset: cfg.local_offset,
debounce: cfg.journal_debounce,
prefs,
events: etx,
latest: None,
journaled: 0,
autosaved: 0,
first_pending: None,
last_change: Instant::now(),
next_autosave: Instant::now(),
meta: JournalMeta { pid, started_unix: started, generator: filmcraft_format::generator(), ..Default::default() },
};
w.next_autosave = Instant::now() + w.autosave_interval();
let worker_failure = failure.clone();
let thread = std::thread::Builder::new().name("filmcraft-autosave".into()).spawn(move || {
if std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| w.run(rx))).is_err() {
worker_failure.report();
}
})?;
Ok(Self {
data_dir: cfg.data_dir.clone(),
session_dir,
local_offset: cfg.local_offset,
candidates,
status: Status::default(),
last_sent: None,
lock: Some(lock),
tx,
events,
thread: Some(thread),
failure,
})
}
pub(crate) fn send_dirty(&self, project: Arc<Project>, revision: u64, path: Option<String>) {
self.send(Msg::Dirty(Snapshot { project, revision, path }));
}
pub(crate) fn send_clean(&self) {
self.send(Msg::Clean);
}
pub fn set_prefs(&self, p: AutoSavePrefs) {
self.send(Msg::Prefs(p));
}
fn send(&self, msg: Msg) {
if self.tx.send(msg).is_err() {
self.failure.report();
}
}
fn stopped_error(&self) -> String {
self.failure.report();
WORKER_STOPPED.into()
}
pub(crate) fn is_running(&self) -> bool {
!self.failure.reported.load(Ordering::Acquire) && self.thread.as_ref().is_some_and(|t| !t.is_finished())
}
/// Write any pending journal now and return its confirmed revision (`None` when clean).
/// Disabled journaling, failed writes and a stopped/unresponsive worker are errors.
pub fn flush(&self) -> Result<Option<u64>, String> {
let (tx, rx) = channel();
self.tx.send(Msg::Flush(tx)).map_err(|_| self.stopped_error())?;
rx.recv_timeout(Duration::from_secs(30)).map_err(|e| match e {
RecvTimeoutError::Timeout => "recovery journal flush timed out".to_string(),
RecvTimeoutError::Disconnected => {
self.failure.report();
"auto-save worker stopped before confirming the recovery journal".to_string()
}
})?
}
/// Write an auto-save now (if there are unsaved changes) and wait for the result.
pub fn auto_save_now(&self) -> Result<Option<PathBuf>, String> {
let (tx, rx) = channel();
self.tx.send(Msg::AutoSaveNow(tx)).map_err(|_| self.stopped_error())?;
match rx.recv_timeout(Duration::from_secs(60)) {
Ok(Ok(p)) => Ok(Some(p)),
Ok(Err(e)) if e.is_empty() => Ok(None),
Ok(Err(e)) => Err(e),
Err(RecvTimeoutError::Timeout) => Err("auto-save timed out".into()),
Err(RecvTimeoutError::Disconnected) => Err(self.stopped_error()),
}
}
pub fn drain_events(&mut self) -> Vec<WorkerEvent> {
let ev: Vec<_> = self.events.try_iter().collect();
for e in &ev {
match e {
WorkerEvent::Journaled { revision, unix, serialize_ms, write_ms, bytes } => {
self.status.last_journal_unix = Some(*unix);
self.status.journaled_revision = *revision;
self.status.journals_written += 1;
(self.status.last_serialize_ms, self.status.last_write_ms, self.status.last_bytes) = (*serialize_ms, *write_ms, *bytes);
}
WorkerEvent::AutoSaved { path, unix, serialize_ms, write_ms, bytes, .. } => {
self.status.last_auto_save = Some(path.to_string_lossy().into_owned());
self.status.last_auto_save_unix = Some(*unix);
self.status.auto_saves_written += 1;
(self.status.last_serialize_ms, self.status.last_write_ms, self.status.last_bytes) = (*serialize_ms, *write_ms, *bytes);
}
WorkerEvent::SavedProject { .. } => {}
WorkerEvent::Error(m) => self.status.last_error = Some(m.clone()),
}
}
ev
}
/// Stop the worker. A session that still has a journal (closed with unsaved changes) keeps its
/// directory — marked as a clean exit — so the changes are offered next time; otherwise the
/// directory is removed.
pub fn close(mut self) {
if let Err(e) = self.flush() {
log::warn!("auto-save at shutdown: {e}");
}
self.stop_worker();
let snap = self.session_dir.join(SNAPSHOT);
self.lock.take();
if snap.is_file() {
if let Some(mut m) = fs::read(self.session_dir.join(META)).ok().and_then(|b| serde_json::from_slice::<JournalMeta>(&b).ok()) {
m.clean_exit = true;
let _ = filmcraft_format::atomic_write(&self.session_dir.join(META), &serde_json::to_vec_pretty(&m).unwrap_or_default());
}
} else {
let _ = fs::remove_dir_all(&self.session_dir);
}
}
/// Stop the worker and release the lock *without* cleaning up — what a crash leaves behind.
#[doc(hidden)]
pub fn simulate_crash(mut self) {
let _ = self.flush();
self.stop_worker();
self.lock.take();
}
fn stop_worker(&mut self) {
let _ = self.tx.send(Msg::Stop);
if let Some(t) = self.thread.take()
&& t.join().is_err()
{
self.failure.report();
}
}
/// Display form of a unix time in local time.
pub fn local_time(&self, unix: i64) -> String {
names::display_time(unix, (self.local_offset)(unix))
}
pub fn candidates_json(&self) -> Value {
Value::Array(
self.candidates
.iter()
.map(|c| {
let mut v = serde_json::to_value(c).unwrap_or_default();
v["savedAt"] = json!(self.local_time(c.meta.saved_unix));
v
})
.collect(),
)
}
}
impl Drop for Persistence {
fn drop(&mut self) {
self.stop_worker();
}
}
struct Worker {
data_dir: PathBuf,
session_dir: PathBuf,
local_offset: fn(i64) -> i32,
debounce: Duration,
prefs: AutoSavePrefs,
events: Sender<WorkerEvent>,
/// Newest unsaved state (None = clean).
latest: Option<Snapshot>,
/// Revision currently in the journal (0 = none) / last auto-saved revision.
journaled: u64,
autosaved: u64,
first_pending: Option<Instant>,
last_change: Instant,
next_autosave: Instant,
meta: JournalMeta,
}
impl Worker {
fn autosave_interval(&self) -> Duration {
Duration::from_secs(self.prefs.interval_minutes as u64 * 60)
}
fn journal_due(&self) -> Option<Instant> {
let s = self.latest.as_ref()?;
if !self.prefs.recovery_journal || s.revision == self.journaled {
return None;
}
let max = self.first_pending.unwrap_or(self.last_change) + Duration::from_secs(self.prefs.recovery_interval_seconds as u64);
Some((self.last_change + self.debounce).min(max))
}
fn run(mut self, rx: Receiver<Msg>) {
loop {
let due = [self.journal_due(), self.prefs.enabled.then_some(self.next_autosave)].into_iter().flatten().min();
let msg = match due {
Some(d) => match rx.recv_timeout(d.saturating_duration_since(Instant::now())) {
Ok(m) => Some(m),
Err(RecvTimeoutError::Timeout) => None,
Err(RecvTimeoutError::Disconnected) => return,
},
None => match rx.recv() {
Ok(m) => Some(m),
Err(_) => return,
},
};
match msg {
Some(Msg::Dirty(s)) => {
let now = Instant::now();
self.first_pending.get_or_insert(now);
self.last_change = now;
self.latest = Some(s);
}
Some(Msg::Clean) => {
self.latest = None;
self.first_pending = None;
self.clear_journal();
}
Some(Msg::Prefs(p)) => {
let was = self.autosave_interval();
let journal_was = self.prefs.recovery_journal;
self.prefs = p;
if self.autosave_interval() != was {
self.next_autosave = Instant::now() + self.autosave_interval();
}
if journal_was && !self.prefs.recovery_journal {
self.clear_journal();
}
}
Some(Msg::AutoSaveNow(reply)) => {
let r = if self.latest.is_some() { self.auto_save() } else { Err(String::new()) };
let _ = reply.send(r);
}
Some(Msg::Flush(ack)) => {
let result = match self.latest.as_ref() {
None => Ok(None),
Some(_) if !self.prefs.recovery_journal => Err("recovery journal is disabled".to_string()),
Some(s) if s.revision == self.journaled => Ok(Some(self.journaled)),
Some(_) => self.write_journal().map(Some),
};
let _ = ack.send(result);
}
Some(Msg::Stop) => return,
None => {}
}
let now = Instant::now();
if self.journal_due().is_some_and(|d| d <= now) {
// The worker reports write failures through its event channel.
let _ = self.write_journal();
}
if self.prefs.enabled && self.next_autosave <= now {
if self.latest.as_ref().is_some_and(|s| s.revision != self.autosaved) {
let _ = self.auto_save();
}
self.next_autosave = now + self.autosave_interval();
}
}
}
fn error(&self, e: String) {
log::warn!("auto-save: {e}");
let _ = self.events.send(WorkerEvent::Error(e));
}
fn write_journal(&mut self) -> Result<u64, String> {
let Some(s) = &self.latest else { return Err("no unsaved recovery state to write".into()) };
let t0 = Instant::now();
let bytes = filmcraft_format::encode(&s.project, false);
let serialize_ms = t0.elapsed().as_secs_f64() * 1000.0;
let t1 = Instant::now();
let unix = unix_now();
let mut meta = self.meta.clone();
meta.saved_unix = unix;
meta.revision = s.revision;
meta.project_name = s.project.name.clone();
meta.project_path = s.path.clone();
meta.bytes = bytes.len();
// Snapshot first, then the meta that makes it a candidate.
let r = filmcraft_format::atomic_write(&self.session_dir.join(SNAPSHOT), &bytes)
.and_then(|_| filmcraft_format::atomic_write(&self.session_dir.join(META), &serde_json::to_vec_pretty(&meta).unwrap_or_default()));
let write_ms = t1.elapsed().as_secs_f64() * 1000.0;
match r {
Ok(()) => {
self.journaled = s.revision;
self.first_pending = None;
let _ = self.events.send(WorkerEvent::Journaled { revision: s.revision, unix, serialize_ms, write_ms, bytes: bytes.len() });
Ok(s.revision)
}
Err(e) => {
// Try again at the next interval rather than spinning.
self.first_pending = Some(Instant::now());
self.last_change = Instant::now();
let message = format!("recovery journal: {e}");
self.error(message.clone());
Err(message)
}
}
}
fn clear_journal(&mut self) {
let _ = fs::remove_file(self.session_dir.join(META));
let _ = fs::remove_file(self.session_dir.join(SNAPSHOT));
self.journaled = 0;
}
fn auto_save(&mut self) -> Result<PathBuf, String> {
let Some(s) = &self.latest else { return Err("nothing to save".into()) };
let scratch = crate::project_tools::trusted_scratch(s.project.settings.scratch.auto_save.as_deref(), s.path.as_deref(), &self.prefs.scratch_folders);
let (dir, name) = match (&s.path, scratch) {
// Project Settings ▸ Scratch Disks ▸ Project Auto Save
(Some(p), Some(scratch)) => {
let p = Path::new(p);
(scratch, p.file_stem().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| s.project.name.clone()))
}
(Some(p), None) => {
let p = Path::new(p);
(names::auto_save_dir(p), p.file_stem().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| s.project.name.clone()))
}
(None, _) => (self.data_dir.join(names::AUTO_SAVE_DIR), s.project.name.clone()),
};
let t0 = Instant::now();
let bytes = filmcraft_format::encode(&s.project, false);
let serialize_ms = t0.elapsed().as_secs_f64() * 1000.0;
let t1 = Instant::now();
let unix = unix_now();
let r = names::write_auto_save(&dir, &name, unix, (self.local_offset)(unix), &bytes, self.prefs.max_versions as usize);
let write_ms = t1.elapsed().as_secs_f64() * 1000.0;
match r {
Ok(path) => {
self.autosaved = s.revision;
let _ = self.events.send(WorkerEvent::AutoSaved { path: path.clone(), revision: s.revision, unix, serialize_ms, write_ms, bytes: bytes.len() });
if self.prefs.save_current_project
&& let Some(p) = &s.path
{
match filmcraft_format::atomic_write(Path::new(p), &bytes) {
Ok(()) => {
let _ = self.events.send(WorkerEvent::SavedProject { path: p.clone(), revision: s.revision });
}
Err(e) => self.error(format!("saving {p}: {e}")),
}
}
Ok(path)
}
Err(e) => {
let m = format!("auto-save to {}: {e}", dir.display());
self.error(m.clone());
Err(m)
}
}
}
}
#[cfg(test)]
mod durability_tests {
use super::*;
#[test]
fn recovery_keeps_original_when_worker_has_stopped() {
let d = std::env::temp_dir().join(format!("fc-recover-worker-stopped-{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
let old_dir = recovery_root(&d).join("1-1");
fs::create_dir_all(&old_dir).unwrap();
let bytes = filmcraft_format::encode(&Project::default(), false);
let original = old_dir.join(SNAPSHOT);
fs::write(&original, &bytes).unwrap();
let mut session = crate::Session::default();
session.start_autosave(AutosaveConfig::new(&d)).unwrap();
session.persistence.as_mut().unwrap().stop_worker();
let result = session.execute("file.recover", json!({"id": "1-1"}));
assert!(original.is_file(), "a stopped worker must not consume the original snapshot");
assert_eq!(fs::read(&original).unwrap(), bytes);
assert_eq!(session.recovery_candidates().len(), 1);
assert!(result.unwrap_err().to_string().contains("worker stopped"));
session.shutdown();
fs::remove_dir_all(&d).unwrap();
}
}
#[cfg(test)]
mod worker_failure_tests {
use super::*;
use crate::{Event, Session};
fn session(tag: &str, offset: fn(i64) -> i32) -> (Session, PathBuf) {
let dir = std::env::temp_dir().join(format!("fc-worker-{tag}-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
let mut prefs = Preferences::default();
prefs.auto_save.recovery_journal = false;
prefs.save(&dir.join("preferences.json")).unwrap();
let mut s = Session::default();
s.execute("file.openDemoProject", json!({})).unwrap();
let mut cfg = AutosaveConfig::new(&dir);
cfg.local_offset = offset;
s.start_autosave(cfg).unwrap();
s.execute("sequence.addEdit", json!({"seconds": 0.5})).unwrap();
(s, dir)
}
fn failure_toasts(s: &mut Session) -> usize {
s.drain_events().into_iter().filter(|e| matches!(e, Event::Toast { error: true, .. })).count()
}
fn verify_report_and_foreground_save(s: &mut Session, dir: &Path) {
s.poll_persistence();
assert_eq!(s.execute("file.autoSaveStatus", json!({})).unwrap()["running"], false);
let message = s.persistence.as_ref().unwrap().status.last_error.as_deref().unwrap();
assert!(message.contains("stopped") && message.contains("Save"), "{message}");
assert_eq!(failure_toasts(s), 1, "worker failure must be visible exactly once");
let log: Vec<_> = s.log.entries.iter().filter(|e| e.source == "autosave").collect();
assert_eq!(log.len(), 1);
assert_eq!(log[0].count, 1);
let before = s.revision;
s.execute("sequence.addEdit", json!({"seconds": 1.0})).unwrap();
assert!(s.revision > before && s.is_dirty(), "the edit was applied despite autosave failure");
s.execute("prefs.set", json!({"key": "autoSave.maxVersions", "value": 7})).unwrap();
s.poll_persistence();
s.poll_persistence();
assert_eq!(failure_toasts(s), 0, "later handoffs must not repeat the failure");
let path = dir.join("manual.fcproj");
s.execute("file.saveAs", json!({"path": path.to_string_lossy()})).unwrap();
assert!(!s.is_dirty());
let loaded = filmcraft_format::decode(&fs::read(&path).unwrap()).unwrap();
assert_eq!(loaded.project, *s.project);
s.poll_persistence();
assert_eq!(failure_toasts(s), 0);
}
#[test]
fn worker_panic_is_contained_and_reported() {
fn broken_clock(_: i64) -> i32 {
panic!("synthetic worker clock failure")
}
let (mut s, dir) = session("panic", broken_clock);
let error = s.execute("file.autoSaveNow", json!({})).unwrap_err().to_string();
let start = Instant::now();
while !s.persistence.as_ref().unwrap().thread.as_ref().unwrap().is_finished() {
assert!(start.elapsed() < Duration::from_secs(10), "worker did not exit");
std::thread::sleep(Duration::from_millis(10));
}
let joined = s.persistence.as_mut().unwrap().thread.take().unwrap().join();
assert!(joined.is_ok(), "panic escaped the autosave worker boundary");
assert!(error.contains("stopped") && !error.contains("timed out"), "{error}");
verify_report_and_foreground_save(&mut s, &dir);
s.shutdown();
fs::remove_dir_all(dir).unwrap();
}
fn disconnected_handoff(tag: &str) {
let (mut s, dir) = session(tag, |_| 0);
s.persistence.as_mut().unwrap().stop_worker();
match tag {
"dirty" => {
s.execute("sequence.addEdit", json!({"seconds": 2.0})).unwrap();
}
"clean" => {
s.execute("file.saveAs", json!({"path": dir.join("initial.fcproj").to_string_lossy()})).unwrap();
}
"prefs" => {
s.execute("prefs.set", json!({"key": "autoSave.maxVersions", "value": 3})).unwrap();
}
"flush" => {
assert!(s.persistence.as_ref().unwrap().flush().unwrap_err().contains("worker stopped"));
}
"request" => {
assert!(s.execute("file.autoSaveNow", json!({})).unwrap_err().to_string().contains("stopped"));
}
_ => panic!("unknown test handoff"),
}
verify_report_and_foreground_save(&mut s, &dir);
s.shutdown();
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn worker_disconnect_dirty_reports_once() {
disconnected_handoff("dirty");
}
#[test]
fn worker_disconnect_clean_reports_once() {
disconnected_handoff("clean");
}
#[test]
fn worker_disconnect_preferences_reports_once() {
disconnected_handoff("prefs");
}
#[test]
fn worker_disconnect_flush_reports_once() {
disconnected_handoff("flush");
}
#[test]
fn worker_disconnect_flush_reply_reports_once() {
let (mut s, dir) = session("flush-reply", |_| 0);
s.persistence.as_mut().unwrap().stop_worker();
let (tx, rx) = channel();
s.persistence.as_mut().unwrap().tx = tx;
let worker = std::thread::spawn(move || match rx.recv().unwrap() {
Msg::Flush(reply) => drop(reply),
_ => panic!("expected a flush request"),
});
let error = s.persistence.as_ref().unwrap().flush().unwrap_err();
worker.join().unwrap();
assert!(error.contains("worker stopped"), "{error}");
verify_report_and_foreground_save(&mut s, &dir);
s.shutdown();
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn worker_disconnect_request_reports_once() {
disconnected_handoff("request");
}
#[test]
fn worker_remains_available_after_an_ordinary_write_error() {
let (mut s, dir) = session("write-error", |_| 0);
let blocked = dir.join(names::AUTO_SAVE_DIR);
fs::write(&blocked, b"occupied directory path").unwrap();
assert!(s.execute("file.autoSaveNow", json!({})).is_err());
s.poll_persistence();
assert_eq!(s.execute("file.autoSaveStatus", json!({})).unwrap()["running"], true);
assert!(s.persistence.as_ref().unwrap().status.last_error.as_deref().unwrap().contains("auto-save to"));
assert_eq!(failure_toasts(&mut s), 1);
fs::remove_file(&blocked).unwrap();
let saved = s.execute("file.autoSaveNow", json!({})).unwrap();
assert!(Path::new(saved["path"].as_str().unwrap()).is_file());
assert!(s.is_dirty(), "auto-save should not mark the foreground project saved");
s.shutdown();
fs::remove_dir_all(dir).unwrap();
}
}
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.